①：继承于Thread类
创建一个继承于Thread类的子类
重写Thread类的run( )方法————>将此线程执行的操作声明在run( )中
public void run( ){ }
创建Thread类的子类的对象
通过此对象调用start( )（来自父类）
注意：
②：实现Runnable接口（多线程共享数据）
导包：
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
创建一个实现Runnable接口的类
实现类去实现Runnable接口中的抽象方法run( )
创建实现类的对象
只有一个实现类对象，被作为多个Thread类的参数时，可以实现多线程共享数据
将实现类的对象作为参数传递到Thread类的构造器中
通过Thread类的对象调用start( )
注意：
该线程实现过程：
start( )调用了Thread类的对象所对应的run( )，而Thread类中的run( )实质是调用Thread类中的Runnable属性的变量的run( )。
将实现了Runnable接口的类的对象作为参数传递给了Thread类中的构造器，构造器给其内的Runnable属性的变量赋值，再通过该Runnable属性的变量调用了其对应的run( )。
③：实现Callable接口
创建一个实现Callable接口的类
实现call( )—————>将线程需要执行的操作声明在此内
public Object call( ){ }
创建Callable接口实现类的对象
创建FutureTask类的对象前，将Callable接口实现类的对象传递给FutureTask类的构造器
将FutureTask类的对象作为参数传递给Thread类的构造器，通过Thread类的对象启用start( )
（可选）若实现的call( )有返回值，可通过FutureTask类的对象调用get( )获取返回值
④：线程池
getPriority( )：获取线程优先级
setPriority( int p )：设置线程优先级
线程的安全问题当一个线程操作未结束，其他线程参与进来，就有可能会产生安全问题。
解决方法：
①同步代码块：
synchronized(同步监视器){ 需要被同步的代码 }
②同步方法：
1）非静态的同步方法：this
2）静态的同步方法：当前类本身（静态修饰的方法随类的加载而加载）
补充：
③Lock锁：
导包：import java.util.concurrent.locks.ReentrantLock
实例化 ReentrantLock类
调用锁定方法 lock( )
调用解锁方法 unlock( )
注意：
涉及3个方法（只适用于同步代码块和同步方法中）：
-> wait( )：一旦执行此方法，当前线程会进入阻塞状态，并释放同步监视器
-> notify( )：一旦执行此方法，会唤醒一个被wait( )的线程（以线程优先级决定）
-> notifyAll( )：一旦执行此方法，会唤醒所有被wait( )的线程
注意：
关于sleep( )和wait( )
相同点：
不同点：
关于Callable接口比Runnable接口创建多线程强大的原因
1.String是final修饰的，表示不能被继承
2.String实现了Serializable接口：表示字符串支持序列化
3.String实现了Comparable接口：表示String可比较大小
4.String在底层是为final修饰的char[ ]，用于存储字符串数据，final表示其引用地址不可被修改，char[ ]内的元素被赋值后不能被改变 ，且长度固定后也不可更改
5.当通过字面量的方式给字符串赋值时，此时的字符串值声明在字符串常量池中
6.字符串常量池不会存储相同内容的字符串
7.不可变性的体现：
8.String实例化的两种方式：
1）通过字面量赋值的方式
2）通过new+构造器的方式
9.字符串拼接时：
注意：字符串的不可变性
①int length()：返回字符串长度
②char charAt(int index)：获取指定下标的字符
③boolean isEmpty()：判断是否为空字符串
④String toLowerCase()：将字符串中的字符转为小写
⑤String toUpperCase()：将字符串中的字符转为大写
⑥String trim()：忽略头部空白和尾部空白
⑦boolean equals(Object obj)：比较字符串内容是否相同
⑧boolean equalsIgnoreCase(String anotherString)：忽略大小写的情况下比较字符串内容是否相同
⑨String concat(String str)：将指定字符串连接到尾部，等价于+
⑩int compareTo(String anotherString)：比较两字符串大小，返回两者相减的值（用括号内的字符串减去调用该方法的字符串）
⑪String substring(int beginIndex)：返回从beginIndex开始，往后截取到的字符串（包含beginIndex）
⑫String substring(int beginIndex,int endIndex)：返回从beginIndex开始，到endIndex结束，中间所截取到的字符串（包含beginIndex，不包含endIndex）
⑬boolean endsWith(String suffix)：判断调用该方法的字符串是否以指定的字符串为后缀结束的
⑭boolean startsWish(String prefix)：判断调用该方法的字符串是否以指定的字符串为前缀开始
⑮boolean startsWith(String prefix,int toffset)：判断调用该方法的字符串从toffset位置开始，是否以指定的字符串开头
⑯boolean contains(CharSequence s)：判断调用该方法的字符串中是否有包含指定字符串中的字符
⑰int indexOf(String str)：返回指定的字符串 在调用该方法的字符串中 第一次出现的位置，如果未找到，返回-1
⑱int indexOf(String str,int fromIndex)：从指定的位置开始往后找，返回指定的字符串 在调用该方法的字符串中 第一次出现的位置，如果未找到，返回-1
⑲int lastIndexOf(String str)：返回指定的字符串 在调用该方法的字符串中最右边第一次出现的位置，找不到返回-1
⑳int lastIndexOf(String str,int fromIndex)：从最右边的指定位置开始，寻找指定的字符串 在调用该方法的字符串中 处于该位置前的最右边的位置，若找不到，返回-1
⑳-①String replace(char oldChar,char newChar)：将所有和前者匹配的字符替换为后者的字符
⑳-②String replace(CharSequence tager,CharSequence replacement)：将所有与前者匹配的字符串替换为后者的字符串
String相关的转换①String ----> 基本数据类型、包装类：
②基本数据类型、包装类 ----> String：
③String ----> char[ ]
④char[ ] ----> String
⑤String ----> byte[ ]（编码）
⑥byte[ ] ----> String（解码）
（增）①StringBuffer append(xxx)：可传多种数据类型，用于进行字符串拼接
（删）②StringBuffer delete(int start,int end)：删除从start位置开始，到end位置前一个的内容
（改）③StringBuffer replace(int start,int end,String str)：把从start位置开始，到end位置的前一个，其中的内容替换为指定的字符串
（插）④StringBuffer insert(int offset,xxx)：可插入多种数据类型，在指定的位置插入
⑤StringBuffer reverse()：将当前的字符串逆序
⑥public int indexOf(String str)：返回指定的字符串 在调用该方法的字符串中 第一次出现的位置，如果未找到，返回-1
⑦public String substring(int start,int end)：返回一个从start开始，到end的前一个结束，之间的字符串，原本的字符串不会发生改变
⑧String toString()：返回String类型的字符串
日期和时间 1）java.util.Date（父类）：
2）java.sql.Date（子类）
SimpleDateFormat 实例化对象：使用不同的构造器（不同构造器解析格式不同）
1）实例化：
2）常用方法：
LocalDate、LocalTime、LocalDateTime注意：月份从0开始，星期日是1
1.now( )：获取当前的日期、时间、日期+时间
2.of( )：设置指定的年、月、日、时、分、秒，没有偏移量
3.getXxx( )：获取指定的属性的值
4.withXxx( )：设置指定的属性的值（有返回值，不可变性）
5.plusXxx( )：对指定的属性进行添加操作（有返回值，不可变性）
6.minusXxx( ):对指定的属性进行减操作（有返回值，不可变性）
Instant瞬时点1.now( )：获取本初子午线对应的标准时间
2.toEpochMilli( )：获取从1970年1月1日0时0分0秒开始的毫秒数
3.ofEpochMilli( )：通过给的毫秒数，获取Instant实例
DateTimeFormatter①实例化方式：
②常用方法：
1.ofPattern( String pattern )：
2.format( TemporalAccessor t )：
3.parse( CharSequence text )：
1、让自定义类实现Comparable接口
2、重写compareTo(obj)方法
public int compareTo(Object obj){ 指明不同类之间的排序的方式 }
1、构建匿名对象的匿名类
2、重写compare(obj1,obj2)
public int compare(Object obj1,Object obj2)
java.lang包下
①（native long）currentTimeMillis()
②（void）exit( int status )
③（void）gc( )
java.lang.Math
①abs( )
②sqrt( )
③pow( double a , double b )
④log( )
⑤exp( )
⑥random( )
⑦PI
获取π的值
String：不可变的字符序列，底层用char[ ]存储
StringBuffer：可变的字符序列，线程安全，效率低，底层用char[ ]存储
StringBuider：可变的字符序列，线程不安全，效率高，底层用char[ ]存储
通过对应的构造器可以实现三者的相互转换
StringBuffer创建一个对象时，会在原有的字符串的长度上加上16，若空间不足时，会扩容2倍+2
StringBuffer返回的长度是实际存储的数据的长度
尽量使用可以指定空间大小的StringBuffer(int capacity)
-> 相同点：
①都是用于对象的比较
②一般都用于Arrays . sort( )中
③在返回值前使用-表示按从大到小的顺序排列
-> 不同点：
Ⅰ、Comparable接口一般用类去实现，相当于一次定义，永久成型
Ⅱ、Comparator接口一般使用匿名对象的匿名子类方式（在调用Array . sort( )时传值）定义，采用一次性使用的方式
枚举类自定义枚举类：
使用enum关键字定义枚举类：
默认继承于java.lang.Enum类
Enum类中的常用方法：
enum类实现接口：
①生成文档相关的注解
②在编译时进行格式检查
③跟踪代码依赖性，实现替换配置文件功能
自定义注解：
元注解：对现有注解进行解释说明的注解
（一）Collection接口：单列集合，存储一个一个的数据
①List接口：存储有序、可重复的数据
动态数组
②Set接口：存储无序、不可重复的数据
无序：使用哈希值存储
不可重复：用哈希值存储，必要时使用equals进行判断
HashSet：Set接口的主要实现类，线程不安全，可以存放null值，底层使用数组+链表存储
a.LinkedHashSet：作为HashSet的子类，遍历数据时，可以按照添加时的顺序遍历，对于频繁使用遍历操作时，效率高于HashSet
TreeSet：对添加对象的特定属性进行排序
（二）Map接口：双列集合，存储一对一对（key - value）的数据
key：不可重复、无序的，使用Set存储，要求所在的类要重写equals( )和hashCode( )，TreeMap例外
values：可重复、无序的，使用Collection存储，要求所在的类要重写equals( )
一个key-values构成了一个Entry对象，无序的、不可重复的，使用Set存储
HashMap：Map的主要实现类，线程不安全，可以存储null的key和value
a.LinkedHashMap：遍历元素时，可以按照添加是顺序遍历
TreeMap：按照添加的key-value进行排序，按照key来进行排序
Hashtable：古老实现类，线程安全，不能存储null的key和value
a.Properties：常用来处理配置文件，key和value都是String类型
Collection接口中的常用方法底层实现原理：
计算key的哈希值，得到在Entry中的存储位置，判断是否有数据，有的话会比较存储位置上的数据的哈希值是否一样，如果一样，会调用equals方法进行比较，如果比较结果返回true，则会将原数据的values替换为新的key对应的values
①add(Object obj)：将元素obj添加到集合中
②addAll(Collection e)：将集合e的所有元素添加到集合中
③size()：获取已添加的元素的个数
④clear()：清空集合中的所有元素
⑤isEmpty()：判断当前集合是否为空
⑥contains(Object obj)：判断集合中是否包含元素obj
⑦containsAll(Collection e)：判断集合e中的所有元素是否都存在于集合中
⑧remove(Object obj)：移除集合中的元素obj，返回boolean
⑨removeAll(Collection e)：移除和集合e共有的元素,会修改当前集合
⑩retainAll(Collection e)：获取和集合e共有的元素，会修改当前集合
⑪equals(Object obj)：判断集合和元素obj是否相同，返回boolean
⑫toArray()：将集合转化为数组，返回Object[ ]
⑬iterator()：生成集合的迭代器，用于集合的遍历，返回一个Iterator的对象
①void add(int index,Object e)：在index位置插入元素e
②boolean addAll(int index,Collection e)：从index位置开始将集合e中的所有元素添加进来
③Object get(int index)：获取指定位置的元素
④int indexOf(Object obj)：返回obj在集合中首次出现的位置
⑤int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
⑥Object remove(int index)：移除指定位置的元素，并返回该元素
⑦Object set(int index,Object e)：设置指定位置为元素e，不会修改原集合
⑧List subList(int fromIndex,int toIndex)：返回一个从fromIndex到toIndex前一个位置之间的集合
总结常用方法
增：add(Object obj)
删：remove(int index)、remove(Object obj)
改：set(int index,Object e)
查：get(int index)
插：add(int index,Object e)
长度：size()
遍历：①Iterator迭代器 ②增强for循环 ③普通for循环
Map接口中的常用方法①Object put(Object key,Object value)：将指定的key-values存放到当前Map对象中（key相同时符合底层存放原理）
②void putAll(Map m)：将m中的所有key-values存放到当前Map对象中
③Object remove(Object key)：移除指定的key对应的values，并返回
④void clear()：清空当前Map对象的所有值
⑤Object get(Object key)：获取指定的key对应的values
⑥boolean containsKey(Object key)：判断是否包含指定的key
⑦boolean containsValue(Object values)：判断是否有指定的values
⑧int size()：返回当前Map对象中的key-values对的个数
⑨boolean isEmpty()：判断当前Map对象是否为空
⑩boolean equals(Object obj)：判断当前Map对象与obj对象是否相等
⑪Set keySet()：返回所有key构成的Set集合
⑫Collection values()：返回所有values构成的Collection集合
⑬Set enrtySet()：返回所有key-values对构成的Set集合（获取到的值为Map接口中的Empty类（内部类），有相应的getKey()和getValue()方法）
总结常用方法
增：put(Object key,Object value)
删：remove(Object key)
改：put(Object key,Object value)
查：get(Object key)
长度：size()
遍历：keySet()、values()、entrySet()
泛型在集合中使用泛型：
自定义泛型类：
自定义泛型方法：
泛型在继承方面的体现：
通配符：
限制条件的通配符：
java.io
类的创建：
常用方法：
①public String getAbsolutePath()：获取绝对路径
②public String getPath()：获取路径
③public String getName()：获取名称
④public String getParent()：获取上层目录路径，若无，返回null
⑤public long length()：获取文件长度（字节数）
⑥public long lastModified()：获取最后一次修改时间（毫秒数）
⑦public String[] list()：获取指定目录下所有文件或文件目录的名称数组
⑧public File[] listFiles()：获取指定目录下所有文件或文件目录的File数组
⑨public boolean renameTo(File dest)：将文件重命名为指定路径下的文件（当dest不存在，调用该方法的文件存在时，返回true）
⑩public boolean isDirectory()：判断是否为文件目录
⑪public boolean isFile()：判断是否是文件
⑫public boolean exists()：判断是否存在
⑬public boolean canRead()：判断是否可读
⑭public boolean canWrite()：判断是否可写
⑮public boolean isHidden()：判断是否隐藏
⑯public boolean createNewFile()：创建文件，若存在，返回false
⑰public boolean delete()：删除文件或文件夹
⑱public boolean mkdir()：创建文件目录，若上层文件不存在，不创建
⑲public boolean mkdirs()：创建文件目录，若上层文件不存在，一并创建
流的介绍input：读取外部数据到内存中
output：将内存数据输出到存储设备中
流的分类：
按操作数据单位：
1）字节流（8b）：存储二进制数
2）字符流（16b）：存储字符
按数据流向：
1）输入流
2）输出流
按流的角色：
1）节点流：链接内存和数据的通道
2）处理流：处理节点流
抽象基类：
节点流（文件流）：
缓冲流（处理流之一）：
转换流（处理流之一）：
对象流（处理流之一）：
随机存取文件流：
其他常用流：
从文件中读取数据到内存：
从内存中写入数据到文件：
写入的数据可以不存在，会自动生成对应文件
调用write(String)：
FileWriter(File,false)或FileWriter(File)：每次调用方法，会对原有文件进行覆盖（覆盖文件！）
FileWriter(File,true)：每次调用方法，会在原有的文件上进行内容添加（追加内容！）
flush()：将缓冲区的数据写出
数据加密和解密：
节点流：
字节流：FileInputStream
用字节流处理文本文件有可能会出现乱码（字符编码集）
调用read(Array[] arr)时，调用的为字节数组
字符流：FileRead
缓冲流：
提高流的读写速度（内置缓冲区）
在关闭外层流时，内层流也会关闭
操作节点流
缓冲字节流两个新方法：
BufferedReader：
BufferedWriter：
转换流：
操作节点流
传递参数时可以指定编码集格式
属于字符流，参数为stream类型
解码格式取决于解码格式，否则会出现乱码
解码：字节、字节数组 ——> 字符数组、字符串
InputStreamReader：将字节的输入流转换为字符的输入流
编码：字符数组、字符串 ——> 字节、字节数组
OutputStreamWriter：将字符的输出流转换为字节的输出流
对象流：
随机存取文件流：
实例化InetAddress（构造器被私有化）：调用方法
常用方法：
TCP网络编程
客户端：
服务端：
UDP网络编程
发送端：
接收端：
URL编程：
获取Class类的对象：
获取对象：
newInstance()：获取当前运行时类的对象
内部调用了空参构造器，因此要求此空参构造器必须存在且权限不能过小
返回值为Object类型，若Class有使用泛型，则为对应类型
获取指定属性、方法、构造器
获取属性：
获取方法：
获取构造器：
代理模式：
动态代理：
思路：
通过方法获取到动态代理类对象后，动态代理类对象调用和被代理类共同实现的接口的方法时，就会自动转到h对象所包含的invoke方法中，调用其method.invoke()方法，从而实现了通过调用代理类的方法而实现被代理类的方法。由于全过程都没有确定代理类的真正类型，这就实现了动态代理的效果。
总结理解Class类：
Class类对象的不太常用的方法：
-> 获取属性、方法、构造器：
Field[] getFields()
Method[] getMethods()
Constructor[] getConstructors()
获取当前运行时类及父类（构造器除外）中声明为public的属性、方法、构造器
Field[] getDeclareFields()
Method[] getDeclareMethods()
Constructor[] getDeclareConstructors()
获取当前运行时类声明的所有属性、方法、构造器
-> 获取父类：
不带泛型：Class getSuperclass()
带泛型：Type getGenericSuperclass()
-> 获取父类的泛型:
-> 获取实现的接口：
-> 获取所在的包：
-> 获取声明的注解：
java.util.Arrays
①判断两数组是否相等:
Arrays.equals ( int[ ] a,int[ ] b )
②输出数组信息:
Arrays.toString ( int[ ] a )
③将指定值填充到数组中:
Arrays.fill ( int[ ] a,int val )
④对数组进行排序:
Arrays.sort ( int[ ] a )
⑤对数组某个值二分查找:
Arrays.binarySearch ( int[ ] a,int key )
①reverse(List)：反转List集合中的元素顺序
②shuffle(List)：对List集合中的元素进行随机排序
③sort(List)：根据元素的自然排序对指定List集合中的元素进行升序排序
④sort(List,Comparator)：根据Comparator指定的排列顺序对List集合中的元素进行排序
⑤swap(List,int,int)：将指定的List集合中的两元素进行交换
⑥Object max(Collection)：根据元素的自然排序，返回集合中的最大元素
⑦Object max(Collection,Comparator)：根据Comparator指定的排列顺序，返回集合中的最大元素
⑧Object min(Collection)：根据元素的自然排序，返回集合中的最小元素
⑨Object min(Collection,Comparator)：根据Comparator指定的排列顺序，返回集合中的最小元素
⑩int frequency(Collection,Object)：返回集合中指定元素出现的次数
⑪void copy(List dest,List src)：将src中的内容复制到dest中（dest必须要有足够的空间存储）
⑫boolean replaceAll(List list,Object oldVal,Object newVal)：将List中所有的oldVal替换为newVal
⑬synchronizedXxx()：将指定集合包装为线程同步的集合（解决线程安全问题）
JDK8 新特性使用方式：
常用方法：
Optional Optional.empty()：创建内部value=null的Optional的对象
boolean isPresent()：判断Optional对象的内部数据是否有数据
Optional.of(T t)：封装数据t生成Optional对象，要求t非空
T get()：获取Optional对象封装的数据
Optional.ofNullable(T t)：封装数据t生成Optional对象，t可为空
T orElse(T c)：获取Optional对象封装的数据，若数据为空，则返回c
