Java后端

成员内部类可以无条件访问外部类所有的成员属性和成员方法（包括private成员）

如果要访问外部类的同名成员，需要以下方式

在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

要创建成员内部类的对象，前提是必须存在一个外部类的对象

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限

成员内部类不允许 static修饰 属性 和 方法

静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法

向外访问  只能直接访问static修饰属性和方法，同名用 Outter.str2。

非静态的外部属性方法需要实例化外部对象调用

可以有 main方法

不允许使用访问权限修饰符该类堆方法以外的全部隐藏，除了此方法其他的都不能访问

匿名内部类必须继承一个抽象类或者实现一个接口。

匿名内部类没有类名，因此没有构造方法。匿名内部类是唯一一种没有构造器的类

背景： 当一个方法执行完成之后，局部变量的生命周期也就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问这个变量就不可能了。但是又必须需要这个变量，怎么办呢?Java采用了复制的手段来解决这个问题造器传参的方式来对拷贝进行初始化赋值。

方案∶也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。

问题∶当在run方法中改变变量a的值的话，会造成数据不一致性

解决:java编译器就限定必须将入参变量限制为final变量

注意:在JDK8版本之中;,方法内部类中调用方法中的局部变量,可以不需要修饰为final,匿名内部类也是一样的，主要是JDK8之后堪加了Effectively final功能

一个内部类的对象能够访问创建它的对象的实现，包括私有数据

对于同一个包中的其他类来说，内部类能够隐藏起来

匿名内部类可以很方便的定义回调

使用内部类可以非常方便的编写事件驱动程序。

在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类

能够非常好的解决多重继承的问题

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独

保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。

String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 不可变

 创建对象的过程
1 首先在常量池中查找是否存在内容为"abc"字符串对象
2 如果不存在则在常量池中创建"abc"，并让str引用该对象
3 如果存在则直接让str引用该对象

 创建对象的过程
1 首先在堆中（不是常量池）创建一个指定的对象，并让str引用指向该对象。
2 在字符串常量池中查看，是否存在内容为"abc"字符串对象
3 若存在，则将new出来的字符串对象与字符串常量池中的对象联系起来（即让那个特殊的成员变量value的指针指向它）
4 若不存在，则在字符串常量池中创建一个内容为"abc"的字符串对象，并将堆中的对象与之联系起来。（有可能此时常量池中的"abc"已经被回收，所以要先创建一个内容 为"abc"的字符串对象）

str 放在栈上，用 new 创建出来的字符串对象放在堆上，而  abc 这个字面量是放在常量池中。

当数据量较小时，测试程序中，两者新增效率差别不是很明显，ArrayList效率比LinkedList高点；当数据量较大时，LinkedList的效率开始比ArrayList效率高了，而且数据量越大，越明显。

不安全，效率高，数组结构：增删慢；查询快

结构和扩容 ArrayList ：初始化时创建一个空数组（Object）。add() 时：创建一个长度等于10的数组，将数据存入数组中，当数组长度大于10的时候会调用扩容方法（原始长度的1.5倍）

get查询时：数组结构，下标查询会很快，直接获取

指定位置add时：从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。

效率：查询快、新增删除需要移动下标后面的元素。

空间：扩容的1.5倍，可能存在的情况是，长度越大，浪费空间越大。

不安全，效率高，链表结构：增删快；查询慢

LinkedList:初始化时创建一个空对象。add时：LinkedList有成员变量 first 和 last ,获取last节点，将last节点放入新节点的前驱中，将last节点的后驱中存入新的节点，修改成员变量last=新节点。

get时：将长度一分为2，index 在前面从前往后遍历，index 在后面从后往前遍历。

指定位置 add() 先将该位置的节点查询出来，拿出前驱节点放入新节点的前驱中，自身放入新节点的后驱中就可以了。

效率：查询慢，新增末尾和开头快，指定位置新增需要遍历查询所以不一定快。

空间：每一个节点存了三次，但是是同一个对象（只是指向对象的地址存了3次）

数组结构 安全（方法加锁） 效率低

存取无序，元素唯一。遍历方式：增强for，Iterator，集合转数组

哈希算法 哈希结构 存取无序 元素唯一

HashSet 如何检查重复?

LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的 LinkedHashMap 其内部是基于 HashMap 实现一样，不过还是有一点点区别的

二叉树算法可以排序

为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。

用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。

(n - 1) & hash

oadFactor 加载因子是控制数组存放数据的疏密程度，loadFactor 越趋近于 1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor 越小，也就是趋近于 0，数组中存放的数据(entry)也就越少，也就越稀疏。

loadFactor 太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor 的默认值为 0.75f 是官方给出的一个比较好的临界值。

给定的默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。

threshold = capacity（最大容量） * loadFactor，当 Size>=threshold的时候，那么就要考虑对数组的扩增了，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。

将原先table数组＋单向链表的数据结构，变更为table数组＋单向链表＋红黑树的结构.

默认初期长度为16，当往map中继续添加元素的时候，通过hash值跟数组长度取与来决定放在数组的哪个位置，如果出现放在同一个位置的时候，优先以链表的形式存放，在同一个位置的个数又达到了8个以上，如果数组的长度还小于64的时候，则会扩容数组。如果数组的长度大于等于64了的话，在会将该节点的链表转换成树。

如果某个节点的是树，同时现在该节点的个数又小于等于6个了，则会将该树转为链表

Hash Map 数组+链表+红黑树

Hash Table 数组+链表

HashMap 默认16 且每次扩容2倍

Hash table 默认11，容量变为原来的 2n+1

HashMap 是非线程安全的，Hashtable 是线程安全的,因为 Hashtable 内部的方法基本都经过synchronized 修饰

因为线程安全的问题，HashMap 要比 Hashtable 效率高一点。另外，Hashtable 基本被淘汰，不要在代码中使用它；

Hash Map实现Map接口

Hash Table 实现set接口

put方法

set方法

Hash Map 存 K V 值，对K进行Hash计算 

HashSet 使用成员对象来计算 hashcode 值，对于两个对象来说 hashcode 可能相同，所以equals()方法用来判断对象的相等性

工作内存（高速缓存 变量副本）

作用于当前  实例对象本身  加锁，进入同步代码前要获得当前对象实例的锁

作用于当前  类对象本身 加锁，进入同步代码前要获得当前类对象的锁。本类的其他静态方法都要等该方法释放锁

指定加锁对象（实例对象、类），对给定对象加锁，进入同步代码库前要获得给定对象的锁

获取锁

 如果当前线程未被中断，则获取锁，可以响应中断 

返回绑定到此 Lock 实例的新 Condition 实例

仅在调用时锁为空闲状态才获取该锁，可以响应中断

如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁

释放锁

Lock readLock() //返回用于读取操作的锁
Lock writeLock() //返回用于写入操作的锁  

正对每一个具体的线程创建的

核心线程数  == 最大线程数

不会出现核心线程以外的线程，所以无需等待时间

容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue（无界队列）

默认的抛异常策略（AbortPolicy()）

线程数量固定导致没有弹性，无界队列有溢出风险

核心线程和最大都是一个 

0

容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue（无界队列）

默认的抛异常策略（AbortPolicy()）

一个线程效率低，无界队列有溢出风险OOM

核心线程数==0

最大线程数==Integer.MAX_VALUE

60s

SynchronousQueue(同步策略)

默认的抛异常策略（AbortPolicy()）

允许创建线程数量Integer.MAX_VALUE ,创建大量的线程可能会OOM

核心线程数  N

最大线程数==Integer.MAX_VALUE

0

SDelayedWorkQueue (延迟策略)

默认的抛异常策略（AbortPolicy()）

允许创建线程数量 和 队列的长度都可以 ==Integer.MAX_VALUE ,可能会OOM风险

抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行

当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。
但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大。
因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略

submit方法被重载了三次，分别对用三个不同的参数