Java中的常用API大全【含浅拷贝深拷贝、正则表达式、BigDecimal、BigInteger底层存储方式等】

String

1 构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

2 常见方法

方法名称	描述
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()	将字符串的结果在常量池中生成并返回常量池中的地址

StringBuilder、StringBuffer

1 StringBuilder构造方法

方法名	说明
public StringBuilder()	构造一个不带任何字符的字StringBuilder对象
public StringBuilder(String original)	根据传入的字符串内容来创建StringBuilder对象

2 StringBuilder常见方法

法名	说明
public StringBuilder insert(索引,数据)	将给定内容的字符串表示形式插入到字符串指定索引位置中
public StringBuilder append(数据)	添加数据并返回对象本身
public StingBuilder reverse()	将字符串对象取反
public String toString()	把StingBuilder类型转换为Sting
public int length()	获取StingBuilder对象的长度

3 StringBuffer

StringBuffer中的成员方法与StringBuilder相同，但StringBuffer中的成员方法都是同步方法

StringJoiner

1 构造方法

方法名	说明
public StringJoiner(CharSequence delimiter , CharSequence prefix , CharSequence suffix)	指定拼接时的间隔符号开始符号、结束符号创建对象
public StringJoiner(CharSequence delimiter)	指定拼接时的间隔符号创建对象

2 常见方法

法名	说明
public StringJoiner add(数据)	添加数据并返回对象本身
public String toString()	把StringJoiner类型转换为String
public int length()	获取StringJoiner对象的长度

Math(工具类)

1 成员变量

2 常见方法

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(工具类)

常见方法

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

1 概述

​ Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息

Runtime对象唯一（类只创建一个对象）

2 常见方法

• 获取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命令

Object

1 概述

查看API文档我们可以看到，在Object类中只提供了一个无参构造方法

Object 是类层次结构的根，每个类都可以将 Object 作为超类：该类所具备的方法会被其他所有类都继承

2 常见方法(需要子类重写)

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

Objects(工具类)

1 常见方法

扩展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

1 概述

​ 我们可以使用BigInteger类进行大整数的计算

2 常见方法

构造方法

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对象

构造方法小结

• 如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
• 如果BigInteger表示的超出long的范围，可以用构造方法获取。
• 对象一旦创建BigInteger内部记录的值不能发生改变，只要改变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类型整数，超出范围数据错误(强转)   

3 BigInteger底层存储方式

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亿次方

BigDecimal

1 概述

​ 表示较大的小数和解决小数运算精度失真问题。

2 常见方法

构造方法

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舍五入)

3 BigDecimal底层存储方式

把数据看成字符串，BigDecimal底层数组存储字符串中每一个字符的ASCII码值。

正则表达式

1 概述

​ 正则表达式就是用来验证各种字符串的规则，从左往右依次匹配

• 步骤

1. 将字符串拆分为各个分组
2. 从左往右根据各个分组规则写各组的正则表达式
3. 将各个分组的正则表达式拼接完整

2 语法

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 分组

表达式	代表意义
(正则)	分组，匹配括号里的整个表达式

• 组号：识别分组，规则：

  1. 从1开始，连续不间断。
  2. 以左括号为基准，最左边的是第一组，其次为第二组，以此类推。

• 捕获分组：可以通过组号引用一组字符(相当于复制的分组

  表达式	代表意义
  \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分组忽略大小写

3 Java中使用正则

• 通过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记录的索引返回子串
	}

时间类

JDK7时间相关类

1 Date

• 应用场景：相当于某一个时刻，获取时间的毫秒值

构造方法

方法名	说明
public Date()	分配一个 Date对象，使用系统当前毫秒值在原点时间上的初始化
public Date(long date)	分配一个 Date对象，使用指定的毫秒值在原点时间上的初始化

成员方法

public long getTime() 		    //把日期对象转换成对应的时间毫秒值
public void setTime(long time) //把方法参数给定的毫秒值设置给日期对象
   									 //中国是东八区，所以系统默认在后面加8小时毫秒值

2 SimpleDateFormat

​ 应用场景：我们通过这个类可以帮我们在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，把Date对象转换为String对象。
• 解析：按照指定的格式，把String对象转换为Date对象。

构造方法

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对象

3 Calendar

1 概述

• java.util.Calendar类表示一个“日历类”，它是一个抽象类，可以使用它的子类：java.util.GregorianCalendar类；底层把时间中的纪元，年，月，日，时，分，秒，星期等字段的都放到一个数组当中
• 应用场景：可以进行日期指定字段的修改，对日历进行加减
• 有两种方式可以获取GregorianCalendar(格林尼治日历)对象：
  • 直接创建GregorianCalendar对象；
  • 通过Calendar的静态方法**getInstance()**方法获取GregorianCalendar对象

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时间相关类

JDK8时间类类名	作用
相当于JDK7中的Date
ZoneId	时区
Instant	时间戳
ZoneDateTime	带时区的时间戳
相当于JDK7中的Calendar
LocalDate	年、月、日
LocalTime	时、分、秒
LocalDateTime	年、月、日、时、分、秒
相当于JDK7中的SimpleDateFormat
DateTimeFormatter	用于时间的格式化和解析
计算时间间隔工具类
Duration	工具类：计算时间间隔（秒，纳，秒）
Period	工具类：计算日期间隔（年，月，日）
ChronoUnit	工具类：计算时间间隔（所有单位）

• 注意事项

调用方法需要改变时间对象的值时会重新创建一个时间对象(时间对象类：Instant、ZoneDateTime、LocalDate、LocalTime、LocalDateTime)，解决多线程中同时访问问题

1 ZoneId

地球中不同位置有不同的时间，时区可以理解为原点时间的偏移(例如北京所在的时区时间为：原点时间+8小时)

//ZoneId静态方法
public static Set<String> getAvailableZoneIds()  //获取Java中支持的所有时区字符串
public static ZoneId systemDefault() 				//获取系统默认时区
public static Zoneld of(string zoneld) 				//通过时区字符串获取一个指定时区

2 Instant

时间戳：以原点时间开始的标准时间，相当于某一个时刻，不可变对象

• 获取Instant 对象(使用Instant静态方法获取Instant对象)

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) //将调用者时间戳对象往后移动指定的纳秒值

3 ZonedDateTime

ZonedDateTime对象相当于Instant对象 + ZoneId时区时间，即带时区的时间

• 获取ZoneDateTime 对象(使用ZonedDateTime静态方法获取ZoneDateTime 对象)

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对象

5 LocalDate

年、月、日日历

• 获取LocalDate对象(使用LocalDate静态方法获取LocalDate 对象)

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对象

5 LocalTime

时、分、秒日历

• 获取LocalTime对象(使用LocalTime静态方法获取LocalTime对象)

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。

6 LocalDateTime

年、月、日、时、分、秒日历

• 获取LocalDateTime对象(使用LocalDateTime静态方法获取LocalDateTime对象)

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对象

7 DateTimeFormatter 用于时间的格式化和解析

• 获取DateTimeFormatter对象(使用ofPattern静态方法获取DateTimeFormatter对象)

public static DateTimeFormatter ofPattern(String format) //获取指定日期时间格式对象

• 常用方法

LocalDate、LocalTime、LocalDateTime、ZonedDateTime实现了TemporalAccessor接口
    
public String format(TemporalAccessor 时间对象) //将实现TemporalAccessor接口的时间对象按照指定方式格式化

//解析使用相应时间对象的静态方法parse

8 Period(工具类)

计算日期间隔（年，月，日）

• 常用方法

//第二个参数减第一个参数：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()	//两个时间差的总月数

9 Duration(工具类)

计算时间间隔（秒，纳，秒）

• 常用方法

//第二个参数减第一个参数：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()	//两个时间差的总纳秒数

10 ChronoUnit(工具类)

计算时间间隔（所有单位）

• 常用方法

//第二个参数减第一个参数：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));

包装类

1 概述

​ 基本类型对应的包装类(引用数据类型)，如下：

基本类型	对应的包装类（位于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

2 Integer

• 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 基本类型与字符串之间的转换

• 基本类型→String

//方式1：直接在数字后加一个空字符串
String s1 = number + "";

//方式2：通过String类静态方法valueOf()
//public static String valueOf(int i)
String s2 = String.valueOf(number);

• String→基本类型

//方式一：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(工具类)

1 概述

操作数组的工具类，Arrays类中的方法都是静态的

2 常用方法

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<E>(接口)

1 概述

Collection是单例集合的顶层接口

2 常用方法

方法名	说明
public abstract boolean add(E e)	添加元素
public abstract boolean addAll(Collection<? extends E> c)	通过Collection集合作为参数批量添加元素
public abstract boolean remove(Object o)	从集合中移除指定的元素
public default boolean removeIf(Predicate<? super E> 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<? super T> action)	遍历集合，重写accept方法
public abstract T[] toArray(T[] a)	将集合的元素存入方法参数对应类型的数组中
public abstract Iterator iterator()	获取迭代器对象

注意事项：使用remove系列方法、contains系列方法、retainAll()方法时，集合泛型类需要重写equals方法

List<E>(接口)

1 概述

• 有序集合：这里的有序指的是存取顺序
• 有索引：可通过索引访问列表元素，并搜索列表中的元素
• 可重复：列表通常允许重复的元素，

2 常用方法

增加了操作索引的方法

方法名	描述
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集合

3 实现类LinkedList<E>(集合)

1 概述

List接口的一个实现类，LinkList底层是通过双向链表实现的

2 常用方法

操作列表首尾特有的方法(Frist、Last)

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

Set<E>(接口)

1 概述

• 无索引：不能通过索引访问集合中元素
• 不可重复：集合中没有重复的元素

2 常用方法

继承与Collection接口中的方法，没有特别方法，常用方法参照Collection接口

方法名	说明
public static Set of(E… elements)	静态方法，获取一个不可变的Set集合

TreeSet<E>

1 概述

• 无索引：不能通过索引访问集合中元素
• 不可重复：集合中没有重复的元素
• 可排序：集合中元素可排序

2 排序所需函数式接口

1 Comparable<T>(接口)：自然排序

方法名	说明
public abstract int compareTo(T o)	通过指定的规则对集合的元素进行排序(类中实现该接口)

• 参数o：表示TreeSet集合红黑树已经存在的元素
• 方法体：用来指定添加的元素(this)与红黑树存在的元素(o)的排序规则
• 返回值：

​ 负数：表示添加的元素比当前集合红黑树中存在元素小；继续与红黑树中下一个小元素比较，直到确定该添加元素的位置
​ 0：表示添加的元素比当前集合红黑树中存在元素小；舍去不存
​ 正数：表示添加的元素比当前集合红黑树中存在元素大；继续与红黑树中下一个大元素比较，直到确定该添加元素的位置

2 Comparator<T>接口：比较器排序

方法名	说明
public compare(T o1,T o2) int compare(T o1,T o2)	通过指定的规则对集合的元素进行排序(创建TreeSet集合使用该接口)

• 参数：
  o1：表示需要添加的元素
  o2：表示TreeSet集合红黑树已经存在的元素
• 方法体：用来指定添加的元素(o1)与红黑树存在的元素(o2)的排序规则
• 返回值：与compareTo(T o)方法的规则相同

Map<K,V>(接口)

1 概述

双列集合的顶层接口，K表示键(key)，V表示值(value)

2 常用方法

方法名	说明
public abstract V put(K key,V value)	添加元素或覆盖元素的值；若键相同返回被覆盖的值，不相同返回null
public void putAll(Map<? extends K, ? extends V> 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<K> keySet()	获取所有键的集合
public abstract Set<Map.Entry<K,V>> entrySet()	获取所有键值对的集合
public abstract Collection values()	获取所有值的集合
public abstract V get(Object key)	根据键获取值
static <K, V> Map<K, V> ofEntries(Entry<K, V>… entries)	使用可变参数创建一个具有指定元素的Map不可变集合
static <K , V> Map<K，V> of(形参列表)	创建一个具有指定元素的Map不可变集合
public static <K, V> Map<K, V> copyOf(Map<K,V> map)	将参数中的map集合变为不可变集合

3 内部接口Entry<K,V>

1 概述

Map集合存储的元素键值对(Entry)

2 常用方法

方法名	说明
public abstract K getKey()	获取键值对中的键
public abstract V getValue()	获取键值对中的值

Collections(工具类)

1 概述

为Collection单列集合提供的工具类

2 常用方法

方法名	说明
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

1 概述

Stream流可以看做是流水线，可以对流上的数据进行加工

2 获取Stream流

2.1 单列集合获取Stream流

单列集合名.stream()

方法名	说明
public default Stream stream()	Collection接口中有默认stream方法来获取Stream流

2.2 双列集合获取Stream流

1. 双列集合通过keySet或entrySet方法来得到单列Set集合
2. 调用Collection中默认的stream方法来获取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流

3 Stream流的中间方法

方法名	说明
public abstract Stream filter( Predicate<? super T> 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<? super T, ? extends R> mapper)	将流中泛型T对应的数据类型数据映射为泛型R对应的数据类型数据

4 Stream流的终结方法

方法名	说明
public abstract long count()	返回当前流中的元素个数
public abstract void forEach(Consumer<? super T> action)	对当前流的每个元素执行Consumer中的accept方法体中的操作
public abstract A[] toArray(IntFunction<A[]> generator)	将流中的数据放入A泛型对应类型的数组中(参数可引用数组的构造方法A[]::new)
public abstract <R, A> R collect(Collector<? super T, A, R> collector)	通过Collectors工具类创建集合，将流中的元素收集到集合中

• 工具类Collectors提供了具体的收集方式

方法名	说明
public static Collector<T, ?, List> toList()；	把元素收集到List集合中(底层创建了ArrayList集合)
public static Collector<T, ?, Set> toSet()；	把元素收集到Set集合中(底层创建了HashSet结合)
public static <T, K, U> Collector <T, ?, Map <K,U>> toMap( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)；	把元素收集到Map集合中(底层创建了HashMap结合)

File

1 概述

表示文件目录路径，可以进行文件操作(字符串路径可以是绝对路径或相对路径，也可以是不存在的路径)

2 常用方法

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

I\O流

字节流

1 FileInputStream

构造方法

方法名	说明
public FileInputStream(String name)	通过文件字符串创建字节输入流对象
public FileInputStream(File file)	通过File对象创建字节输入流对象

常用方法

方法名	说明
public int read()	一次读一个字节数据
public int read(byte b[])	一次最多读一个字节数组b的数据
public void close()	关闭此文件输入流并释放与此流相关联的任何系统资源

2 FileOutputStream

构造方法

方法名	说明
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()	关闭此文件输出流并释放与此流相关联的任何系统资源

3 BufferedInputStream

构造方法

方法名	说明
public BufferedInputStream(OutputStream out, int size)	根据字节输入流关联缓冲流(参数size为缓冲区大小)

常用方法

read方法：与字节输入流相同

close方法：与字节流相同

4 BufferedOutputStream

构造方法

方法名	说明
public BufferedOutputStream(OutputStream out, int size)	根据字节输出流关联缓冲流(参数size为缓冲区大小)

常用方法

方法名	说明
public void flush()	将写入缓冲区的数据直接写入文件

write方法：与字节流输出相同

close方法：与字节流相同

5 ObjectInputStream

构造方法

方法名	说明
public ObjectInputStream(InputStream in)	创建反序列化对象并关联文件字节输入流

常用方法

方法名	说明
public Object readObject()	从对象序列化的文件中反序列化出一个对象()

close方法：与字节流相同

6 ObjectOutputStream

构造方法

方法名	说明
public ObjectOutputStream(OutputStream out)	创建序列化对象并关联文件字节输出流

常用方法

方法名	说明
public void writeObject(Object obj)	将对象序列化到文件中(类需要实现Serializable接口)

close方法：与字节流相同

7 PrintStream

构造方法

方法名	说明
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方法：与字节流相同

8 ZipInputStream

概述

解压：把压缩包里面的每一个文件(不是文件夹)(ZipEntry对象)解压(读取)到内存，然后按照层级使用字节输出流拷贝到解压文件中

构造方法

方法名	说明
public ZipInputStream(InputStream in)	创建字节解压流对象并关联字节输入流 (参数中字节输入流中关联的文件为需要解压的压缩文件(.zip))

常用方法

方法名	说明
public ZipEntry getNextEntry()	通过解压流获取ZipEntry对象并指向下一个ZipEntry对象 (ZipEntry对象获取完后会返回null)
public String getName()	ZipEntry调用，可获取其相对于压缩包(去掉.zip)的全路径名
public void closeEntry()	表示在压缩包中的一个文件或文件夹(ZipEntry对象)处理完毕了

read方法：与字节输入流相同

close方法：与字节流相同

9 ZipOutputStream

概述

压缩：将需要压缩的文件中每一个文件或者文件夹读入内存，然后变为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方法：与字节流相同

字符流

1 FileReader

构造方法

方法名	说明
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()	关闭此文件输入流并释放与此流相关联的任何系统资源

2 Filewriter

构造方法

方法名	说明
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()	关闭此文件输出流并释放与此流相关联的任何系统资源

3 BufferedReader

构造方法

方法名	说明
public BufferedReader(OutputStream out, int size)	根据字符输出流关联缓冲流(参数size为缓冲区大小)

常用方法

方法名	说明
public String readLine()	每次依次读一行数据

read方法：与字符输入流相同

close方法：与字符流相同

4 BufferedWriter

构造方法

方法名	说明
public BufferedWriter(Writer out, int sz)	根据字符输出流关联缓冲流(参数size为缓冲区大小)

常用方法

方法名	说明
public void newLine()	写入回车换行符(换行符字符串由系统属性而定)

write方法：与字符流输出相同

flush方法：与字符流输出相同

close方法：与字符流相同

5 InputStreamReader

概念

可以将字节输入流转换为字符输入流；即以字符对应指定编码的字符集读取多个字节数据

构造方法

方法名	说明
public InputStreamReader(InputStream in)	使用默认字符编码创建转换流对象并关联字节流
public InputStreamReader(InputStream in,String charset)	使用指定的字符编码创建转换流对象并关联字节流

常用方法

read方法：与字符输入流相同

close方法：与字符流相同

6 OutputStreamWriter

概念

可以将字符输出流转换为字节输出流；即以字符对应指定编码的字符集写入一个字节数据

构造方法

方法名	说明
public OutputStreamWriter(OutputStream out)	使用默认字符编码创建转换流对象并关联字节流
public OutputStreamWriter(OutputStream out,String charset)	使用指定的字符编码创建转换流对象并关联字节流

常用方法

write方法：与字符流输出相同

flush方法：与字符流输出相同

close方法：与字符流相同

7 PrintWriter

构造方法

方法名	说明
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方法：与字符流相同

Thread

1 构造方法

方法名	说明
public Thread()	空参创建线程对象
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	通过任务对象创建线程对象
public Thread(Runnable target,String name)	通过任务对象创建线程对象并指定线程名称

2 常用方法

方法名	说明
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()	测试线程是否处于活动状态。如果线程已经启动且尚未终止则为活动状态

Enum

方法名	说明
public static 枚举类型[] values()	返回枚举类型的对象数组(静态方法)
public static 枚举类型 valueOf(String name)	通过枚举中常量的名获取枚举常量(静态方法)
public String toString()	返回对象名
public String name()	得到当前枚举常量的名称（建议优先使用toString()）
public int ordinal()	返回当前枚举常量的次序号，默认从0开始