JavaSE

通常所说的栈（Stack） ， 是指虚拟机
栈。 虚拟机栈用于存储局部变量等。
局部变量表存放了编译期可知长度的
各种基本数据类型（boolean、 byte、
char 、 short 、 int 、 float 、 long 、
double） 、 对象引用（reference类型，
它不等同于对象本身， 是对象在堆内
存的首地址） 。 方法执行完， 自动释
放。

堆（Heap） ， 此内存区域的唯一目的
就是存放对象实例， 几乎所有的对象
实例都在这里分配内存。 这一点在
Java虚拟机规范中的描述是：所有的
对象实例以及数组都要在堆上分配。

方法区（Method Area） ， 用于存储已
被虚拟机加载的类信息、 常量、 静态
变量、 即时编译器编译后的代码等数
据。

针对八种基本数据类型定义相应的引用类型—包装类（封装类）

有了类的特点，就可以调用类中的方法， Java才是真正的面向对象

基本数据类型包装成包装类的实例 ---装箱

获得包装类对象中包装的基本类型变量 ---拆箱

• 用abstract关键字来修饰一个类， 这个类叫做抽象类。
• 用abstract来修饰一个方法， 该方法叫做抽象方法。

抽象方法：只有方法的声明，没有方法的实现。以分号结束：
比如： public abstract void talk();

• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

• 不能用abstract修饰变量、代码块、构造器；
• 不能用abstract修饰私有方法、静态方法、 final的方法、 final的类。

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

成员内部类

局部内部类

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

静态代码块：用static 修饰的代码块
1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而加载，且只执行一次。

非静态代码块：没有static修饰的代码块
1. 可以有输出语句。
2. 可以对类的属性、 类的声明进行初始化操作。
3. 除了调用非静态的结构外， 还可以调用静态的变量或方法。
4. 若有多个非静态的代码块， 那么按照从上到下的顺序依次执行。
5. 每次创建对象的时候， 都会执行一次。 且先于构造器执行。

饿汉式:类一加载，就创建对象
缺陷：
1、如果此类中还有其他占用内存的对象存在，一单此类加载，就会占用大量的内存；
2、高并发下不安全。

基本类型比较值:只要两个变量的值相等， 即为true。

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时， ==才返回true。

简单的说，在Java8中， Lambda表达式就是一个函数式接口的实例。 这就是
Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口
的实例，那么该对象就可以用Lambda表达式来表示。

所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就
是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向
一个方法，可以认为是Lambda表达式的一个语法糖。

要求： 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的
方法的参数列表和返回值类型保持一致！

 如下三种主要使用情况：

与函数式接口相结合，自动与函数式接口中方法兼容。
可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象
方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

Java8 中的 Collection 接口被扩展，提供了两个获取流
的方法：

• default Stream<E> stream() : 返回一个顺序流
• default Stream<E> parallelStream() : 返回一个并行流

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

• static <T> Stream<T> stream(T[] array): 返回一个流

可以调用Stream类静态方法 of(), 通过显示值创建一个
流。它可以接收任意数量的参数。

• public static<T> Stream<T> of(T... values) : 返回一个流

可以使用静态方法 Stream.iterate() 和 Stream.generate(),
创建无限流。

• 迭代

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

• 生成

public static<T> Stream<T> generate(Supplier<T> s)

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止
操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全
部处理，称为“惰性求值” 。

类型

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例
如： List、 Integer，甚至是 void 。

类型

HttpURLConnection对象不能直接构造，需要通过URL类中的openConnection()方法来获得。

HttpURLConnection的connect()函数，实际上只是建立了一个与服务器的TCP连接，并没有实际发送HTTP请求。HTTP请求实际上直到我们获取服务器响应数据（如调用getInputStream()、getResponseCode()等方法）时才正式发送出去。

对HttpURLConnection对象的配置都需要在connect()方法执行之前完成。

HttpURLConnection是基于HTTP协议的，其底层通过socket通信实现。如果不设置超时（timeout），在网络异常的情下，可能会导致程序僵死而不继续往下执行。

HTTP正文的内容是通过OutputStream流写入的， 向流中写入的数据不会立即发送到网络，而是存在于内存缓冲区中，待关闭时，根据写入的内容生成HTTP正文。

调用getInputStream()方法时，返回一个输入流，用于从中读取服务器对于HTTP请求的返回信息。

我们可以使用HttpURLConnection.connect()方法手动的发送一个HTTP请求，但是如果要获取HTTP响应的时候，请求就自动的发起，比如我们使用HttpURLConnection.getInputStream()方法的时候，所以完全没有必要调用connect()方法。

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

public
class Thread implements Runnable {

要点：代理模式

有返回值 

当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了start()此线程立即就会执行

当就绪状态中的线程获得了CUP执行资源，执行run()中的代码，这样的线程我们称为运行状态的线程

处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。线程的阻塞状态分为两种：

第一种，Waiting(无时间限制的等待状态)：

这个状态下是不能分配CPU执行的。有三种情况会使得Running状态到waiting状态

调用无参的Object.wait()方法。等到notifyAll()或者notify()唤醒就会回到Runnable状态。
调用无参的Thread.join()方法。也就是比如你在主线程里面建立了一个线程A，调用A.join()，那么你的主线程是得等A执行完了才会继续执行，这是你的主线程就是等待状态。
调用LockSupport.park()方法。LockSupport是Java6引入的一个工具类Java并发包中的锁都是基于它实现的，再调用LocakSupport.unpark(Thread thread)，就会回到Runnable状态。
第二种，Timed_Waiting(有时间限制的等待状态)：

其实这个状态和Waiting就是有没有超时时间的差别，这个状态下也是不能分配CPU执行的。有五种情况会使得Runnable状态到waiting状态。

Object.wait(long timeout)。
Thread.join(long millis)。
Thread.sleep(long millis)。注意 Thread.sleep(long millis, int nanos) 内部调用的其实也是Thread.sleep(long millis)。
LockSupport.parkNanos(Object blocked,long deadline)。
LockSupport.parkUntil(long deadline)。

在我们的线程正常run结束之后或者run一半异常了就是终止状态

可以作用在「方法」或「代码块」上，通过在对应的修饰「对象」上添加锁来达到同步效果

COW

实现机制

需求

状态

死锁

队列：排队 特性：先进先出 FIFO

阻塞：必须要阻塞、不得不阻塞

有界队列

无界队列

SynchronousQueue

线程池原理

创建线程池的三大方法

7大参数

四种拒绝策略

优化配置

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。

4个schedule调度

​ JMM：Java Memory Model ,Java内存模型要求必须满足以下条件：

Java 内存模型对主内存与工作内存之间的具体交互协议定义了八种操作

可见性

不保证原子性

禁止指令重排

解决：AtomicStampedReference

不足

对比

CompletableFuture

并行 && 并发

ForkJoinTask

ForkJoinPool

需要了解String在JVM内存结构中的存储方式

System类提供的public static long currentTimeMillis()用来返回当前时
间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

表示特定的瞬间，精确到毫秒

是一个不与语言环境有关的方式来格式化和解析日期的具体类

是一个抽象基类，主用用于完成日期字段之间相互操作的功能

字节流(8 bit)

字符流(16 bit)

输入流

输出流

节点流

处理流

RandomAccessFile 类

Selector 允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用 Selector 就会很方便。要使用 Selector，得向 Selector 注册 Channel，然后调用他的 select 方法，这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件。

基本上所有的 IO 在 NIO 中都从一个 Channel 开始。Channel 有点像流，数据可以从 Channel 读到 Buffer，也可以从Buffer 写到 Channel。

缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松的使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变换情况，Channel 提供从文件，网络读取数据的渠道，但是读取或者写入的数据都必须经由 Buffer 。

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组

List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

ArrayList

LinkedList

Vector

LinkedHashSet

hash算法

结构

二叉查找/搜索/排序树(BST树)

二叉平衡树(AVL树)

红黑树

B树（Blance-Tree）平衡树，也叫作B-树。一个m阶的B树规定了：

特点

优点

缺点

图例

特点

优点

图例

原子性（Atomicity，或称不可分割性）：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性（Consistency）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

隔离性（Isolation，又称独立性）：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

持久性（Durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

标记清除算法的执行过程分为两个阶段：标记阶段、清除阶段。

复制算法会将内存空间分为两块，每次只使用其中一块内存。复制算法同样使用可达性分析法标记除垃圾对象，当GC执行时，会将非垃圾对象复制到另一块内存空间中，并且保证内存上的连续性，然后直接清空之前使用的内存空间。然后如此往复。

标记压缩算法可以解决标记清除算法的内存碎片问题。
其算法可以看作三步：

1. 标记垃圾对象
2. 清除垃圾对象
3. 内存碎片整理

分代算法基于复制算法和标记压缩算法。

首先，标记清除算法、复制算法、标记压缩算法都有各自的缺点，如果单独用其中某一算法来做GC，会有很大的问题。

例如，标记清除算法会产生大量的内存碎片，复制算法会损失一半的内存，标记压缩算法的碎片整理会造成较大的消耗。

其次，复制算法和标记压缩算法都有各自适合的使用场景。

复制算法适用于每次回收时，存活对象少的场景，这样就会减少复制量。

标记压缩算法适用于回收时，存活对象多的场景，这样就会减少内存碎片的产生，碎片整理的代价就会小很多。



分代算法将内存区域分为两部分：新生代和老年代。

根据新生代和老年代中对象的不同特点，使用不同的GC算法。

新生代对象的特点是：创建出来没多久就可以被回收（例如虚拟机栈中创建的对象，方法出栈就会销毁）。也就是说，每次回收时，大部分是垃圾对象，所以新生代适用于复制算法。

老年代的特点是：经过多次GC，依然存活。也就是说，每次GC时，大部分是存活对象，所以老年代适用于标记压缩算法。