API

1.API
API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。

java.lang包，这个包会自动导入。
java.lang.Object
java.lang.String
java.lang.StringBuilder/StringBuffer
正则表达式
包装类等

2.Object
所有对象的顶级父类，存在于java.lang包中，这个包不需要我们手动导包。
常用方法：

boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
protected  void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
int hashCode()：返回该对象的哈希码值。
String toString()：返回该对象的字符串表示。

3.String
字符串对象，是一个封装char[]数组的对象。
创建String对象：

• 方式1：new String(char[]) //堆中分配新的内存
• 方式2：直接创建：String s2="abcd";//常量池中分配新的内存

常用方法：

length()：获取字符串长度
charAt()：获取指定索引处的char值
lastIndexOf()：获取指定字符串最后一次出现的索引值
substring()；截取含头不含尾[3,7)
equals()：判断两个字符串的内容是否相同
startsWith()：是否以指定字符开始
endsWith()：是否以指定后缀结束
split()：根据指定的规则切割字符串
trim():去除字符串两端的空格
toUpperCase()：把字符串全传大写
toLowerCase()：把字符串全传小写
concat()：拼接指定字符串
valueOf()：把其他类型的数据转换成字符串

String、StringBuffer、StringBuilder区别：

• String：不可变字符串；
• StringBuffer：可变字符串、效率低、线程安全；
• StringBuilder：可变字符序列、效率高、线程不安全；
• StringBuilder/StringBuffer：用于字符串拼接，常用append()来代替字符串做字符串连接。

4.包装类
Number：数字包装类的抽象父类。
Integer：

parseInt();字符串转换成int
toBinaryString();把整数转换成2进制数据
toOctalString();把整数转换成8进制数据
toHexString();把整数转换成16进制数据

Double：

Double.parseDouble()：字符串转换成double类型

5.日期类Date
存在于java.util.Date包。用来封装一个毫秒值表示一个精确的时间点。从1970-1-1 0点开始的毫秒值。

getTime()：到现在毫秒值
setTime()：存取内部毫秒值
getMonth()：获取当前月份（0-11表示）
getHours()：获取当前小时
getMinutes()：现在是哪一分钟
getSeconds()：获取当前秒值
compareTo(Date)：当前对象与参数对象比较。当前对象大返回正数，小返回负数，相同0。
toLocalString()：获取当前时间

日期工具SimpleDateFormat：
日期格式化工具。可以把Date对象格式化成String类型，也可以日期字符串解析成Date对象。

format(Date)：把Date格式化成字符串
parse(String)：把String解析成Date

6.BigDecimal/BigInteger
BigDecimal：常用来解决小数运算不精确。
BigInteger：常用来解决超大的整数运算。

add(BigDecimal bd)： 做加法运算
substract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂

7.IO
java.io包
in/out相对于程序而言的输入(读取)和输出(写出)的过程。
字节流：针对二进制文件

InputStream
	--FileInputStream
	--BufferedInputStream
	--ObjectInputStream
OutputStream
	--FileOutputStream
	--BufferedOutputStream
	--ObjectOutputStream

字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8

Writer
	--BufferedWriter
	--OutputStreamWriter
Reader
	--BufferedReader
	--InputStreamReader
	--PrintWriter/PrintStream

File文件流：

length()：文件的字节量
exists()：是否存在，存在返回true
isFile()：是否为文件，是文件返回true
isDirectory()：是否为文件夹，是文件夹返回true
getName()：获取文件/文件夹名
getParent()：获取父文件夹的路径
getAbsolutePath()：获取文件的完整路径

字节流读取：
InputStream抽象类：字节读取流的抽象父类（不能new）。

abstract  int read()：从输入流中读取数据的下一个字节。
int read(byte[] b)：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)：将输入流中最多 len 个数据字节读入 byte 数组。
void close()：关闭此输入流并释放与该流关联的所有系统资源。

字节流写出：抽象类是表示输出字节流的所有类的超类。

void close()：关闭此输出流并释放与此流有关的所有系统资源。
void flush()：刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)：将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract  void write(int b)：将指定的字节写入此输出流。

8.泛型
通过泛型的语法定义，约束集合元素的类型，进行安全检查，把错误显示在编译期。
泛型可以在接口、方法、返回值上使用。

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
? - 表示不确定的java类型

9.集合
所有抽象层的形成，都是为了提取子类的共性。

Collection接口
-- List接口：数据有序，可以重复，元素有下标。
   -- ArrayList子类
   -- LinkedList子类
-- Set接口：数据无序，不可以存重复值
   -- HashSet子类
   -- TreeSet
-- Map接口：键值对存数据
	-- HashMap
Collections工具类

Collection接口：

boolean add(E e)：添加元素。
boolean addAll(Collection  c)：把小集合添加到大集合中 。
boolean contains(Object o) ： 如果此 collection 包含指定的元素，则返回 true。
boolean isEmpty() ：如果此 collection 没有元素，则返回 true。
Iterator<E> iterator()：返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o) ：从此 collection 中移除指定元素的单个实例。
int size() ：返回此 collection 中的元素数。
Objec[] toArray()：返回对象数组

List接口：

• 数据有序
• 允许存放重复元素
• 元素都有索引
• 允许存null值

ListIterator<E> listIterator()：返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E> listIterator(int index)：返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
void add(int index, E element)：在列表的指定位置插入指定元素（可选操作）。
boolean addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
List<E> subList(int fromIndex, int toIndex)：截取：返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
E get(int index)：返回列表中指定位置的元素。  
int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

迭代方法：

• for循环
• 增强for循环

for(数据类型  变量名：数组或集合类)

ArrayList（实现类）：

• 存在于java.util包中。
• 底层基于数组实现，在内存中连续存放，基于下标访问快，方便查询
• 当创建一个新的ArrayList对象后，是一个空数组，初始容量是10
• 添加元素后，长度变为10
• 长度满了后，新建一个1.5倍的数组，并将原数据复制至新数组。
• 为避免频繁扩容，应在创建时指定其初试长度。
• 自己指定初始长度为5，加到6个元素的时候，扩容至10，然后按15，22进行扩容。*1.5出小数直接舍掉

LinkedList（实现类）：

• 双向链表，两端效率高。底层就是数组和链表实现的。方便增删。
• 适用于非末端位置频繁进行插入删除数据的操作，也可以规避动态扩容的问题。

Set接口：

• 元素无序
• 没有下标
• 不能重复
• 只能存一个null值
• 常用于给数据去重。

HashSet（实现Set接口）：

• 底层是哈希表/散列表
• 元素无序
• 不能重复
• 没有下标
• 构造一个空Set，其底层HashMap实例的的默认初始容量为16，加载因子是0.75（即使自己设置了大小，也会变成最近的向上取整的2的n次幂）。

TreeSet（实现类）：

• TreeSet中不允许使用null元素！在添加的时候如果添加null，则会抛出NullPointerException异常。
• TreeSet是基于TreeMap实现的。TreeSet中的元素支持2种排序方式：自然排序 或者 根据创建TreeSet 时提供的 Comparator 进行排序。这取决于使用的构造方法。是红黑树的形式，便于查找数据。
• TreeSet是非同步的方法。 它的iterator 方法返回的迭代器是fail-fast的。
• TreeSet不支持快速随机遍历，只能通过迭代器进行遍历！

HashSet与TreeSet区别：

• HashSet是一个无序的集合，基于HashMap实现；TreeSet是一个有序的集合，基于TreeMap实现。
• HashSet集合中允许有null元素，TreeSet集合中不允许有null元素。
• HashSet和TreeSet都是非同步！在使用Iterator进行迭代的时候要注意fail-fast。

Map接口：
java.util接口 Map<K,V>，将键值映射到值的对象。
常用于存键值对结构的数据。其中的键不能重复，值可以重复.

• 可以根据键，提取对应的值
• 键不允许重复，如果重复值会被覆盖
• 存放的都是无序数据
• 初始容量是16，默认的加载因子是0.75

HashMap：

• HashMap底层是一个Entry数组，当存放数据时会根据hashCode()计算数据的存放位置。算法：hash(key)%n，n就是数组的长度。
• 当计算的位置没有数据时，就直接存放，当计算的位置有数据时也就是发生hash冲突的时候/hash碰撞时，采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

TreeMap：
TreeMap是一个有序的key-value集合，基于红黑树（Red-Black tree）的 NavigableMap实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator进行排序，具体取决于使用的构造方法。

红黑树：

1. 根节点是黑色
2. 每个节点都只能是红色或者黑色
3. 每个叶节点（NIL节点，空节点）是黑色的。
4. 如果一个节点是红色的，则它两个子节点都是黑色的，也就是说在一条路径上不能出现两个红色的节点。
5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

10.Collections工具类

Collections.sort(List<> list)：根据元素的自然顺序 对指定列表按升序进行排序。
Collections.max()：根据元素的自然顺序，返回给定 collection 的最大元素。
Collections.min()：根据元素的自然顺序 返回给定 collection 的最小元素。
Collections.swap(List,i,j)：在指定列表的指定位置处交换元素。

11.集合和数组的区别
区别1：

• 数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值。
• 集合只能存储引用数据类型（对象）。集合也能存储基本数据类型(有点矛盾，看后句)，但是在存储的时候会自动装箱变成对象。

区别2：

• 数组长度是固定的，不能自动增长。
• 集合的长度是可变的，可以根据元素的增长而增长。

适用场合：

• 如果元素个数是固定的推荐用数组，效率高。
• 如果元素个数不是固定的推荐用集合

12.进程
进程：是正在运行的程序。也就是代表了程序所占用的内存区域。
特点：

• 独立性：进程是系统中独立存在的实体，它可以拥有自己的独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
• 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念，进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。
• 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

进程和程序的区别：
程序的定义：程序是指令的有序集合。是一个在时间上按照严格次序前后相继的操作序列。
进程的定义：可并发执行的程序在数据集上的一次执行过程。
进程与程序的主要区别：
（1）程序是永存的；进程是暂时存在的。即进程是有生命周期的，创建，执行，撤销等；
（2）程序是静态的观念，进程是动态的观念；
（3）一个程序可对应多个进程； 一个进程可以执行一个程序或多个程序
（4）进程具有并发性，而程序没有；
（5）进程是竞争计算机资源的基本单位，程序不是。

线程（thread）：
是操作系统运算调度的最小单位。

• 一个程序运行后至少一个进程，一个进程里包含多个线程。
• 如果一个进程只有一个线程，这种程序被称为单线程程序。
• 如果一个进程运行依赖多个线程被称为多线程程序。

关系：
一个操作系统中可以有多个进程，一个进程中可以有多个线程，每个进程有自己独立的内存，每个线程共享一个进程中的内存，每个线程又有自己独立的内存。
线程与进程的区别：

• 1.概念
  线程：是程序执行流的最小单元，是系统独立调度和分配CPU（独立运行）的基本单位。
  进程：是资源分配的基本单位。一个进程包括多个线程。
• 2.区别：
  1.线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源。
  2.每个进程都有自己独立的内存，供其内的所有线程共享。

多线程与多进程的区别：
多线程：同一时刻执行多个线程。用浏览器一边下载，一边听歌，一边看视频，一边看网页。。。
多进程：同时执行多个程序。如，同事运行YY，QQ，以及各种浏览器。
并发与并行的区别：
并发：指同一时刻共享资源被多个线程抢占；
并行：同一时刻，可以执行多个任务，但是不发生抢占资源的现象，各干各的，互不干扰。

线程生命周期：新建、就绪、运行、阻塞、终止。

• 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()；
• 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
• 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
• 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态；
• 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

阻塞状态又可以分为三种：

• 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
• 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
• 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

13.多线程创建

• 1.继承Thread：启动线程的唯一方法就是通过Thread类的start()实例方法。

String getName()：返回该线程的名称。
static Thread currentThread()：返回对当前正在执行的线程对象的引用。
void setName(String name)：改变线程名称，使之与参数 name 相同。
static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
void start()：使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
Thread(String name)：分配新的 Thread 对象。

• 2.实现Runnable接口

void run()：使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

start()与run() 的区别：

• start是用来开启线程的,使线程进入就绪状态来等待时间片；

• run方法是线程具体的执行逻辑,直接调用run方法只是执行了一段代码,而并没有启动线程；

• start方法内部会调用run方法；

• 线程执行的业务，必须写在run()方法里。

• start与run方法的主要区别在于当程序调用start方法一个新线程将会被创建，并且在run方法中的代码将会在新线程上运行，然而在你直接调用run方法的时候，程序并不会创建新线程，run方法内部的代码将在当前线程上运行。

• 3.继承Callable接口重写run方法。

14.同步锁

• 把有可能出现问题的代码包起来，一次只让一个线程执行。通过sychronized关键字实现同步。
• 当多个对象操作共享数据时，可以使用同步锁解决线程安全问题。

synchronized(对象){
    需要同步的代码；
}

特点：

• 前提1，同步需要两个或者两个以上的线程。
• 前提2，多个线程间必须使用同一个锁。
• 同步的缺点是会降低程序的执行效率， 为了保证线程安全,必须牺牲性能。
• 可以修饰方法称为同步方法，使用的锁对象是this。
• 可以修饰代码块称为同步代码块，锁对象可以任意。

15.单例设计模式
饿汉式
懒汉式：延迟加载思想+线程不安全
锁对象：类名.class（共享资源是静态的）

16.注解
JDK自带注解

• @Override
• @Deprecated标记就表明这个方法已经过时了，但我就要用，别提示我过期
• @SuppressWarnings(“deprecation”) 忽略警告
• @SafeVarargs jdk1.7出现，堆污染，不常用
• @FunctionallInterface jdk1.8出现，配合函数式编程拉姆达表达式，不常用

元注解
描述注解的注解，就5个：

• @Target 注解用在哪里：类上、方法上、属性上
• @Retention 注解的生命周期：源文件中、class文件中、运行中
• @Inherited 允许子注解继承
• @Documented 生成javadoc时会包含注解，不常用
• @Repeatable注解为可重复类型注解，可以在同一个地方多次使用，不常用

自定义注解

17.反射（Reflection）

• 反射非常强大，它甚至能直接操作程序的私有属性。
• 可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

获取Class类对象的三种方式：

Class.forName(“类的全路径”);
类名.class
对象.getClass();

反射会打破封装，可以直接对private的属性进行赋值
调用类中的某个方法
1.获取类对象
2.获取方法对象
3.方法对象.invoke(类实例(class.instance()),“参数值”)

18.内部类
如果一个类存在的意义就是为指定的另一个类，可以把这个类放入另一个类的内部。

.....class	A  {class	B{  }...}

匿名内部类:
匿名内部类属于局部内部类，并且是没有名字的内部类。

19.Socket
也叫套接字编程，是一个抽象层。
服务器端-ServerSocket
客户端-Socket

20.lambda表达式

（参数列表）——>{方法体}