方法名 | 说明 |
---|---|
public String() | 创建一个空白字符串对象,不含有任何内容 |
public String(char[] chs) | 根据字符数组的内容,来创建字符串对象 |
public String(byte[] bys) | 根据字节数组的内容,来创建字符串对象 |
String s = “abc”; | 直接赋值的方式创建字符串对象,内容就是abc |
方法名称 | 描述 |
---|---|
public char charAt(int index) | 返回指定索引位置的字符 |
public char[] toCharArray() | 将字符串以字符数组的形式返回 |
public byte[] getBytes() | 将字符串变为字节数组 |
public byte[] getBytes(String charsetName) | 指定编码转换 |
public boolean equals(Object anObject) | 区分大小写的字符串比较(是否相等) |
public boolean equalsIgnoreCase(String anotherString) | 不区分大小的字符串比较(是否相等) |
public boolean startsWith(String prefix) | 判断是否以某个字符串开头 |
public boolean endsWith(String suffix) | 是否以某个字符串结尾 |
public boolean contains(CharSequence s) | 判断某一个字符串是否存在 |
public String substring(int beginIndex) | 从指定索引位置(包含该位置的字符)截取至末尾 |
public String substring(int beginIndex, int endIndex) | 截取指定索引范围内的字符串(包含起始索引,不包含end索引) |
public String replaceAll(String regex,String replacement) | 字符串的全部替换 |
public String replaceFirst(String regex,String replacement) | 替换第一个内容 |
public String[] split(String regex) | 字符串按照指定字符拆分 |
public int length() | 获取字符串长度 |
public String toUpperCase() | 将字符串中字母转大写 |
public String toLowerCase() | 将字符串中字母转小写 |
public boolean isEmpty() | 判断是否为空(“”),若是返回true,否则返回false |
public int compareTo(String anotherString) | 返回this - anotherString的字典值(依次比较字符串中字符ASCII码) |
public boolean matches(String regex) | 对字符串进行正则匹配,匹配正确返回true,错误返回f |
public void String trim() | 去掉字符串前后空白符 |
public String intern() | 将字符串的结果在常量池中生成并返回常量池中的地址 |
方法名 | 说明 |
---|---|
public StringBuilder() | 构造一个不带任何字符的字StringBuilder对象 |
public StringBuilder(String original) | 根据传入的字符串内容来创建StringBuilder对象 |
法名 | 说明 |
---|---|
public StringBuilder insert(索引,数据) | 将给定内容的字符串表示形式插入到字符串指定索引位置中 |
public StringBuilder append(数据) | 添加数据并返回对象本身 |
public StingBuilder reverse() | 将字符串对象取反 |
public String toString() | 把StingBuilder类型转换为Sting |
public int length() | 获取StingBuilder对象的长度 |
StringBuffer中的成员方法与StringBuilder相同,但StringBuffer中的成员方法都是同步方法
方法名 | 说明 |
---|---|
public StringJoiner(CharSequence delimiter , CharSequence prefix , CharSequence suffix) |
指定拼接时的间隔符号开始符号、结束符号创建对象 |
public StringJoiner(CharSequence delimiter) | 指定拼接时的间隔符号创建对象 |
法名 | 说明 |
---|---|
public StringJoiner add(数据) | 添加数据并返回对象本身 |
public String toString() | 把StringJoiner类型转换为String |
public int length() | 获取StringJoiner对象的长度 |
Math类中的方法都是静态的
public static int abs(int a) // 返回参数的绝对值
public static double ceil(double a) // 返回大于或等于参数的最小整数
public static double floor(double a) // 返回小于或等于参数的最大整数
public static int round(float a) // 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b) // 获取两个int值中的较大值
public static int min(int a,int b) // 获取两个int值中的较小值
public static double pow (double a,double b) // 计算a的b次幂的值
public static double random() // 返回一个[0.0,1.0)的随机值
System类中的方法都是静态的
public static long currentTimeMillis()// 获取当前时间所对应的毫秒值(1970年1月1日00:00:00)
public static void exit(int status)// 终止当前正在运行的JVM(0表示正常退出,非零表示异常退出)
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// 将源数组中的数据复制到目标数组中
// src: 源数组
// srcPos: 源数值的开始位置
// dest: 目标数组
// destPos: 目标数组开始位置
// length: 要复制的元素个数
arraycopy方法底层细节
1.数据源数组和目的地数组数组项为基本数据类型:对源数组中数据存储的值进行拷贝;两者的类型保持一致
2.数据源数组和目的地数组数组项为引用数据类型:对源数组中数据存储的地址进行拷贝(浅克隆)
3.源数组的子类类型可以赋值给目的地数组的父类类型(多态)
Runtime表示Java中运行时对象,可以获取到程序运行时设计到的一些信息
Runtime对象唯一(类只创建一个对象)
public static Runtime getRuntime() //获取当前系统的运行环境对象
public void exit(int status) //停止虚拟机(System中exit方法底层原理)
public int availableProcessors() //获得CPU的线程数
public long maxMemory() //JVM能从系统中获取堆总内存大小(单位B)
public long totalMemory() //JVM已经从系统中获取对总内存大小(单位B)
public long freeMemory() //JVM剩余堆内存大小(单位B)
public Process exec(String command) //运行cmd命令
查看API文档我们可以看到,在Object类中只提供了一个无参构造方法
Object 是类层次结构的根,每个类都可以将 Object 作为超类:该类所具备的方法会被其他所有类都继承
public String toString() //返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj) //比较两个对象地址值是否相等;true表示相同,false表示不相同
protected Object clone() //对象克隆(默认的是浅克隆)
public final void wait() //使该线程处于等待状态,需要使用notify来唤醒,会释放同步监视器
public final native void wait(long timeoutMillis) //使该线程处于计时等待状态,会释放同步监视器
public final native void notify() //唤醒被wait的高优先级的线程
public final native void notifyAll() //唤醒被wait的全部线程
对象克隆clone
把A对象的属性值完全拷贝给B对象
1 浅克隆:
对象内部的属性都完全拷贝过来 :属性为基本数据类型拷贝过来的是具体的数据,属性为引用数据类型拷贝过来的是地址值(源对象和目的对象若属性为引用数据类型则有关系)
2 深克隆(源对象和目的对象没有关系):
属性为基本数据类型拷贝过来的是具体的数据,字符串复用,属性为引用数据类型会重新创建新的引用数据类型对象(源对象和目的对象属性之间没有关系)
2.1类中重写clone()深克隆思路
1为该类实现Cloneable克隆标记接口
2为源对象引用数据类型的属性创建新对象
3将源对象中引用数据类型属性的数据添加到新对象中
4使用super.clone()获取拷贝后的对象
5将引用数据类型的属性赋值给拷贝的对象
//实现Cloneable标记接口
public class User implements Cloneable{
private int id;
private String username;
private String password;
private String path;
private int[] data;
//构造方法、get、set方法
...
//重写clone方法
@Override
protected Object clone() throws CloneNotSupportedException {
// private String username;
// private String password;
// private String path;
// private int[] data;
//为引用数据类型的属性创建新对象(深克隆)
//String为不可变对象不需要创建新对象,只需要对data创建对象
//创建新的数组
int[] newArr = new int[data.length];
//将源对象中引用数据类型属性的数据添加到新对象中
System.arraycopy(data,0,newArr,0, data.length);
//获取拷贝后的对象
User cloneUser = (User) super.clone();
//引用数据类型的属性创建新对象(深克隆)
cloneUser.data = newArr;
return cloneUser;
//浅克隆
//return super.clone();
}
2.2深克隆工具
https://www.bilibili.com/video/BV17F411T7Ao/?p=160&spm_id_from=pageDriver&vd_source=2f262ab3519a1a86f6fec9b9b439dca6
扩展Object,Objects类中的方法都是静态的
public static String toString(Object o) //获取对象的字符串表现形式
public static boolean equals(Object a, Object b)//比较两个对象是否相等(底层先判断a是否为null)
public static boolean isNull(Object obj) //判断对象是否为null
public static boolean nonNull(Object obj) //判断对象是否不为null
了解的常见方法如下所示
public static <T> T requireNonNull(T obj) // 检查对象是否不为null,如果为null直接抛出异常;如果不是null返回该对象;
public static <T> T requireNonNullElse(T obj, T defaultObj) // 检查对象是否不为null,如果不为null,返回该对象;如果为null返回defaultObj值
public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier) // 检查对象是否不为null,如果不为null,返回该对象;如果为null,返回由Supplier所提供的值
我们可以使用BigInteger类进行大整数的计算
构造方法
public BigInteger(int num, Random rnd) //获取随机大整数,范围:[0 ~ 2的num次方-1]
public BigInteger(String val) //获取指定的大整数
//注意事项:
//只能是数字字符串
public BigInteger(String val, int radix) //获取指定进制的大整数,radix表示进制
//下面这个不是构造,而是一个静态方法获取BigInteger对象
public static BigInteger valueOf(long val) //静态方法获取BigInteger的对象
//注意事项:
//1.能表示范围比较小,只能在long的取值范围之内
//2.在内部对常用的数字[-16 ~ 16]进行了优化:类加载时提前把[-16~16]先创建好BigInteger的对象,通过该方法不用创建就直接获取BigInteger对象
构造方法小结
常见成员方法
BigDecimal类中使用最多的还是提供的进行四则运算的方法,如下:
public BigInteger add(BigInteger val) //加法
public BigInteger subtract(BigInteger val) //减法
public BigInteger multiply(BigInteger val) //乘法
public BigInteger divide(BigInteger val) //除法,获取商
public BigInteger[] divideAndRemainder(BigInteger val)//除法,获取商(0索引)和余数(1索引)
public boolean equals(Object x) //比较对象属性是否相同
public BigInteger pow(int exponent) //次幂、次方
public BigInteger max(BigInteger val) //返回较大值(不会创建对象)
public BigInteger min(BigInteger val) //返回较小值(不会创建对象)
public int intValue(BigInteger val) //转为int类型整数,超出范围数据错误(强转)
public long intLong(BigInteger val) //转为long类型整数,超出范围数据错误(强转)
public double intDouble(BigInteger val) //转为double类型整数,超出范围数据错误(强转)
BigInteger对象在在实际存储的时:
1先把BigInteger对象具体的数字变成二进制
2以每32个bit(int类型占用4B)将BigInteger对象分为若干组,符号位单独存入signum成员变量中
3将每组数据存储在mag成员变量数组中
存储方式如图所示:
BigInteger的存储上限:
数组中最大索引(索引为int类型):int数据类型正数最大值 → 2^(32-1)-1
int类型数组中每一位能表示的**无符号最大值 **→ 2^32
BigInteger理论能表示的最大数字为: 2^32的 2^(32-1)-1次方 = 42亿的21亿次方
表示较大的小数和解决小数运算精度失真问题。
构造方法
public BigDecimal(String val) //通过字符串获取指定的BigDecimal对象(推荐)
//注意事项:
//可以为小数字符串
public BigDecimal(double val) //通过double数据获取指定的BigDecimal对象(不推荐)
//注意事项:
//会在创建BigDecimal对象时损失精度
public static BigDecimal valueOf(long val) //静态方法获取BigDecimal的对象
//注意事项:
//1.能表示范围比较小,只能在double的取值范围之内
//2.在内部对常用的数字[0 ~ 10]进行了优化:类加载时提前把[0 ~ 10]先创建好BigDecimal的对象,通过该方法不用创建就直接获取BigDecimal对象
public static BigDecimal valueOf(double val) //静态方法获取BigDecimal的对象
//注意事项:
//底层将double数据转换为字符串创建BigDecimal对象
常见成员方法
public BigDecimal add(BigDecimal value) // 加法运算
public BigDecimal subtract(BigDecimal value) // 减法运算
public BigDecimal multiply(BigDecimal value) // 乘法运算
public BigDecimal divide(BigDecimal value) // 除法运算
//注意事项:除不尽会报错,用下面的dividedivide重载方法
public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
//divisor: 除数对应的BigDecimal对象
//scale: 精确的位数(小数点后几位)
//roundingMode: 舍入模式;取舍模式被封装到了RoundingMode这个枚举类中
//最常见的取舍方式有如下几个:UP(直接进1) , FLOOR(直接删除) , HALF_UP(4舍五入)
把数据看成字符串,BigDecimal底层数组存储字符串中每一个字符的ASCII码值。
正则表达式就是用来验证各种字符串的规则,从左往右依次匹配
2.1字符(匹配单个字符)
表达式 | 代表意义 |
---|---|
[abc] | 代表a、b、c字符中的一个(省略|) |
[^abc] | 任何字符 - a、b、c |
[a-z] | 代表a-z之间小写字符中的一个 |
[A-Z] | 代表A-Z之间大写字符中的一个。 |
[0-9] | 代表0-9之间的某一个数字字符 |
[a-z[A-Z]] 或 [a-zA-Z] | 代表a-z、A-Z之间的某一个字符 |
[a-z&&[^\d]] | 二元运算符,代表a-z与任何字符 - [0-9]的交集 |
2.2 预定义字符(匹配单个字符)
表达式 | 代表意义 |
---|---|
. | 匹配任何字符(\n回车符号不匹配) |
\d | \d 任何数字:[0-9]的简写 |
\D | \D 任何非数字:[^0-9]的简写 |
\s | 空白字符:[ \t\n\x0B\f\r] 的简写 |
\S | 非空白字符:[^\s] 的简写 |
\w | 单词字符:[a-zA-Z_0-9]的简写(有下划线_) |
\W | 非单词字符:[^\w]的简写 |
2.3 逻辑运算符
表达式 | 代表意义 |
---|---|
| | 二元运算符或,满足一个条件即可(必须使用()将|包围(限定范围) |
ab | 相当于ab字符串 |
\ | 转义字符:改变字符原本的意思 |
2.4 数量词
贪婪爬取:在爬取数据的时候尽可能的多获取数据,达到最高要求
X表示一组字符或一个字符
表达式 | 代表意义 |
---|---|
X? | 表示E组出现0次或1次[0,1] |
X* | 表示E组出现0次到多次[0,+∞] |
X+ | 表示E组出现1次或多次[1,+∞] |
X{n} | 表示E组出现恰好n次 |
X{n,} | 表示E组出现至少n次[n,+∞] |
X{n,m} | 示E组出现n到m次(n和m都是包含的)[n,m] |
非贪婪爬取:在爬取数据的时候尽可能的少获取数据,达到最低要求(贪婪表达式后加?,例如??、*?、+?):
表达式 | 代表意义 |
---|---|
X?? | 表示E组出现0次或1次[0,1],非贪婪爬取 |
2.5 分组
表达式 | 代表意义 |
---|---|
(正则) | 分组,匹配括号里的整个表达式 |
组号:识别分组,规则:
捕获分组:可以通过组号引用一组字符(相当于复制的分组
表达式 | 代表意义 |
---|---|
\num | 正则表达式内引用第num组的内容(Java中使用\\num) |
$num | 正则表达式外引用第num组的内容(方法有regex以外的其他参数考虑使用;Java中使用$num) |
非捕获分组:不占用组号的分组
表达式 | 代表意义 |
---|---|
(?:正则) | 获取该组前后所有部分(常用),例如C(?:ode)C能匹配HouCodeC中的CodeC |
(?=正则) | 获取该组前面部分,例如Code(?=Hou)能匹配CodeHou中的Code |
(?!正则) | 获取不是组的前面部分,例如Code(?!Hou)能匹配CodeChar中的Code |
(?<=正则) | 获取该组后面部分,例如(?<=Hou)Code能匹配HouCode中的Code |
(? | 获取不是组的后面部分,例如(?<=Hou)Code能匹配CharCode中的Code |
2.6 其他
(?i)X:X分组忽略大小写
通过Pattern静态方法获取正则表达式对象Pattern
方法名 | 说明 |
---|---|
static Pattern compile(String regex) | 将给定的正则表达式编译为模式 |
通过Pattern对象获取文本匹配器
方法名 | 说明 |
---|---|
Matcher matcher(CharSequence input) | 创建匹配给定输入的匹配器 |
通过Matcher对象匹配符合正则条件的子串
方法名 | 说明 |
---|---|
boolean find() | 尝试查找与该模式匹配的输入序列的下一个子序列 |
String group() | 返回所匹配的全部序列(底层参数为group(0)) |
String group(int group) | 返回所匹配全部序列中对应group组的子序列 |
Pattern p = Pattern.compile(regex);//获取正则表达式对象
Matcher m = p.matcher(str);//通过正则表达式对象获取文本匹配器对象
while (m.find()) {//find从上次位置寻找子串:找到返回true并在底层记录索引,没有找到返回false
System.out.println(m.group());//通过find记录的索引返回子串
}
构造方法
方法名 | 说明 |
---|---|
public Date() | 分配一个 Date对象,使用系统当前毫秒值在原点时间上的初始化 |
public Date(long date) | 分配一个 Date对象,使用指定的毫秒值在原点时间上的初始化 |
成员方法
public long getTime() //把日期对象转换成对应的时间毫秒值
public void setTime(long time) //把方法参数给定的毫秒值设置给日期对象
//中国是东八区,所以系统默认在后面加8小时毫秒值
应用场景:我们通过这个类可以帮我们在Date对象与String对象之间进行来回转换。
构造方法
public SimpleDateFormat();//用默认的模式构造SimpleDateFormat
public SimpleDateFormat(String pattern);//用指定的日期格式符号构造SimpleDateFormat
//注意事项
//参数pattern代表日期时间的自定义格式,例如:yyyy-MM-dd HH-mm-ss EE
格式规则
更详细的格式规则,可以参考SimpleDateFormat类的API文档:
标识字母(区分大小写) | 含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
3 常用方法
public String format(Date date);//将Date对象格式化为字符串。
public Date parse(String source);//将字符串解析为Date对象
1 概述
2 常用方法
获取GregorianCalendar对象(使用静态方法获取Instant对象)
public static Calendar getInstance(); //静态方法,获取一个它的子类GregorianCalendar对象
//默认获取当前时间,单例设计模式
常用:
public final Date getTime(); //获取当前日历的日期对象
public long getTimeInMillis(); //拿到当前日历的时间毫秒值
public int get(int field); //获取某个字段的值。
public void add(int field,int amount); //为字段增加(amount>0)/减少(amount<0)指定的值
//增加或减少的值超过对应字段的值则高一级的字段会修改
不常用,会更改当前日历的时间:
public final Date setTime(Date date); //给日历设置日期对象,不常用
public void set(int field,int value); //设置某个字段的值,不常用
public long setTimeInMillis(long Millis); //给当前日历对象的设置时间毫秒值,不常用
//中国是东八区,所以系统默认在后面加8小时毫秒值
3 注意事项:
field参数表示获取哪个字段的值,可以使用Calender中自定义的常量来表示:
Calendar.YEAR : 年
Calendar.MONTH :月;注意:Calendar中的月份范围0-11(需要+1变为1-12月)
Calendar.DAY_OF_MONTH:月中的日期
Calendar.HOUR:小时
Calendar.MINUTE:分钟
Calendar.SECOND:秒
Calendar.DAY_OF_WEEK:星期中的日期;注意:范围为1-7(表示星期日-星期六)
JDK8时间类类名 | 作用 |
---|---|
相当于JDK7中的Date | |
ZoneId | 时区 |
Instant | 时间戳 |
ZoneDateTime | 带时区的时间戳 |
相当于JDK7中的Calendar | |
LocalDate | 年、月、日 |
LocalTime | 时、分、秒 |
LocalDateTime | 年、月、日、时、分、秒 |
相当于JDK7中的SimpleDateFormat | |
DateTimeFormatter | 用于时间的格式化和解析 |
计算时间间隔工具类 | |
Duration | 工具类:计算时间间隔(秒,纳,秒) |
Period | 工具类:计算日期间隔(年,月,日) |
ChronoUnit | 工具类:计算时间间隔(所有单位) |
调用方法需要改变时间对象的值时会重新创建一个时间对象(时间对象类:Instant、ZoneDateTime、LocalDate、LocalTime、LocalDateTime),解决多线程中同时访问问题
地球中不同位置有不同的时间,时区可以理解为原点时间的偏移(例如北京所在的时区时间为:原点时间+8小时)
//ZoneId静态方法
public static Set<String> getAvailableZoneIds() //获取Java中支持的所有时区字符串
public static ZoneId systemDefault() //获取系统默认时区
public static Zoneld of(string zoneld) //通过时区字符串获取一个指定时区
时间戳:以原点时间开始的标准时间,相当于某一个时刻,不可变对象
public static Instant now() //获取当前时间的Instant对象(标准时间)
public static Instant ofEpochMilli(long epochMilli)//根据毫秒获取Instant对象
//ofEpochSecond方法重载:
public static Instant ofEpochSecond(long epochSecond)//根据秒获取Instant对象
public static Instant ofEpochSecond(long epochSecond,long nanoAdjustment)//秒+纳秒获取
public ZoneDateTime atZone(ZoneId zone) //根据当前时间戳获取带时区的ZoneDateTime对象
public boolean isBefore(Instant otherInstant) //判断调用者代表的时间是否在参数表示时间的前面
public boolean isAfter(Instant otherInstant) //判断调用者代表的时间是否在参数表示时间的后面
//减少时间戳系列的方法
public Instant minusSeconds(long secondsToSubtract) //将调用者时间戳对象往前移动指定的秒值
public Instant minusMillis(long millisToSubtract) //将调用者时间戳对象往前移动指定的毫秒值
public Instant minusNanos(long nanosToSubtract) //将调用者时间戳对象往前移动指定的纳秒值
//增加时间戳系列的方法
public Instant plusSeconds(long secondsToSubtract) //将调用者时间戳对象往后移动指定的秒值
public Instant plusMillis(long millisToSubtract) //将调用者时间戳对象往后移动指定的毫秒值
public Instant plusNanos(long nanosToSubtract) //将调用者时间戳对象往后移动指定的纳秒值
ZonedDateTime对象相当于Instant对象 + ZoneId时区时间,即带时区的时间
public static ZonedDateTime now() //获取当前时间的ZonedDateTime对象
public static ZonedDateTime ofXxxx(形参列表) //根据指定参数获取ZonedDateTime对象
//ChronoZonedDateTime是ZonedDateTime实现的接口
public boolean isBefore(ChronoZonedDateTime<?> other);//判断调用者是否在参数前面
public boolean isAfter(ChronoZonedDateTime<?> other);//判断调用者是否在参数后面
public ZonedDateTime withXxx(时间) //修改时间系列的方法
public ZonedDateTime minusXxx(时间) //减少时间系列的方法
public ZonedDateTime plusXxx(时间) //增加时间系列的方法
//静态方法
public static ZonedDateTime parse(String text);//将字符串解析为ZonedDateTime对象
年、月、日日历
public static LocalDate now();//获取当前时间的日历对象(包含:年、月、日);默认系统时区
public static LocalDate of(形参列表)//获取指定的时间的日历对象
public xxx getXxx(形参列表)//get系列方法获取日历中的某一个属性值
//注意事项:
//获取月对应的int值
//方式一:使用Month中的getValue()方法
Month m = ldDate.getMonth();
System.out.println(m.getValue());
//方式二:直接使用LocalDate中的getMonthValue()
int month = ldDate.getMonthValue();
//ChronoLocalDate是LocalDate实现的接口
public boolean isBefore(ChronoLocalDate other);//判断调用者是否在参数前面
public boolean isAfter(ChronoLocalDate other);//判断调用者是否在参数后面
public LocalDate withXxx(形参列表)//with开头的方法表示修改,只能修改年月日
public LocalDate minusXxx(形参列表)//minus开头的方法表示减少,只能减少年月日
public LocalDate plusXxx(形参列表)//plus开头的方法表示增加,只能增加年月日
//静态方法
public static LocalDate parse(String text);//将字符串解析为LocalDate对象
时、分、秒日历
public static LocalTime now();//获取当前时间的日历对象(包含:时、分、秒系列);默认系统时区
public static LocalTime of(形参列表)//获取指定的时间的日历对象
public xxx getXxx(形参列表)//get系列方法获取日历中的某一个属性值
public boolean isBefore(LocalTime other);//判断调用者是否在参数前面
public boolean isAfter(LocalTime other);//判断调用者是否在参数后面
public LocalDate withXxx(形参列表)//with开头的方法表示修改,只能修改时、分、秒
public LocalDate minusXxx(形参列表)//minus开头的方法表示减少,只能修改时、分、秒
public LocalDate plusXxx(形参列表)//plus开头的方法表示增加,只能修改时、分、秒
//静态方法
public static LocalTime parse(String text);//将字符串解析为LocalTime,例如:13:14,13:14:20,13:14:20.500。
年、月、日、时、分、秒日历
public static LocalDateTime now();//获取当前时间的日历对象(包含全部);默认系统时区
public static LocalDateTime of(形参列表)//获取指定的时间的日历对象
public xxx getXxx(形参列表)//get系列方法获取日历中的某一个属性值
public LocalDate toLocalDate()//转换成一个LocalDate对象
public LocalTime toLocalTime()//转换成一个LocalTime对象
//ChronoLocalDateTime是LocalDate实现的接口
public boolean isBefore(ChronoLocalDateTime<?> other);//判断调用者是否在参数前面
public boolean isAfter(ChronoLocalDateTime<?> other);//判断调用者是否在参数后面
public LocalDateTime withXxx(形参列表)//with开头的方法表示修改
public LocalDateTime minusXxx(形参列表)//minus开头的方法表示减少
public LocalDateTime plusXxx(形参列表)//plus开头的方法表示增加
//静态方法
public static LocalDateTime parse(String text);//将字符串解析为LocalDateTime对象
public static DateTimeFormatter ofPattern(String format) //获取指定日期时间格式对象
LocalDate、LocalTime、LocalDateTime、ZonedDateTime实现了TemporalAccessor接口
public String format(TemporalAccessor 时间对象) //将实现TemporalAccessor接口的时间对象按照指定方式格式化
//解析使用相应时间对象的静态方法parse
计算日期间隔(年,月,日)
//第二个参数减第一个参数:endInclusive - startInclusive,返回Period类的对象
public static Period between(LocalDate startDateInclusive,LocalDate endDateExclusive)
//非静态方法
public int getYears() //两个时间的 年end - 年2start
public int getMonths() //两个时间差的 月end - 月2start
public int getDays() //两个时间差的日 日end - 日2start
public long toTotalMonths() //两个时间差的总月数
计算时间间隔(秒,纳,秒)
//第二个参数减第一个参数:endInclusive - startInclusive,返回Duration类的对象
//Temporal是LocalDateTime、LocalTime、LocalDate类实现的接口
public static Duration between(Temporal startInclusive, Temporal startInclusive)
//非静态方法
public long toDays() //两个时间差的总天数
public long toHours() //两个时间差的总小时数
public long toMinutes() //两个时间差的总分钟数
public long toMillis() //两个时间差的总毫秒数
public long toNanos() //两个时间差的总纳秒数
计算时间间隔(所有单位)
//第二个参数减第一个参数:endInclusive - startInclusive,返回Duration类的对象
//Temporal是LocalDateTime、LocalTime、LocalDate类实现的接口
public long between(Temporal startInclusive, Temporal endInclusive)
System.out.println("相差的年数:" + ChronoUnit.YEARS.between(start, today));
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(start, today));
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(start, today));
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(start, today));
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(start, today));
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(start, today));
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(start, today));
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(start, today));
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(start, today));
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(start, today));
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(start, today));
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(start, today));
System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(start, today));
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(start, today));
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(start, today));
基本类型对应的包装类(引用数据类型),如下:
基本类型 | 对应的包装类(位于java.lang包中) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
非浮点数(整数、布尔、字符)使用valueOf方法获取其对应的包装类底层都有优化,避免浪费内存(提前创建了常用数据的对象)
包装类缓存对象
包装类 | 缓存对象 |
---|---|
Byte | -128~127 |
Short | -128~127 |
Integer | -128~127 |
Long | -128~127 |
Float | 没有 |
Double | 没有 |
Character | 0~127 |
Boolean | true和false |
Integer类概述
包装一个对象中的原始类型 int 的值
Integer类常用静态方法
//底层创建了[-128,127]范围常用的Integer对象
public static Integer valueOf(int i) //通过int类型参数获取Integer对象
public static Integer valueOf(String s) //通过String类型参数获取Integer对象
public static string toBinarystring(int i) //将int参数转换为二进制字符串
public static string toOctalstring(int i) //将int参数转换为八进制字符串
public static string toHexstring(int i) //将int参数转换为十六进制字符串
public static int parseInt(string s) //将整数字符串解析为int类型的整数
Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE
2.1 装箱与拆箱
用Integer与 int为例:
基本数值---->包装对象;底层使用valueOf(int i)
Integer integer = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值;底层使用intValue
int num = i.intValue();
2.2 自动装箱与自动拆箱
从JDK 5开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
2.3 基本类型与字符串之间的转换
//方式1:直接在数字后加一个空字符串
String s1 = number + "";
//方式2:通过String类静态方法valueOf()
//public static String valueOf(int i)
String s2 = String.valueOf(number);
//方式一:String --- Integer --- int
Integer integer = Integer.valueOf("100");
int i = integer.intValue();
//方式二:通过Integer静态方法parseInt()进行转换(除了Character包装类之外)
public static byte parseByte(String s) //将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s) //将字符串参数转换为对应的short基本类型。
public static int parseInt(String s) //将字符串参数转换为对应的int基本类型
public static long parseLong(String s) //将字符串参数转换为对应的long基本类型
public static float parsefloat(String s) //将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s) //将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s) //将字符串参数转换为对应的boolean基本类型。
操作数组的工具类,Arrays类中的方法都是静态的
public static <T> List<T> asList(T... a) //将数组转化为ArrayList集合
public static String toString(int[] arr) //返回数组字符串形式的内容
public static void fill(int[] arr, int val) //使用指定值填充数组中全部元素
//二分搜索数组中的数据,存在返回索引,不存在返回-1
public static int binarySearch(int[] arr, int key)
//注意事项:
1,数组必须是升序
2,找到则返回key位于数组的索引,找不到则返回-(key应该的存在位置 + 1)
//为什么+1:若元素应该存在0索引则返回-0会引起歧义
public static int[] copyOf(int[] original, int newLength)
//拷贝original数组到长度为newLength的新数组中,底层通过System.arraycopy方法实现(浅克隆)
public static int[] copyOfRange(int[] original, int from, int to)
//范围拷贝(包头不包尾);将源数组从from起始索引到 to - 1 索引的元素拷贝到新数组中
public static void sort(int[] arr) //对数组进行默认升序排序,底层通过快速排序实现
public static <T> void sort(T[] arr, Comparator<? super T> c)
//注意事项
//底层通过插入排序和二分查找实现,默认把0索引当做有序的序列,1索引到最后为无序的序列;
//遍历无序的序列得到里面的每一个元素,假设当前遍历得到的元素是A元素,把A往有序序列中进行插入
//在插入的时候,是利用二分查找确定A元素的插入点。拿着A元素,跟插入点的元素进行比较,
//比较的规则就是compare方法的方法体
//如果方法的返回值是负数,拿着A继续跟前面的数据进行比较
//如果方法的返回值是正数,拿着A继续跟后面的数据进行比较
//如果方法的返回值是0,也拿着A跟后面的数据进行比较
//直到能确定A的最终位置为止
//使用比较器对象自定义排序,o1表示无序序列被遍历的每一个元素,o2表示有序的元素
1,调用方法时需要重写Comparator接口中的compare方法
//public int compare(T o1, T o2)
2,compare方法规则:
当compare返回负数:o1元素需要在o2元素前面
当compare返回正数:o1元素需要在o2元素后面
当compare返回0:o1元素与o2元素位置不变
Collection是单例集合的顶层接口
方法名 | 说明 |
---|---|
public abstract boolean add(E e) | 添加元素 |
public abstract boolean addAll(Collection c) | 通过Collection集合作为参数批量添加元素 |
public abstract boolean remove(Object o) | 从集合中移除指定的元素 |
public default boolean removeIf(Predicate filter | Predicate接口中text方法返回true删除元素,false保留元素 |
public abstract boolean removeAll(Collection coll) | 从当前集合中删除所有与coll集合中相同的元素 即:this = this - this ∩ coll (删除一个就返回true) |
public abstract boolean retainAll(Collection coll) | 使得当前集合仅保留与coll集合中的元素相同的元素 即:this = this ∩ coll |
public abstract void clear() | 清空集合中的元素 |
public abstract boolean contains(Object o) | 判断集合中是否存在指定的元素 |
public abstract boolean containsAll(Collection coll) | 判断集合中是否存是指定集合的子集 |
public abstract boolean isEmpty() | 判断集合是否为空 |
public abstract int size() | 集合的长度,也就是集合中元素的个数 |
public default void forEach(Consumer action) | 遍历集合,重写accept方法 |
public abstract T[] toArray(T[] a) | 将集合的元素存入方法参数对应类型的数组中 |
public abstract Iterator iterator() | 获取迭代器对象 |
注意事项:使用remove系列方法、contains系列方法、retainAll()方法时,集合泛型类需要重写equals方法
增加了操作索引的方法
方法名 | 描述 |
---|---|
public abstract void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
public abstract E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |
public abstract E set(int index,E element) | 修改指定索引处的元素,返回被修改的元素 |
public abstract E get(int index) | 返回指定索引处的元素 |
public static List of(E… elements) | 静态方法,获取一个不可变的List集合 |
List接口的一个实现类,LinkList底层是通过双向链表实现的
操作列表首尾特有的方法(Frist、Last)
方法名 | 说明 |
---|---|
public void addFirst(E e) | 在该列表开头插入指定的元素 |
public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
public E getFirst() | 返回此列表中的第一个元素 |
public E getLast() | 返回此列表中的最后一个元素 |
public E removeFirst() | 从此列表中删除并返回第一个元素 |
public E removeLast() | 从此列表中删除并返回最后一个元素 |
继承与Collection接口中的方法,没有特别方法,常用方法参照Collection接口
方法名 | 说明 |
---|---|
public static Set of(E… elements) | 静态方法,获取一个不可变的Set集合 |
1 Comparable
方法名 | 说明 |
---|---|
public abstract int compareTo(T o) | 通过指定的规则对集合的元素进行排序(类中实现该接口) |
负数:表示添加的元素比当前集合红黑树中存在元素小;继续与红黑树中下一个小元素比较,直到确定该添加元素的位置
0:表示添加的元素比当前集合红黑树中存在元素小;舍去不存
正数:表示添加的元素比当前集合红黑树中存在元素大;继续与红黑树中下一个大元素比较,直到确定该添加元素的位置
2 Comparator
方法名 | 说明 |
---|---|
public compare(T o1,T o2) int compare(T o1,T o2) | 通过指定的规则对集合的元素进行排序(创建TreeSet集合使用该接口) |
双列集合的顶层接口,K表示键(key),V表示值(value)
方法名 | 说明 |
---|---|
public abstract V put(K key,V value) | 添加元素或覆盖元素的值;若键相同返回被覆盖的值,不相同返回null |
public void putAll(Map m) | 通过Map集合作为参数批量添加元素 |
public abstract V remove(Object key) | 根据键删除键值对元素 |
public abstract void clear() | 移除所有的键值对元素 |
public abstract boolean containsKey(Object key) | 判断集合是否包含指定的键 |
public abstract boolean containsValue(Object value) | 判断集合是否包含指定的值 |
public abstract boolean isEmpty() | 判断集合是否为空 |
public abstract int size() | 集合的长度,也就是集合中键值对的个数 |
public abstract Set |
获取所有键的集合 |
public abstract Set |
获取所有键值对的集合 |
public abstract Collection values() | 获取所有值的集合 |
public abstract V get(Object key) | 根据键获取值 |
static |
使用可变参数创建一个具有指定元素的Map不可变集合 |
static |
创建一个具有指定元素的Map不可变集合 |
public static |
将参数中的map集合变为不可变集合 |
1 概述
Map集合存储的元素键值对(Entry)
2 常用方法
方法名 | 说明 |
---|---|
public abstract K getKey() | 获取键值对中的键 |
public abstract V getValue() | 获取键值对中的值 |
为Collection单列集合提供的工具类
方法名 | 说明 |
---|---|
public static boolean addAll(Collection c, T… elements) | 在集合后批量添加元素(底层使用增强for+add方法) |
public static void shuffle(List list) | 打乱List集合元素的顺序 |
public static void sort(List list) | 对List集合进行排序 |
public static void sort(List list, Comparator c) | 根据指定的规则进行排序 |
public static int binarySearch (List list, T key) | 以二分查找法查找List集合中的元素 |
public static void copy(List dest, List src) | 将src原集合全部元素拷贝到dest目的集合中(从0开始) |
public static int fill (List list, T obj) | 使用指定的元素填充集合 |
public static void max/min(Collection coll) | 根据默认的自然排序获取最大/小值 |
public static void max/min(Collection coll, Comparator c) | 根据默认的指定的规则获取最大/小值 |
public static void swap(List list, int i, int j) | 交换集合中指定索引i、j的元素 |
public static int frequency(Collection c, Object o) | 返回指定集合中指定元素的出现次数 |
public static Xxx synchronizedXxx(Xxx xxx) | 返回一个线程安全的集合(List、Set、Map) 原理:将集合中的方法使用synchronize包裹起来 |
Stream流可以看做是流水线,可以对流上的数据进行加工
2.1 单列集合获取Stream流
单列集合名.stream()
方法名 | 说明 |
---|---|
public default Stream stream() | Collection接口中有默认stream方法来获取Stream流 |
2.2 双列集合获取Stream流
2.3 数组获取Stream流
Arrays.stream(数组)
方法名 | 说明 |
---|---|
public static Stream stream(T[] array) | 获取泛型T对应类型的流(引用数据类型) |
public static IntStream stream(int[] array) | 获取基本int类型数组对应的流(基本数据类型) |
2.4 零散数据获取Stream流
Stream.of(数据列表)
方法名 | 说明 |
---|---|
public static Stream of(T… values) | Stream中有【静态of方法】可根据多个相同数据类型的数据获取Stream流 |
方法名 | 说明 |
---|---|
public abstract Stream filter( Predicate predicate) |
筛选出满足重写Predicate接口中text方法中返回true条件的数据 |
public abstract Stream limit(long maxSize) | 截取流中前指定参数个数的数据作为新流返回 |
public abstract Stream skip(long n) | 跳过指定参数个数的数据,返回由该流的剩余元素组成的流 |
public static Stream concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
public abstract Stream distinct() | 去除该流中重复的元素并返回新流 (底层使用HashSet完成去重功能,所以存储的类需要重写HashCode和equals方法) |
public abstract Stream map( Function mapper) |
将流中泛型T对应的数据类型数据映射为泛型R对应的数据类型数据 |
方法名 | 说明 |
---|---|
public abstract long count() | 返回当前流中的元素个数 |
public abstract void forEach(Consumer action) | 对当前流的每个元素执行Consumer中的accept方法体中的操作 |
public abstract A[] toArray(IntFunction generator) | 将流中的数据放入A泛型对应类型的数组中(参数可引用数组的构造方法A[]::new) |
public abstract |
通过Collectors工具类创建集合,将流中的元素收集到集合中 |
方法名 | 说明 |
---|---|
public static Collector |
把元素收集到List集合中(底层创建了ArrayList集合) |
public static Collector |
把元素收集到Set集合中(底层创建了HashSet结合) |
public static Function keyMapper, Function valueMapper); |
把元素收集到Map集合中(底层创建了HashMap结合) |
表示文件目录路径,可以进行文件操作(字符串路径可以是绝对路径或相对路径,也可以是不存在的路径)
2.1 构造方法
方法名 | 说明 |
---|---|
public File(String pathname) | 通过将给定的字符串路径创建File对象 |
public File(String parent, String child) | 将父字符串路径和子字符串路径名拼接后创建新的File对象 |
public File(File parent, String child) | 通过父File对象和和子字符串路径名拼接后创建新的File对象 |
2.2 成员方法
判断方法
方法名 | 说明 |
---|---|
public boolean exists() | 判断此File对象的文件或文件夹是否存在 |
public boolean isDirectory() | 判断此File对象是否为目录(文件夹) |
public boolean isFile() | 判断此File对象是否为文件 |
获取文件信息
方法名 | 说明 |
---|---|
public long length() | 返回文件的大小(单位:B(字节)) |
public String getAbsolutePath() | 返回文件的绝对路径 |
public String getPath() | 返回定义文件时使用的路径 |
public String getName() | 返回文件的名称(若是文件则会带后缀名;若是文件夹则返回文件夹名称) |
public long lastModified() | 返回文件的最后修改时间(单位:毫秒) |
创建文件
方法名 | 说明 |
---|---|
public boolean createNewFile() | 创建一个新的空的文件 |
public boolean mkdir() | 创建单级目录(文件夹) |
public boolean mkdirs() | 创建多级目录(文件夹) |
删除文件
方法名 | 说明 |
---|---|
public boolean delete() | 只能删除空文件夹和文件;含有其他文件的文件夹会删除失败;不进入回收站(记得关流) |
遍历文件
方法名 | 说明 |
---|---|
public static File[] listRoots() | 获取系统中所有的盘符 |
public String[] list() | 获取当前该目录(文件夹)下所有内容的文件名 |
public String[] list(FilenameFilter filter) | 利用文件名过滤器获取当前**该目录(文件夹)**下所有内容文件名 (过滤器中参数 dir:当前文件的父级路径的字符串 name:当前文件的名称) |
public File[] listFiles() | 获取当前目录(文件夹)下的所有内容(文件和文件夹)的File对象 |
public File[] listFiles(FileFilter filter) | 利用文件过滤器获取**该目录(文件夹)**下所有内容 (过滤器中参数 pathname:当前文件路径的字符串) |
public File[] listFiles(FilenameFilter filter) | 利用文件名过滤器获取**该目录(文件夹)**下所有内容 |
注意事项:list方法遍历到的若File对象对应的目录为空则返回长度为0的数组,若File对象是文件则返回null
构造方法
方法名 | 说明 |
---|---|
public FileInputStream(String name) | 通过文件字符串创建字节输入流对象 |
public FileInputStream(File file) | 通过File对象创建字节输入流对象 |
常用方法
方法名 | 说明 |
---|---|
public int read() | 一次读一个字节数据 |
public int read(byte b[]) | 一次最多读一个字节数组b的数据 |
public void close() | 关闭此文件输入流并释放与此流相关联的任何系统资源 |
构造方法
方法名 | 说明 |
---|---|
public FileOutputStream(String name, boolean append) | 通过文件字符串创建字节输出流对象 |
public FileOutputStream(File name,boolean append) | 通过File对象创建字节输出流对象 |
常用方法
方法名 | 说明 |
---|---|
public void write(int b) | 一次往文件中写一个字节的数据 |
public void write(byte[] b) | 一次往文件中写一个字节数组中的数据 |
public void write(byte[] b,int off ,int len) | 一次往文件中写一个指定字节数组位置中的数据 |
public void close() | 关闭此文件输出流并释放与此流相关联的任何系统资源 |
构造方法
方法名 | 说明 |
---|---|
public BufferedInputStream(OutputStream out, int size) | 根据字节输入流关联缓冲流(参数size为缓冲区大小) |
常用方法
read方法:与字节输入流相同
close方法:与字节流相同
构造方法
方法名 | 说明 |
---|---|
public BufferedOutputStream(OutputStream out, int size) | 根据字节输出流关联缓冲流(参数size为缓冲区大小) |
常用方法
方法名 | 说明 |
---|---|
public void flush() | 将写入缓冲区的数据直接写入文件 |
write方法:与字节流输出相同
close方法:与字节流相同
构造方法
方法名 | 说明 |
---|---|
public ObjectInputStream(InputStream in) | 创建反序列化对象并关联文件字节输入流 |
常用方法
方法名 | 说明 |
---|---|
public Object readObject() | 从对象序列化的文件中反序列化出一个对象() |
close方法:与字节流相同
构造方法
方法名 | 说明 |
---|---|
public ObjectOutputStream(OutputStream out) | 创建序列化对象并关联文件字节输出流 |
常用方法
方法名 | 说明 |
---|---|
public void writeObject(Object obj) | 将对象序列化到文件中(类需要实现Serializable接口) |
close方法:与字节流相同
构造方法
方法名 | 说明 |
---|---|
public PrintStream(OutputStream out , boolean autoFlush , String encoding) |
创建打印流对象并指定字符编码和自动刷新,然后关联字节输出流 |
常用方法
方法名 | 说明 |
---|---|
public void println(Xxx xx) | 打印任意数据并自动换行 |
public void print(Xxx xx) | 打印任意数据;不换行 |
public void printf(String format, Object… args) | 带有占位符的打印语句;不换行 |
write方法:与字节输出流相同
close方法:与字节流相同
概述
解压:把压缩包里面的每一个文件(不是文件夹)(ZipEntry对象)解压(读取)到内存,然后按照层级使用字节输出流拷贝到解压文件中
构造方法
方法名 | 说明 |
---|---|
public ZipInputStream(InputStream in) | 创建字节解压流对象并关联字节输入流 (参数中字节输入流中关联的文件为需要解压的压缩文件(.zip)) |
常用方法
方法名 | 说明 |
---|---|
public ZipEntry getNextEntry() | 通过解压流获取ZipEntry对象并指向下一个ZipEntry对象 (ZipEntry对象获取完后会返回null) |
public String getName() | ZipEntry调用,可获取其相对于压缩包(去掉.zip)的全路径名 |
public void closeEntry() | 表示在压缩包中的一个文件或文件夹(ZipEntry对象)处理完毕了 |
read方法:与字节输入流相同
close方法:与字节流相同
概述
压缩:将需要压缩的文件中每一个文件或者文件夹读入内存,然后变为ZipEntry对象并按照原文件的层级关系压缩(写入)到.zip文件中
构造方法
方法名 | 说明 |
---|---|
public ZipOutputStream(OutputStream out) | 创建字节压缩流对象并关联字节输出流 (参数中字节输入流中关联的文件为需要解压的压缩文件(.zip)) |
public ZipEntry(String name) | 指定的路径创建ZipEntry对象 |
常用方法
方法名 | 说明 |
---|---|
public void putNextEntry(ZipEntry e) | 将ZipEntry对象添加到.zip文件中 |
public void closeEntry() | 表示在压缩包中的一个文件或文件夹(ZipEntry对象)处理完毕了 |
write方法:与字节输出流相同
close方法:与字节流相同
构造方法
方法名 | 说明 |
---|---|
public FileReader(String fileName) | 通过文件字符串创建符输入流对象 |
public FileReader(File name) | 通过File对象创建符输入流对象 |
public FileReader(String fileName, Charset charset) | 通过指定字符编码创建字符输入流对象 |
常用方法
方法名 | 说明 |
---|---|
public int read() | 一次读一个字符数据 |
public int read(char chs[]) | 一次最多读一个字符数组chs的数据 |
public void close() | 关闭此文件输入流并释放与此流相关联的任何系统资源 |
构造方法
方法名 | 说明 |
---|---|
public Filewriter(String name) | 通过文件字符串创建字符输出流对象 |
public Filewriter(File file) | 通过File对象创建字符输出流对象 |
public FileWriter(String fileName, Charset charset) | 通过指定字符编码创建字符输出流对象 |
常用方法
方法名 | 说明 |
---|---|
public void write(int b) | 一次往文件中写一个字符的数据 |
public void write(char[] b) | 一次往文件中写一个字符数组中的数据 |
public void write(char[] b,int off ,int len) | 一次往文件中写一个指定字符数组位置中的数据 |
public void flush() | 将写入缓冲区的数据直接写入文件 |
public void close() | 关闭此文件输出流并释放与此流相关联的任何系统资源 |
构造方法
方法名 | 说明 |
---|---|
public BufferedReader(OutputStream out, int size) | 根据字符输出流关联缓冲流(参数size为缓冲区大小) |
常用方法
方法名 | 说明 |
---|---|
public String readLine() | 每次依次读一行数据 |
read方法:与字符输入流相同
close方法:与字符流相同
构造方法
方法名 | 说明 |
---|---|
public BufferedWriter(Writer out, int sz) | 根据字符输出流关联缓冲流(参数size为缓冲区大小) |
常用方法
方法名 | 说明 |
---|---|
public void newLine() | 写入回车换行符(换行符字符串由系统属性而定) |
write方法:与字符流输出相同
flush方法:与字符流输出相同
close方法:与字符流相同
概念
可以将字节输入流转换为字符输入流;即以字符对应指定编码的字符集读取多个字节数据
构造方法
方法名 | 说明 |
---|---|
public InputStreamReader(InputStream in) | 使用默认字符编码创建转换流对象并关联字节流 |
public InputStreamReader(InputStream in,String charset) | 使用指定的字符编码创建转换流对象并关联字节流 |
常用方法
read方法:与字符输入流相同
close方法:与字符流相同
概念
可以将字符输出流转换为字节输出流;即以字符对应指定编码的字符集写入一个字节数据
构造方法
方法名 | 说明 |
---|---|
public OutputStreamWriter(OutputStream out) | 使用默认字符编码创建转换流对象并关联字节流 |
public OutputStreamWriter(OutputStream out,String charset) | 使用指定的字符编码创建转换流对象并关联字节流 |
常用方法
write方法:与字符流输出相同
flush方法:与字符流输出相同
close方法:与字符流相同
构造方法
方法名 | 说明 |
---|---|
public PrintWriter(OutputStream out , boolean autoFlush , String encoding) |
创建打印流对象并指定字符编码和自动刷新,然后关联字节输出流 |
public PrintWriter(Writer out , boolean autoFlush) |
创建打印流对象并指定字符编码和自动刷新,然后关联字符输出流 |
常用方法
方法名 | 说明 |
---|---|
public void println(Xxx xx) | 打印任意数据并自动换行 |
public void print(Xxx xx) | 打印任意数据;不换行 |
public void printf(String format, Object… args) | 带有占位符的打印语句;不换行 |
write方法:与字符输出流相同
close方法:与字符流相同
方法名 | 说明 |
---|---|
public Thread() | 空参创建线程对象 |
public Thread(String name) | 可以为当前线程指定名称 |
public Thread(Runnable target) | 通过任务对象创建线程对象 |
public Thread(Runnable target,String name) | 通过任务对象创建线程对象并指定线程名称 |
方法名 | 说明 |
---|---|
public static Thread currentThread() | 返回当前正在执行的线程对象(静态方法) |
public static void sleep(long millis) | 让当前执行的线程休眠指定的时间后再继续执行(单位:毫秒)(静态方法) |
public static native void yield() | 使当前执行的线程让出CPU(静态方法) |
public void setName(String name) | 设置线程的名称 |
public void run() | 线程任务 |
public void start() | 启动线程,执行Thread类中的run方法 |
public String getName() | 获取当前线程的名称 |
public final int getPriority() | 返回此线程的优先级 |
public final void setPriority(int newPriority) | 更改此线程的优先级线程(默认:5;范围:1-10,优先级升序(2 > 1)) |
public void setDaemon(boolean on) | 将此线程设置为守护线程(当其他运行的非守护线程都结束时守护线程也会结束) |
public final void join() | 在线程a中使用线程b调用join方法,意味着线程a被阻塞,直到线程b执行结束 |
public final boolean isAlive() | 测试线程是否处于活动状态。如果线程已经启动且尚未终止则为活动状态 |
方法名 | 说明 |
---|---|
public static 枚举类型[] values() | 返回枚举类型的对象数组(静态方法) |
public static 枚举类型 valueOf(String name) | 通过枚举中常量的名获取枚举常量(静态方法) |
public String toString() | 返回对象名 |
public String name() | 得到当前枚举常量的名称(建议优先使用toString()) |
public int ordinal() | 返回当前枚举常量的次序号,默认从0开始 |