Java常用类-优快云博客

       /*创建后里面的字符串内容不可变*/
       （1）String(byte[] b,String str)：使用指定方式解码，并创建解码后的字符串对象，不传str时采用默认方式解码
       （2）eauals：比较字符串内容的大小。
       （3）equalsIgnoreCase：比较大小，忽略大小写。
       （4）charAt
       （5）substring
       （6）replace
       （7）toCharArray
       （8）maches：传入正则表达式进行匹配，检查字符串是否满足要求
       （9）replaceAll：将正则表达式匹配到的子串进行替换，"%1"表示用第1组的字符串进行替换（分组概念见正则表达式）
       （10）split：按正则表达式规则分割字符串
       （11）getBytes(str)：使用指定方式编码字符串，返回byte数组，不传str时使用默认方式编码，IDEA默认使用Unicode字符集的UTF-8编码方式

2.StringBuilder类

       /*底层由字符数组实现，创建后里面的字符串内容可变，常用于字符串拼接或反转，数组初始容量16，扩容后的容量=max(实际容量，原容量*2+2)
       StringBuilder多线程不安全，有和StringBuilder相同成员变量和成员方法的StringBuffer，但其成员方法都是同步方法，因此该类多线程安全*/
       （1）append：返回值为调用者自己，可运用链式编程简写代码
       （2）reverse
       （3）toString
       （4）length
       （5）capacity

3.Math类

       /*final类不能被继承，构造方法private不能创建对象*/
       （1）E、PI
       （2）abs、absExact(在绝对值超出传入变量的数据类型的数据范围时抛出异常)、ceil、floor、round、max、pow、sqrt、cbrt(开立方根)
       （3）random：返回double随机值，范围[0.0，1.0)

4.System类

       （1）out：方法printl，底层调用对象的toString方法
       （2）exit：终止java虚拟机，传0正常停止，非0异常停止
       （3）currentTimeMillis：返回当前系统的时间毫秒值形式
       （4）arraycopy：数组拷贝，数组越界/基本数据的数组类型不同/引用数据的数组类型不兼容抛出异常

5.Runtime类

       /*单例模式实现，无法创建对象，但可用方法getRuntime获取指向该对象的引用*/
       （1）getRuntime：返回指向唯一的Runtime对象的引用
       （2）exit：System.exit(0)的底层实现
       （3）availableProcessors：获取CPU的线程数
       （4）maxMemory：JVM能从系统中获取总内存大小（byte）
       （5）totalMemory：JVM已经从系统中获取总内存大小（byte）
       （6）freeMemory：JVM剩余内存大小（byte）
       （7）exec：传String类型参数运行cmd命令（shutdown关机，-s默认一分钟后执行、-s -t等待指定时间后关机、-a取消关机、-r关机并重启）
       （8）availableProcessors：返回Java虚拟机可用的虚拟处理器个数，此个数为Java虚拟机的最大并行数

6.Object类

       /*注意直接用引用类型变量给引用类型变量赋值，不等于浅拷贝，浅拷贝也是拷贝，因此也会创建新对象*/
       （1）toString
       （2）equals
       （3）clone：浅拷贝（新对象的成员变量用原对象的成员变量直接赋值），可重写实现深拷贝，可能抛出异常，重写clone的类需实现Cloneable接口
       （4）hashCode：计算得到该对象的int型的哈希值，默认用地址值进行计算，一般用属性值计算哈希值
       （5）getClass：获取该对象所属类的字节码文件类的对象

7.Cloneable接口

/*没有抽象方法的接口，重写了clone方法的类一般实现该接口，告诉外界该类属于Cloneable重写了clone方法*/

8.Throwable类

       /*异常类和错误类的父类*/
       （1）getMessage：返回此Throwable的详细消息字符串
       （2）toString：返回此可Throwable的简短描述
       （3）printStackTrace：把异常的错误信息输出在控制台

9.Error类

/*代表系统级别的错误，如内存溢出，属于严重问题，一般开发人员无法处理这类问题，Error类是给sun公司自己用的*/

10.Exception类

/*异常类，RuntimeException类（运行时异常）和其它异常（编译时异常）的父类
可以让类继承Exception实现自定义异常，一般继承RuntimeException类*/

11.Thread类

       /*线程类，实现了Runnable接口，具有run方法
       创建线程对象后，调用start方法启动线程，若直接调用run方法只是普通的方法调用，没有多线程的效果
       线程的生命周期有新建、就绪、运行、阻塞、死亡*/
       （1）Thread(Runnable r,String s)：传入Runnable类型的对象，将其赋值给Runnable类型的成员变量tar，线程名s有默认值
       （2）setName：设置线程的名字
       （3）getName：获取线程的名字
       （4）start：启动线程
       （5）run：没有返回值，线程执行的内容，实际上调用了成员变量tar的run方法
       （6）currentThread：静态方法，返回此方法执行时所在线程的线程对象，因此返回类型是Thread类型
       （7）sleep(long time)：静态方法，让此方法执行时所在的线程休眠time毫秒，使线程进入计时等待状态
       （8）setPriority(int)、getPriority：设置/获取线程的优先级
       （9）setDaemon(boolean on)：在线程启动前设为守护线程（为其它线程提供服务），非守护线程全结束后系统通知仍未结束的守护线程终止运行
       （10）yield：静态方法，出让/礼让线程，让此方法执行时所在的线程从运行态变为就绪态
       （11）join：插入线程/插队线程，thread.join()使thread线程结束后再继续执行此方法执行时所在的线程
       （12）线程的实现方式（方法③是具有返回值的线程的实现方式，涉及的类见java.util.concurrent包）
           ①创建Thread时传入Runnable实现类的对象，调用Thead的start方法
           ②继承Thread重写run方法自定义线程类，调用自定义线程类的start方法
           ③定义类C实现Callable重写call，创建Thread时传入代理C对象的FutureTask对象然后调用start()，用FutureTask对象的get获取返回值

12.Class类

       /*字节码文件类，可以通过反射获取一个类的成员变量和成员方法，并对相关信息进行解剖
       构造方法私有，无法在外界创建对象
       获取Class对象的方式有Class.forName("全类名")、类名.class、对象.getClass()*/
       （1）forName(String)：静态方法，传入全类名，返回该类的字节码文件类的对象
       （2）getConstructors：返回存储所有公有访问权限的构造方法对象的数组Constructor<>[]
       （3）getConstructor：返回单个公有访问权限的构造方法对象，传入Class类的对象表示目标构造方法的参数以指定返回的构造方法对象
       （4）getDeclaredConstructors：返回存储所有构造方法对象的数组Constructor<>[]
       （5）getDeclaredConstructor：返回单个构造方法对象，传入Class类的对象表示目标构造方法的参数以指定返回的构造方法对象
       （6）getFields：返回存储所有公有访问权限的成员变量对象的数组Field[]
       （7）getField(String)：返回单个公有访问权限的成员变量对象，传入变量名指定返回的成员变量对象
       （8）getDeclaredFields：返回存储所有成员变量对象的数组Field[]
       （9）getDeclaredField(String)：返回单个成员变量对象，传入变量名指定返回的成员变量对象
       （10）getMethods：返回存储所有公有访问权限的成员方法对象的数组Method[]，包括继承的
       （11）getMethod：返回单个公有访问权限的成员方法对象，传入方法名和代表目标方法形参类型的Class类的对象指定返回的成员方法对象
       （12）getDeclaredMethods：返回存储所有成员方法对象的数组Method[]，不包括继承的
       （13）getDeclaredMethod：返回单个成员方法对象，传入方法名和代表目标方法形参类型的Class类的对象指定返回的成员方法对象

13.reflect包

       （1）Constructor类
           /*构造方法类，一个构造方法类的对象表示一个构造方法*/
           ①newInstance：用表示的构造方法创建对象
           ②setAccessible(boolean)：传入true，表示暂时取消该构造方法的访问权限限制
           ③getModifiers：返回表示的构造方法的权限修饰符，返回类型为int
           ④getParameterCount：返回表示的构造方法的形参个数
           ⑤getParameterTypes：返回存储表示的构造方法的所有参数类型的数组Class<>[]
           ⑥getParameters：返回存储表示的构造方法的所有参数的数组Parameter[]
       （2）Field类
           /*成员变量类，一个成员变量类的对象表示一个成员变量*/
           ①getModifiers：返回表示的成员变量的权限修饰符，返回类型为int
           ②getName：返回表示的成员变量的变量名
           ③getType：返回表示的成员变量的类型的字节码文件类的对象Class<>
           ④setAccessible(boolean)：传入true，表示暂时取消该成员变量的访问权限限制
           ⑤get：传入该成员变量所属类的对象，返回该对象中此成员变量的值，返回类型为Object
           ⑥set：传入该成员变量所属类的对象obj以及类型与该成员变量相同的对象val，将obj中该成员变量的值置为val
       （3）Method类
           /*成员方法类，一个成员方法类的对象表示一个成员方法*/
           ①invoke：传入该成员方法所属类的对象obj和该方法所需的实参，用obj调用该成员方法并返回Object类型的对象
           ②setAccessible(boolean)：传入true，表示暂时取消该成员方法的访问权限限制
           ③getModifiers：返回表示的成员方法的权限修饰符，返回类型为int
           ④getName：返回表示的成员方法的方法名
           ⑤getParameterCount：返回表示的成员方法的形参个数
           ⑥getParameterTypes：返回存储表示的成员方法的所有参数类型的数组Class<>[]
           ⑦getParameters：返回存储表示的成员方法的所有参数的数组Parameter[]
           ⑧getExceptionTypes：返回存储表示的成员方法可能会抛出的所有异常类型的数组Class<>[]
       （4）Parameter类
           /*参数类，一个参数类的对象表示方法中的一个参数*/
       （5）Proxy类
           /*代理生成类，用于在代理模式下生成目标代理类并返回该代理类的对象，构造方法非公有，无法在外界创建对象
           cd指定加载生成的代理类的类加载器，一般设置为加载方法调用处所在类的类加载器，即所在类名.class.getClassLoader()
           代理类与被代理类需实现相同接口以保证二者具有相同方法，因此需要将代理类需实现的所有接口传给i以定义目标代理类
           代理类需自定义各接口以增加被代理类的功能，因此传入h自定义各接口的方法体，每个被代理的方法底层都是调用h的invoke方法*/
           ①newProxyInstance(ClassLoader cd,Class<?>[] i,InvocationHandler h)：静态方法，创建目标代理类的对象，返回Object类型
       （6）InvocationHandler接口
           /*具有抽象方法invoke，用于自定义代理类所有代理方法的功能，所有代理方法底层都是调用invoke方法
           obj表示代理类的对象，m表示本次调用invoke的代理方法的成员方法类对象，args表示传给本次调用invoke的代理方法的参数
           用匿名内部类实现该接口时注意匿名内部类可直接使用外部类成员，因此可在invoke中调用外面被代理类对象的被代理方法实现方法代理*/
           ①invoke(Object obj,Method m,Object[] args)：抽象方法，返回值为Object

14.ThreadLocal类

        /*用于存储线程级局部变量的类。ThreadLocal为线程提供线程隔离的存储空间，线程a存储的变量只有线程a才能访问到
       ThreadLocal中可以存储多个线程的局部变量，只是每个线程只能拿到自己存的变量，因此ThreadLocal可以是静态成员变量，从而被多个线程共享，从而节省创建变量的空间*/
        （1）set(T)：设置当前线程的线程局部变量的值
       （2）get：返回当前线程所对应的线程局部变量的值
       （3）remove：移除当前线程的线程局部变量

二、java.util包

1.Scanner类

       （1）nextInt：输入整数，遇到间隔符结束输入。
       （2）nextDouble：输入小数，遇到间隔符结束输入。
       （3）next：输入字符串，遇到间隔符结束输入，间隔符依旧留在缓冲区中。
               底层实现——根据输入的字符串字面量new一个新的String对象s并返回s，因此s的地址值与输入的字符串字面量的地址不同
       （4）nextLine：输入一行字符串，遇到换行结束输入，换行符从缓冲区中移除，但返回的String不会存储'\n'。

2.Random类

3.StringJoiner

       /*用于自定义字符串拼接的间隔字符、起始字符、结束字符*/
       （1）add
       （2）length
       （3）toString

4.Objects类

       /*实现的equal等方法能够处理引用为空等异常情况，简化了手动调用对象的equals方法时的异常情况判断*/
       （1）equals：做非空判断，比较两个对象
       （2）isNull、nonNull

5.regex包

       /*查找满足要求的字符串*/
       （1）Pattern类：正则表达式对象，用静态方法compile获得对象
       （2）Matcher类
           /*用Pattern对象的matcher方法获取，Matcher m=pattern.matcher(str)，m要在str中查找符合pattern规则的字符串*/
           ①find：查找下一个符合规则的子串，有返回true，没有返回false
           ②group：返回上一次find找到的子串
           ③replaceAll：String类的replaceAll方法的底层实现

6.Date类

       /*JDK7创立，set方法多线程不安全，可以创建指定时间的Date对象，空参构造时默认初始化为当前时间*/
       （1）setTime
       （2）getTime

7.Calendar抽象类

       /*JDK7创立，set方法多线程不安全，该类中一月用数字0表示，星期天用数字1表示*/
       （1）getInstance：返回Calendar引用，引用所指对象是其子类，默认为当前时间
       （2）setTime：传入Date对象设置时间
       （3）getTime：返回Date对象
       （4）get/set：获取/设置日历中某个字段的数据，可用Calendar.YEAR等常量指定字段
       （5）add：增加某个字段的值
       （6）getTimeInMillis、setTimeInMillis：获取/设置时间毫秒值

8.Arrays类

       /*构造方法私有，不可在外界创建对象*/
       （1）toString(arr)：将数组arr拼接成字符串
       （2）binarySearch
       （3）copyOf、copyOfRange：返回新数组，但新数组中的数据由原数组浅拷贝得到
       （4）fill：填充数组
       （5）sort：底层使用快速排序，可传入具有自定义排序规则的对象
       （6）stream：获取该数组的Stream流对象，流中的元素由数组元素的引用赋值得到

9.单列集合体系顶层接口Collection接口

       /*List接口、Set接口继承自Collection接口
       ArrayList类、LinkedList类、Vector类（已被淘汰）继承自List接口，HashSet类、TreeSet类继承自Set接口
       LinkedHashSet类继承自HashSet接口
       存储类型为Object时可同时存储不同类型的数据，因此称为集合*/
       （1）add(ele)、clear、remove(ele)：remove底层调用类的public boolean equals(Object o)判断元素是否相同
       （2）contains、isEmpty
       （3）size
       （4）iterator：获取当前容器的迭代器对象，默认指向0索引
           ①hasNext：判断当前位置是否有元素
           ②next：获取当前元素并移动迭代器，集合记录了增加/删除元素的次数i，iterator初始化时用j记录i，next先判断j==i，不等于则抛出异常
           ③remove：移除迭代器当前返回的最后一个元素
       （5）stream：集合元素的引用值复制给Stream流对象并返回，双列集合Map需先调用keySet/entrySet转为单列集合后再获取流对象
       （6）遍历方式
           ①迭代器遍历：当前位置无元素时用next会报错，不能在迭代器遍历时用集合的方法增加/删除元素，否则报错，但可用迭代器的方法删除
           ②增强for循环：只能遍历数组/单列集合，迭代器遍历实现（遍历规则相同），值传递给ele，存引用的容器可通过ele修改元素的成员变量
           ③forEach成员方法遍历：传入函数式接口的实现类对象操作集合中的元素，可用Lambda表达式简写，底层根据容器特性用fori或增强for实现

10.List接口

       /*添加的元素有序（存取顺序相同）、可重复、有索引，以下列出比Collection多出来的方法*/
       （1）add(int,ele)、remove(int)：在指定索引处添加/删除元素
       （2）set、get
       （3）listIterator：获取当前列表的列表迭代器对象，默认指向0索引
           ①hasNext、hasPrevious
           ②next、previous
           ③nextIndex、previousIndex
           ④add、remove、set：set可更换迭代器所指向的元素
       （4）of：静态方法，获取不可变List集合，集合添加、修改、删除元素的方法不能调用，但可通过元素引用调用修改元素的方法

11.ArrayList类

       /*底层用动态数组实现，长度可变，增删慢，查找快。
       删除元素并不简单赋值为null，而是将后面元素全部往前移1个位置
       空参构造默认容量为0，首次加入元素后容量变为max(1.5倍容量，实际长度)，之后元素存满时，容量变为max(1.5倍容量，实际长度)*/
       （1）初始化：ArrayList<Object> list = new ArrayList<>();//标准写法
                   ArrayList<Object> list = new ArrayList();//省略第二个<>，不标准
                  ArrayList list = new ArrayList<>();//存储Object类型的写法，不标准
                  ArrayList list = new ArrayList();//存储Object类型且省略第二个<>的写法，不标准
       （2）get：((Phone)list.get(0)).call();//存储Object类型时，要使用存储成员的方法时需强制转换指明类型
       （3）addAll：传入ArrayList对象，将该对象中的所有元素加入到调用者中

12.LinkedList类

       /*底层用双链表实现，长度可变，增删快，查找慢*/
       （1）addFirst、addLast
       （2）getFirst、getLast
       （3）removeFirst、removeLast

13.Set接口

/*添加的元素无序、不重复、无索引，其实现类底层都用对应的Map类实现*/
（1）of：静态方法，获取不可变Set集合，集合添加、修改、删除元素的方法不能调用，但可通过元素引用调用修改元素的方法，传入元素重复报错

14.HashSet类

       /*添加的元素无序、不重复、无索引，底层哈希表实现
       JDK8之前数组+链表实现哈希表，拉链法解决哈希冲突，新元素挂在老元素上
       JDK8之后数组+链表+红黑树实现，拉链法解决冲突，老元素挂在新元素上，某个链表长度>8且数组长度>=64时该链表转为红黑树
       添加元素后哈希表长度为16，加载因子为0.75，元素个数达到表长*0.75后，哈希表扩容为表长度的2倍
       为了正确进行哈希值计算和元素去重，最好重写hashCode方法和equals方法，且HashSet中的红黑树用哈希值大小进行排序*/

15.LinkedHashSet类

/*添加的元素有序、不重复、无索引，元素的存储和取出顺序一致
底层数据结构是数组+链表+红黑树实现的哈希表，但用双链表连接了存储的元素，实现了存储顺序的记录，迭代器遍历时遍历双向链表*/

16.TreeSet类

       /*添加的元素可排序、不重复、无索引，底层直接红黑树实现，默认升序排序
       自定义类型排序需实现Comparable接口（红黑树排序和去重用compareTo实现）或创建TreeSet时传Comparator接口的实现类对象
       TreeSet有Comparator接口的实现类对象时，不论元素有无实现Comparable接口，都按Comparator实现类对象定义的规则排序*/

17.双列集合体系顶层接口Map接口

       /*存储键值对
       HashMap类、TreeMap类、Hashtable类继承自Map接口，LinkedHashMap类自HashMap接口，Properties类继承自Hashtable类
       值存储的自定义对象无需重写hashCode和equals方法，但键存储的自定义对象需要*/
       （1）put、remove、clear：put时若Map中已存在对应的键，则会将值覆盖，并返回覆盖的值；remove返回被删除的键值对中的值
       （2）containsKey、containsValue、isEmpty、size
       （3）get：获取目标键对应的值
       （4）keySet：返回存储所有键的Set集合
       （5）entrySet：返回存储键值对的Set集合
       （6）Map.Entry类：Map接口的内部接口，键值对接口，是Map容器的存储类型
       （7）forEach
       （8）of：静态方法，获取不可变Map集合，性质同不可变Set，但形参不是可变参数，最多传10对键值对
       （9）ofEntries：静态方法，传入Entry对象，返回不可变Map集合，形参个数无上限
       （10）copyOf：静态方法，传入Map集合m，返回存储m中所有元素的不可变Map集合

18.HashMap类

/*存储特点由键决定，无序、不重复、无索引，底层实现与HashSet相同*/

19.LinkedHashMap类

/*存储特点由键决定，有序、不重复、无索引，底层实现与LinkedHashSet相同*/

20.TreeMap类

/*存储特点由键决定，添加的元素可排序、不重复、无索引，底层实现与TreeSet相同*/

21.Properties类

       /*.properties配置文件信息类，.properties配置文件以键值对方式存储数据，因此此类属于双列集合类
       Properties类的键和值均为Object类型*/
       （1）put：存入的键已经存在时覆盖值
       （2）store(OutputStream/Writer ow,String comments)：通过输出流将配置信息写入文件（不会关闭文件），并添加注释comments
       （3）load(InputStream/Reader)：通过输入流将文件中的配置信息读取到类中（不会关闭文件）

22.Collections类

       /*构造方法私有，不可在外界创建对象*/
       （1）addAll：向单列集合中批量添加数据
       （2）shuffle：打乱List集合元素的顺序
       （3）sort、binarySearch
       （4）copy、fill、max/min、swap：copy为引用传递，源集合中元素的成员变量变化会影响目标集合中元素的成员变量

23.Stream接口

       /*用于批量处理数据，一个Stream流对象只能使用一次，流中的数据由并非拷贝得到，而是用引用值赋值得到*/
       （1）of：静态方法，传入任意个数据，返回能够处理这些数据的Stream流对象
       （2）concat：静态方法，合并两个流为一个流，返回合并后的流对象
       （3）filter：过滤元素，返回新的Stream流对象
       （4）limit：获取前几个元素，返回新的Stream流对象
       （5）skip：跳过前几个元素，返回新的Stream流对象
       （6）distinct：元素去重，底层用HashSet去重，注意重写hashCode方法，返回新的Stream流对象
       （7）map：传入函数式接口，用接口中的方法转换流中的数据类型，返回新的流对象
       （8）forEach、count
       （9）toArray：收集流中的数据放到数组中，可以传入函数式接口用于创建指定类型的数组
       （10）collect：收集流中的数据放到集合中，传入Colloctors.toList()/toSet()toMap()用于生成不同的集合，放到Map中若有键重复则报错

24.concurrent包

       （1）Callable接口
           /*函数式接口，抽象方法是有返回值的call方法，通常作为线程的执行任务，具有泛型，泛型类型为方法的返回值类型*/
       （2）FutureTask类
           /*用于代理Callable接口的实现类，间接实现了具有run方法的Runnable接口和具有get方法的Future接口
           具有泛型，泛型类型为代理的Callable接口实现类的泛型类型*/
           ①FutureTask(Callable)：传入代理的Callable实现类的对象，将其赋值给Callable类型的成员变量callable
           ②run：没有返回值，实际上调用了成员变量callable的call方法，并将方法返回值赋给Object类型成员变量outcome
           ③get：阻塞等待run方法执行结束，然后将成员变量outcome强制转换为泛型类型并返回
       （3）locks.Lock接口
           /*互斥锁，可以通过实例化的对象调用lock和unlock实现同步代码块的功能
           但由于没有代码块的限制，实现方式更灵活*/
           ①lock：阻塞式等待获得锁，相当于while(尝试获取锁==false) 当前线程进入当前锁的阻塞队列;
           ②unlock：将当前锁的阻塞队列的第一个线程唤醒到就绪队列
           ③newCondition：创建与当前锁绑定的条件变量并返回
       （4）locks.ReentrantLock类
           /*互斥锁locks.Lock接口的实现类*/
       （5）locks.Condition接口
           /*条件变量，用于在临界区中判断线程访问临界区的条件是否满足，若满足则访问临界区，若不满足则线程进入此条件变量的等待队列
           由于条件变量要能将临界区中的线程放入等待队列，因此条件变量需要与临界区的锁绑定，使线程进入等待队列后将临界区解锁
           互斥锁的阻塞队列存放无法进入临界区的线程，条件变量的等待队列存放临界区运行条件不满足的线程
           条件变量可以实现同步代码块synchronized(lock){}中lock.wait()和lock.notify()的功能，但没有代码块限制，实现方式更灵活
           唤醒丢失：生产者signal时消费者没有await导致唤醒丢失，当消费者再await就会等待，可以加个if判断是否需要等待解决唤醒丢失问题
           虚假唤醒：当线程被唤醒到就绪队列后一个临界区中的线程更改条件使唤醒的线程运行后条件不满足，可循环判断是否要等待解决问题*/
           ①await：将此方法执行时所在的线程放入条件变量的等待队列后调用绑定锁的unlock，被唤醒到就绪队列并运行后再调用绑定锁的lock
           ②signal：唤醒当前条件变量的等待队列中的第一个线程到就绪队列
           ③signalAll：唤醒当前条件变量的等待队列中的所有线程到就绪队列
       （6）BlockingQueue接口
           /*互斥访问的队列，内置了Lock锁，用Lock对象实现了队列访问与修改的互斥
           继承了Queue接口，Queue继承了Collection接口，Collection继承了Iterable接口*/
           ①put：往队列中放入一个元素
           ②take：从队列中取出一个元素
       （7）ArrayBlockingQueue类
           /*BlockingQueue接口的实现类，底层用数组实现，创建时必须指定数组长度*/
       （8）LinkedBlockingQueue类
           /*BlockingQueue接口的实现类，底层用链表实现，创建时无需指定元素最多个数*/
       （9）Executors类
           /*线程池工具类，构造方法私有，方法全静态，不可在外界创建对象
           可以调用方法返回不同类型的线程池对象*/
           ①newCachedThreadPool：创建没有线程上限的线程池
           ②newFixedThreadPool(int)：创建有线程上限的线程池
           ③defaultThreadFactory：创建线程工厂ThreadFactory接口的实现类对象，返回类型为ThreadFactory，该接口有创建线程的方法
       （10）ExecutorService接口
           /*线程池接口，通过Executors类创建*/
           ①submit(Runnable)：传入Runnable接口的实现类作为任务，将线程任务放入线程池的任务队列中
           ②shutdown：销毁线程池
       （11）ThreadPoolExecutor类
           /*线程池类，间接继承ExecutorService接口，对象创建后线程池就会开始工作
           最多可以有m个线程，但只能设置n个核心线程
           当存放线程任务的队列q不够放时，假设多出k个任务：
           若k+n<=m，用线程工厂f创建k个临时线程来处理这k个任务
           若k+n>m，用线程工厂f创建m-n个临时线程来处理m-n个任务，剩余k-(m-n)个任务用拒绝策略h拒绝处理
           当临时线程的空闲时间大于st时，销毁该临时线程，其中st的时间单位为t
           t可以设置为TimeUnit.SECONDS，表示时间单位为秒
           f可以用Executors工具类创建
           h可以用ThreadPoolExecutor的静态内部类创建，如传入new ThreadPoolExecutor.AbortPolicy()
           项目为CPU密集型运算时线程池的最大线程数一般设置为Java虚拟机的最大并行数+1
           项目为IO密集型运算时线程池的最大线程数一般设置为最大并行数*期望的CPU利用率*(CPU计算时间+等待时间)/CPU计算时间*/
           ①ThreadPoolExecutor(int n,int m,long st,TimeUnit t,BlockingQueue<Runnable> q,ThreadFactory f,RejectedExecutionHandler h)

25.UUID类

/*用于存储UUID*/
（1）randomUUID：返回存储不重复且随机的UUID的UUID对象

三、java.math包

1.BigInteger类

       /*初始化后其值不可改变，内部优化了常用数字，静态代码块提前创建-16-16的对象，此优化仅在调用valueOf时起作用
       底层存储方式：将传入字符串表示的大数字转为二进制，用int型数组存储二进制分段*/
       （1）valueOf：用传入的long变量创建BigInteger对象，重复获取-16-16不会创建新对象
       （2）add、divideAndRemainder、pow：不会修改原对象，只会创建新对象
       （3）max、min、equals
       （4）intValue：转为int类型数据，超范围数据有误

2.BigDecimal类

       /*初始化后其值不可改变，可以表示任意精度的有符号十进制数，
       0.3虽无法精确存储，但转成字符串时先四舍五入再转换，因此所得字符串就是"0.3"，且sout底层将变量转为字符串，因此直接打印也显示0.3
       内部优化了常用整数，拥有整数0-10范围内的的BigDecimal类型的静态常量，此优化仅在调用valueOf时起作用
       底层存储方式：将传入字符串转为一个个字符，并将每个字符转为ASCII表对应的数字，用byte型数组存储这些数字*/
       （1）BigDecimal(double)：传入0.3等double无法精确表示的数字时会出错，不推荐
       （2）BigDecimal(String)：推荐的构造方法
       （3）valueOf：传入的double/long变量创建BigDecimal对象。传double不易出错，会先转为字符串，再return new BigDecimal(String)；
                   传long时，重复获取整数0-10不会创建新对象
       （4）add、divide：divide有两种版本，用整除的版本却除不尽时会抛出异常

3.RoundingMode枚举

/*有代表四舍五入方式的常量*/

四、java.text包

1.SimpleDateFormat类

       /*指定的时间输出格式*/
       （1）SimpleDateFormat(str)：str为时间输出格式，示例str="yyyy-MM-dd HH:mm:ss"，空参构造时为默认格式
       （2）format：传入Date对象，按str的格式返回Date对象存储的时间的字符串
       （3）parse：传入str格式的字符串，返回相应时间的Date对象

五、java.time包

1.ZoneId抽象类

       /*JDK8创立，不可修改，因此多线程安全，表时区的类*/
       （1）getAvailableZoneIds：返回存储所有时区的集合
       （2）systemDefault：返回存储系统默认时区的ZoneId引用，引用所指对象是子类（抽象类不可创建对象）
       （3）of(str)：返回存储str所代表时区的ZoneId引用，引用所指对象是子类

2.Instance类

       /*JDK8创立，不可修改，多线程安全，构造方法私有，不可在外界创建对象，表标准时间的类*/
       （1）now：返回存储当前标准时间的Instance对象
       （2）ofXXX：传入秒/毫秒/纳秒，返回Instance对象
       （3）isXXX：判断时间先后的相关方法
       （4）atZone(zoneid)：传入ZoneId对象，返回存储调用对象表示的标准时间在指定时区下的时间的ZonedDateTime对象
       （5）minusXXX/plusXXX：减少/增加时间的相关方法，返回存储修改后的时间的新对象

3.ZonedDateTime类

       /*JDK8创立，不可修改，多线程安全，构造方法私有，不可在外界创建对象，表指定时区下的时间的类*/
       （1）now：返回存储当前时区下的时间的ZonedDateTime对象
       （2）ofXXX：返回存储指定时区下的时间的ZonedDateTime对象
       （3）withXXX：修改时间的相关方法，返回存储修改后的时间的新对象
       （4）minusXXX/plusXXX：减少/增加时间的相关方法，返回存储修改后的时间的新对象

4.format包

       （1）DateTimeFormatter类
           /*用于时间的格式化和解析*/
           ①ofPattern(str)：str示例str="yyyy-MM-dd HH:mm:ss"，返回DateTimeFormatter引用
           ②format：传入ZonedDateTime对象，按时间格式返回表示传入对象所存时间的字符串

5.LocalDate、LocalTime、LocalDateTime、MonthDay类

       /*JDK8创立，不可修改，多线程安全，构造方法私有，不可在外界创建对象，4个类分别能获取的时间为年月日、时分秒、年月日时分秒、月日*/
       （1）now：获取当前时间的对象
       （2）of：获取指定时间的对象
       （3）getXXX：获取年、月、日、时、分、秒等信息
       （4）isXXX：判断时间先后相关方法
       （5）withXXX：修改时间的相关方法，返回存储修改后的时间的新对象
       （6）minusXXX/plusXXX：减少/增加时间的相关方法，返回存储修改后的时间的新对象，MonthDay类没有该方法
       （7）toLocalDate/toLocalTime：根据调用的LocalDateTime对象，创建相应的LocalDate/LocalTime对象并返回

6.Period、Duration类

       /*JDK8创立，不可修改，多线程安全，构造方法私有，不可在外界创建对象，表时间间距的类*/
       （1）between：返回传入的两个时间对象之间的间距
       （2）Period——getXXX、toTotalMonths；Duration——toXXX：获取时间间隔的相关信息

7.temporal包

（1）ChronoUnit类
/*具有YEARS、MONTHS等静态成员变量，这些变量有between方法来计算两个时间相差的年/月/...，返回long*/

六、java.io包

1.File类

       /*File对象表示文件或文件夹，表示的文件或文件夹可以存在也可以不存在*/
       （1）isDirectory、isFile、exists
       （2）length、lastModified：length只能获取文件的大小（不能计算文件夹的大小）
       （3）getAbsolutePath、getPath、getName、getParentFile
       （4）createNewFile：创建文件，如果文件没有加后缀名，创建无后缀文件；文件已存在时方法返回false，父级路径不存在时抛出编译时异常
       （5）mkdir、mkdirs：mkdir创建单级文件夹，mkdirs创建多级文件夹，文件夹路径存在时方法返回false
       （6）delete：删除文件、空文件夹，不能删除非空的文件夹
       （7）listFiles：获取路径下的所有File，包含隐藏文件，返回File[]；当前File不存在或File为文件或File设置权限限制当前用户进入时返回null

2.InputStream、OutputStream抽象类

       /*字节输入/输出流，FileInputStream类、BufferedInputStream类、ObjectInputStream类、ZipInputStream类继承或间接继承自InputStream
       OutputStream的继承体系类似，但OutputStream还有子类PrintStream类
       字节输入/输出流以字节为单位读/写*/

3.Reader、Writer抽象类

       /*字符输入/输出流，FileReader类、BufferedReader类、InputStreamReader类继承或间接继承自Reader
       Writer的继承体系类似，但Writer还有子类PrintWriter类
       字符输入/输出流以字符为单位读/写
       IDEA默认将文件的字节按UTF-8的编码方式解码为字符，默认将字符按UTF-8的编码方式编码为字节，因此默认创建的文件的编码方式为UTF-8*/

4.FileOutputStream类

       /*操作本地文件的字节输出流，可以把程序中的数据以字节为单位写到本地文件中，数据只能写一次，未开辟缓冲区提高性能
       创建对象时文件不存在会创建新文件，但要保证父级路径存在*/
       （1）FileOutputStream(File/String f,boolean b)：可用File或String创建对象并打开文件，b=true以追加方式打开，默认b=false以覆盖方式打开
       （2）write(int)：一次写一个字节的数据，传入整数，在文件中存储该整数对应的字节
       （3）write(byte[])、write(byte[] b,int start,int len)：一次写一个字节数组的数据/部分数据，可结合字符串的getBytes方法简化
       （4）close：关闭文件，若使用文件后不关闭，程序执行过程中将无法对文件进行一些操作，如删除、移动

5.FileInputStream类

       /*操作本地文件的字节输入流，可以把本地文件中的数据以字节为单位输入到程序中，数据只能读一次，未开辟缓冲区提高性能
       创建对象时如果文件不存在，直接报错
       read(byte[] buff)方法和FileOutputStream类的write(byte[] b,int start,int len)方法结合可实现文件拷贝*/
       （1）FileInputStream(File/String)：可用File或String创建对象并打开文件，解码方式code
       （2）read：往后读取一个字节，返回该字节对应的整数，若已读到文件末尾，则读不到任何数据，返回-1
       （3）read(byte[] buff)：往后读取一个字节数组数据并尽量填满数组，不清空未填充部分，返回读到的数据个数，读不到数据时返回-1
       （4）close：关闭文件，若使用文件后不关闭，程序执行过程中将无法对文件进行一些操作，如删除、移动

6.FileWriter类

       /*操作本地文件的字符输出流，可以把程序中的数据以字符为单位写到本地文件中，数据只能写一次，
       其父类是转换输出流OutputStreamWriter类，因此FileWriter是针对FileOutputStream的转换流，底层使用FileOutputStream类读数据
       开辟了长度为8192的缓冲区提高性能
       缓冲区未满时，将数据写到缓冲区中，缓冲区满时，先将缓冲区中的数据写到文件中，再将数据写到缓冲区中
       创建对象时文件不存在会创建新文件，但要保证父级路径存在*/
       （1）FileWriter(File/String f,boolean b)：可用File或String创建对象并打开文件，b=true以追加方式打开，默认b=false以覆盖方式打开
       （2）write(int)：写一个字符，实际写的是整数在字符集中对应的字符（相当于强转(char)intNum），并根据编码方式往文件中写入字节
       （3）write(String)、write(String s,int start,int len)：写字符串/部分字符串
       （4）write(char[])、write(char[] buff,int start,int len)：写字符数组/部分字符数组
       （5）flush：将缓冲区的数据写到文件中
       （6）close：先调用flush，再关闭文件，若使用文件后不关闭，程序执行过程中将无法对文件进行一些操作，如删除、移动

7.FileReader类

       /*操作本地文件的字符输入流，可以把可以把本地文件中的数据以字符为单位输入到程序中，数据只能读一次
       其父类是转换输入流InputStreamReader类，因此FileReader是针对FileInputStream的转换流，底层使用FileInputStream类写数据
       开辟了长度为8192的缓冲区提高性能
       缓冲区有数据时，从缓冲区中读取数据，缓冲区为空时先从文件中读取数据到缓冲区，再从缓冲区中读取数据
       创建对象时如果文件不存在，直接报错*/
       （1）FileReader(File/String)：可用File或String创建对象并打开文件
       （2）read：往后读取一个字符，返回解码后的字符在字符集中对应的整数，若已读到文件末尾，则读不到任何数据，返回-1
       （3）read(char[] buff)：往后读取一个字符数组数据并尽量填满数组，不清空未填充部分，返回读到的数据个数，读不到数据时返回-1
       （4）close：关闭文件，若使用文件后不关闭，程序执行过程中将无法对文件进行一些操作，如删除、移动

8.BufferedOutputStream类

       /*字节缓冲输出流，开辟了长度为8192的缓冲区提高性能
       缓冲区未满时，将数据写到缓冲区中，缓冲区满时，先将缓冲区中的数据写到文件中，再将数据写到缓冲区中
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此只是在基本流的基础上加了一个缓冲区，操作的文件对象也由基本流决定*/
       （1）BufferedOutputStream(InputStream os,int size)：传入封装的基本流，缓冲区大小size默认是8192
       （2）write：参考FileOutputStream类的写方法，缓冲区满后调用基本流的write(byte[] b,int start,int len)方法
       （3）flush：将缓冲区的数据写到文件中
       （4）close：先调用flush，再调用封装的基本流的close方法

9.BufferedInputStream类

       /*字节缓冲输入流，开辟了长度为8192的缓冲区提高性能
       缓冲区有数据时，从缓冲区中读取数据，缓冲区为空时先从文件中读取数据到缓冲区，再从缓冲区中读取数据
       该类底层封装了基本流，读数据调用的方法是基本流的读方法，因此只是在基本流的基础上加了一个缓冲区，操作的文件对象也由基本流决定*/
       （1）BufferedInputStream(InputStream is,int size)：传入封装的基本流，缓冲区大小size默认是8192
       （2）read：参考FileInputStream类的写方法，缓冲区空时调用基本流的read(byte[] buff)方法
       （3）close：调用封装的基本流的close方法

10.BufferedWriter类

       /*字符缓冲输出流，开辟了长度为8192的缓冲区提高性能
       缓冲区未满时，将数据写到缓冲区中，缓冲区满时，先将缓冲区中的数据写到文件中，再将数据写到缓冲区中
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此只是在基本流的基础上加了一个缓冲区，操作的文件对象也由基本流决定
       但FileWriter类已开辟了缓冲区，因此封装的基本类是FileWriter类时，速度提升不大*/
       （1）BufferedWriter(Writer w,int size)：传入封装的基本流，缓冲区大小size默认是8192
       （2）newLine：根据不同平台写入相应换行符，Windows"\r\n"，Linux'\n'，Mac'\r'，Java底层封装了'\n'，底层根据平台将'\n'转为相应换行符
       （3）write：参考FileWriter类的写方法，缓冲区满后调用基本流的write(char[] buff,int start,int len)方法
       （4）flush：将缓冲区的数据写到文件中
       （5）close：先调用flush，再调用封装的基本流的close方法

11.BufferedReader类

       /*字符缓冲输入流，开辟了长度为8192的缓冲区提高性能
       缓冲区有数据时，从缓冲区中读取数据，缓冲区为空时先从文件中读取数据到缓冲区，再从缓冲区中读取数据
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此只是在基本流的基础上加了一个缓冲区，操作的文件对象也由基本流决定
       但FileReader类已开辟了缓冲区，因此封装的基本类是FileReader类时，速度提升不大*/
       （1）BufferedReader(Reader r,int size)：传入封装的基本流，缓冲区大小size默认是8192
       （2）readLine：读取一行数据，返回String，如果没有数据可读时，返回null
       （3）read：参考FileReader类的写方法，缓冲区空时调用基本流的read(char[] buff)方法
       （4）close：调用封装的基本流的close方法

12.OutputStreamWriter类

       /*转换输出流，一般字节流想要使用字符流中的方法时使用转换流，底层使用字节流写数据*/
       （1）OutputStreamWriter(OutputStream os,String code)：数据的编码方式code默认是Unicode字符集的UTF-8
       （2）write(int)：写一个字符，实际写的是整数在字符集中对应的字符（相当于强转(char)intNum），并根据编码方式往文件中写入字节
       （3）write(String)、write(String s,int start,int len)：写字符串/部分字符串
       （4）write(char[])、write(char[] buff,int start,int len)：写字符数组/部分字符数组
       （5）close：调用封装的字节流的close方法

13.InputStreamReader类

       /*转换输入流，一般字节流想要使用字符流中的方法时使用转换流，底层使用字节流读数据*/
       （1）InputStreamReader(InputStream is,String code)：数据的解码方式code默认是Unicode字符集的UTF-8
       （2）read：往后读取一个字符，返回解码后的字符在字符集中对应的整数，若已读到文件末尾，则读不到任何数据，返回-1
       （3）read(char[] buff)：往后读取一个字符数组数据并尽量填满数组，不清空未填充部分，返回读到的数据个数，读不到数据时返回-1
       （4）close：调用封装的字节流的close方法

14.ObjectOutputStream类

       /*序列化流，可以把java中的对象写到本地文件中
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此在基本流的基础上增加了序列化对象的功能，操作的文件对象也由基本流决定
       若序列化了多个对象将无法确定读对象的次数，因此可将多个对象放到ArrayList中，再将ArrayList对象序列化到文件中即可*/
       （1）ObjectOutputStream(OutputStream os)：传入封装的OutputStream流对象
       （2）writeObject(Object)：把对象序列化写到文件中，目标类需实现Serializable接口(无抽象方法，告诉外界该类属于Serializable可以序列化)
       （3）close：调用封装的字节流的close方法

15.ObjectInputStream类

       /*反序列化流，可以把序列化到本地文件中的对象读取到程序中
       该类底层封装了基本流，读数据调用的方法是基本流的读方法，因此在基本流的基础上增加了反序列化对象的功能，操作的文件对象也由基本流决定
       每个类都会根据拥有的成员计算出一个版本号，对象的序列化内容就存有该对象所属类的版本号
       当类的成员发生更改后，从文件中读取对象并反序列化由于版本号不同就会报错
       可以定义private final static long serialVersionUID=1L固定该类的版本号，使修改类后版本号依旧不变
       可以用transient修饰成员使对象序列化时不会序列化该成员*/
       （1）ObjectInputStream(InputStream is)：传入封装的InputStream流对象
       （2）readObject：从文件中读取对象并反序列化，返回Object类，可以强转为目标类，若无对象可读，抛出异常
       （3）close：调用封装的字节流的close方法

16.PrintStream类

       /*字节打印流，打印流特有写方法的效果参考sout
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此只是在基本流的基础上增加了特有的写功能，操作的文件对象也由基本流决定
       由于该类没有设置缓冲区，因此封装的基本流也没有设置缓冲区时，该类即使不设置自动刷新也会自动刷新*/
       （1）PrintStream(OutputStream/File/String)：传入封装的OutputStream流对象/文件/字符串，传入文件或字符串时也会创建基本流并封装
       （2）PrintStream(String str,Charset charset)：传入字符串并创建封装的基本流，同时指定字符编码
       （3）PrintStream(OutputStream os,boolean autoFlush,String code)：传入封装的流，并设置是否自动刷新，编码方式code默认是UTF-8
       （4）write：常规的写方法，参考FileInputStream类的写方法
       （5）println/print：特有的写方法，打印任意数据，其中println能够自动换行并刷新
       （6）printf(String format,Object... args)：特有的写方法，带有占位符的打印语句，不换行
       （7）close：调用封装的基本流的close方法

17.PrintWriter类

       /*字符打印流，打印流特有写方法的效果参考sout
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，因此只是在基本流的基础上增加了特有的写功能，操作的文件对象也由基本流决定
       由于该类底层设置了缓冲区，因此要实现自动刷新的效果需要设置autoFlush*/
       （1）PrintWriter(Write/File/String)：传入封装的Write流对象/文件/字符串，传入文件或字符串时也会创建基本流并封装
       （2）PrintWriter(String str,Charset charset)：传入字符串并创建封装的基本流，同时指定字符编码
       （3）PrintWriter(Write w,boolean autoFlush,Charset charset)：传入封装的流，并设置是否自动刷新，编码方式code默认是UTF-8
       （4）write：常规的写方法，参考FileWrite类的写方法
       （5）println/print：特有的写方法，打印任意数据，其中println能够自动换行并刷新
       （6）printf(String format,Object... args)：特有的写方法，带有占位符的打印语句，不换行
       （7）flush：将缓冲区的数据写到文件中
       （8）close：先调用flush，再调用封装的基本流的close方法

18.ZipOutputStream类

       /*字节压缩流
       该类底层封装了基本流，写数据调用的方法是基本流的写方法，在基本流的基础上增加了压缩功能，操作的文件对象也由基本流决定
       ZipEntry代表压缩包中的一个文件/文件夹，可传入相对路径（表示代表的文件/文件夹在压缩包中的相对路径）创建ZipEntry对象*/
       （1）ZipOutputStream(OutputStream os)：传入封装的OutputStream流对象
       （2）putNextEntry(ZipEntry)：往压缩包中放入下一个ZipEntry对象（表示文件时打开该文件）
       （3）write(int)：从当前ZipEntry对象表示的压缩包中的文件中往后写一个字节，传入整数，在文件中存储该整数对应的字节
       （4）closeEntry：关闭当前打开的ZipEntry对象代表的文件
       （5）close：调用封装的基本流的close方法

19.ZipInputStream类

       /*字节解压缩流
       该类底层封装了基本流，读数据调用的方法是基本流的读方法，在基本流的基础上增加了解压缩功能，操作的文件对象也由基本流决定*/
       （1）ZipInputStream(InputStream is)：传入封装的InputStream流对象
       （2）getNextEntry：获取下一个ZipEntry对象（表示文件时打开该文件），没有文件/文件夹时返回null
       （3）read：从当前ZipEntry对象表示的压缩包中的文件中往后读一个字节，返回数据在ASCII上对应的整数，读不到任何数据时返回-1
       （4）closeEntry：关闭当前打开的ZipEntry对象代表的文件
       （5）close：调用封装的基本流的close方法

七、java.net包

1.URL类

       /*一个URL对象代表一个网址*/
       （1）URL(String)：传入网址字符串创建URL对象
       （2）openConnection：返回URLConnection对象

2.URLConnection类

/*一个URLConnection对象代表一个网址与程序的连接通道*/
（1）getInputStream：返回操作的文件是该网页文件的InputStream对象

3.InetAddress类

       /*IP地址类，构造方法非public，无法直接用构造方法创建对象，只能通过静态方法创建对象*/
       （1）getByName：静态方法，传入IP地址或主机名，返回相应IP的InetAddress对象，224.0.0.0-224.0.0.255的IP能收到组播UDP
       （2）getHostName：返回此InetAddress对象对应主机的名字
       （3）getHostAddress：返回此InetAddress对象对应主机的IP地址

4.DatagramPacket类

       /*UDP数据包类，用于保存UDP数据包的接收者信息和发送的数据，或者保存发送者信息和接收的数据*/
       （1）DatagramPacket(byte[] data,int start,int len,InetAddress ip,int port)：保存data数据、默认null的IP地址、默认-1的端口号
       （2）getData：返回DatagramPacket中保存的数据byte数组
       （3）getLength：返回DatagramPacket中保存的数据长度
       （4）getAddress：返回DatagramPacket中保存的IP地址InetAddress

5.DatagramSocket类

       /*UDP套接字对象，用于收发UDP数据包*/
       （1）DatagramSocket(int port)：将此应用程序与指定端口port绑定，port默认为一个随机的可用端口
       （2）send(DatagramPacket)：从本地端口向DatagramPacket中存储的IP地址对应主机的端口号绑定的进程发送UDP数据包
       （3）receive(DatagramPacket)：从本地端口阻塞式接收UDP数据包，并将发送者信息和接收的数据存储在DatagramPacket中
       （4）close：关闭套接字

6.Socket类

       /*TCP通信套接字类，用于建立客户端与服务器的连接，并提供端到端的通信功能
       由于客户端和服务器都需close一次完成4次挥手才能关闭TCP连接
       因此客户端close后，只要服务器还没有close，服务器就可以读取客户端发送的数据*/
       （1）Socket(String ip,int port)：客户端创建套接字的同时3次握手连接服务器ip的端口port绑定的进程，若连不上，则报错
       （2）getOutputStream：从TCP连接中获取给客户端或服务器发送数据的输出流，返回字节输出流OutputStream
       （3）getInputStream：从TCP连接中获取接收客户端或服务器数据的输入流，返回字节输入流InputStream
       （4）close：客户端和服务端各close一次完成4次挥手关闭TCP连接，TCP连接关闭的同时会关闭用于通信的输入/输出流

7.ServerSocket类

       /*TCP服务器监听套接字类，用于创建服务器，并监听客户端的连接请求，以及获取与客户端通讯的Socket套接字
       创建对象后，后续若有客户端连接，内核将自动完成连接过程*/
       （1）ServerSocket(int port)：将服务器进程与本机的端口号port绑定
       （2）accept：从处于established状态的全连接队列头部阻塞式取出一个TCP连接并返回与该连接中的客户端通信的Socket套接字
       （3）close：停止监听绑定端口上的客户端连接请求并释放占用的系统资源，如端口号、文件描述符等