集合
为什么使用集合
集合就是用来保存对象的，他的长度可变，数组的长度每次定义好之后就不可变了，但是我们不知道要存储多少个元素，所以我们就要使用集合。
集合中的数据都是存放在内存中的。当程序关闭或重启后集合中的数据丢失，所以集合是一种临时存储数据的容器
集合分类
迭代器
迭代器是一种设计模式，接口，专门用来遍历循环集合，它只使用容器Collection，并不关心容器类型。
应用场景：我们使用容器时必须指定类型，但是我想把list的操作给set。就会使用到Iterator.
每个实现类都提供了.iterator()；返回值就是迭代器对象。
public class TestIterator {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//获取集合的迭代器
Iterator<Integer> iterator = list.iterator();
//.hasNext() 判断是否有下一个元素
while (iterator.hasNext()) {
//获取下一个元素
Integer next = iterator.next();
System.out.println(next);
}
//lterable用来返回迭代器，实现了该接口的类就算是可迭代对象了，可以用for-each循环访问数据。省去了next操作
Collection list1 = new ArrayList<>();
for(Object o : list1){
System.out.println(o);
}
}
}
1
2
3
注意
java中的迭代器是一个接口，名为Iterator，将通用性做到了极致，可以访问不同特性的集合数据而无需关心他们的内部实现。集合并不是直接去实现Iterator接口，而是实现的Iterable接口，用这个Iterable定义的方法区返回当前集合的迭代器，Collection就继承了这个接口，所以Collection体系内的集合都的按照这种方式返回迭代器collection.iterator()，以供大家访问数据。
why？
如果集合直接实现迭代器的话，那别人调用了当前集合的next方法，就会影响到你遍历数据，比如你希望从头开始遍历数据，但是别人已经遍历完了，你就拿不到数据了，而通过实现Iterable这种方式，就可以每次返回新的迭代器，不同迭代器遍历数据时互不影响。所以这就可以看出迭代器是具有独立性和隔离性的。但如果我们正确的返回了迭代器，那么我们就可以用for-each来循环数据。
总结
Iterable用来返回迭代器，实现了该接口的类就算是可迭代对象了，可以用for-each循环访问数据。省去了next操作
Iterator就是迭代器，用来遍历集合的数据，并无需关心集合的内部实现。for-each底层用的就是迭代器
Iterator
只能单向遍历
.hasNext(); 检查集合中是否还存在元素
.next(); //获取集合的下一个元素
.remove(); 将迭代器返回的元素删除
ListIterator
双向遍历
.hasNext(); 检查集合中是否还存在元素
.next(); //获取集合的下一个元素
.remove(); 将迭代器返回的元素删除
.add(); 添加元素
public class TestListIterator {
public static void main(String[] args) {
//创建一个集合对象
List<Integer> list = new ArrayList<Integer>();
//向集合中添加分数
list.add(78);
list.add(80);
list.add(89);
ListIterator<Integer> lit = list.listIterator();
//从前向后遍历
while(lit.hasNext()){
lit.next();
}
//从后向前遍历 ---- 前提是必须正着来一遍
while(lit.hasPrevious()){
int elem = lit.previous();
System.out.println(elem +" "+lit.nextIndex()+" "+lit.previousIndex());
}
}
}
89 2 1
80 1 0
78 0 -1
区别
1.适用范围不同: iterator : 适用于Collection集合 ---- list和set 。Listiterator :适用于list
2.遍历顺序不一样: Listiterator 双向遍历。iterator 单向遍历（向后）
3.操作不一样：Listiterator 在循环元素时可以可以add、remove，set ，Iterator：remove
Listiterator 可以定位当前索引位置，nextIndex(),previousIndex(),Interator不可以。
foreach和Iterator
Iterator只能用来遍历集合。foreach可以遍历集合和数组，但是遍历集合时不能操作数据，对数据进行添加删除等操作，Iterator可以。
JDK1.8之后添加了removelf方法，可以条件删除数据
源码
以ArrayList为例
public class TestIterator {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//获取集合的迭代器
Iterator<Integer> iterator = list.iterator();
//.hasNext() 判断是否有下一个元素
while (iterator.hasNext()) {
//获取下一个元素
Integer next = iterator.next();
System.out.println(next);
}
}
}
/**
* The size of the ArrayList (the number of elements it contains).
*ArrayList的大小（它包含的元素数）。
*/
private int size; // 数组容量 = 3
/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
这个列表被结构修改的的次数。结构修改是指改变列表的大小，或以其他方式干扰它，
使进行中的迭代可能产生不正确的结果
*
*This field is used by the iterator and list iterator implementation
* returned by the {@code iterator} and {@code listIterator} methods.
* If the value of this field changes unexpectedly, the iterator (or list
* iterator) will throw a {@code ConcurrentModificationException} in
* response to the {@code next}, {@code remove}, {@code previous},
* {@code set} or {@code add} operations. This provides
* <i>fail-fast</i> behavior, rather than non-deterministic behavior in
* the face of concurrent modification during iteration.
此字段由迭代器和列表迭代器实现使用 由迭代器和方法返回。如果此字段的值发生意外变化，则迭代器(或列表
将抛出一个代码并发修改异常 .对于｛next｝、｛remove｝、｛previor｝,｛set｝或｛add｝操作。。提供 了fail-fast（快速失败）行为，不是非确定性行为
*
* <p><b>Use of this field by subclasses is optional.</b> If a subclass
* wishes to provide fail-fast iterators (and list iterators), then it
* merely has to increment this field in its {@code add(int, E)} and
* {@code remove(int)} methods (and any other methods that it overrides
* that result in structural modifications to the list). A single call to
* {@code add(int, E)} or {@code remove(int)} must add no more than
* one to this field, or the iterators (and list iterators) will throw
* bogus {@code ConcurrentModificationExceptions}. If an implementation
* does not wish to provide fail-fast iterators, this field may be
* ignored.
子类使用此字段是可选的，如果子类希望提供快速失败迭代器（和列表迭代器）只需在其｛add（int，E）｝和
｛remove（int）｝方法（及其重写的任何其他方法导致列表的结构修改）。
一次呼叫｛add（int，E）｝或｛remove（int）｝添加的数量不得超过或者迭代器（和列表迭代器）将抛伪 ConcurrentModificationExceptions。如果实施者不希望提供快速失败迭代器，此字段可忽略
*/
//在 AbstractList 定义的全局变量，他在add，remove。set等修改数据的时候会+1
protected transient int modCount = 0;
private class Itr implements Iterator<E> {
// 调用next方法返回的元素索引
int cursor; // 0 1 2 3
// 最近一次调用next方法返回的元v素索引-如果没有，则为-1
int lastRet = -1; //-1 0 1 2
// expectedModCount 修改次数
int expectedModCount = modCount; // 3 -- 循环调用next方法 3次
//判断集合中是否还有元素
public boolean hasNext() {
//第一次调用的元素索引是否等于集合长度
return cursor != size; // 0 != 3 ; true
}
// 返回下一个元素
@SuppressWarnings("unchecked")
public E next() {
// 判断是否进行了修改操作
checkForComodification();
// i = 0 第一次调用的元素下标
int i = cursor;
// next返回的索引 大于 数组
if (i >= size) // 0 >=3 flase
//无搜索元素异常
throw new NoSuchElementException();
// 转换为数组
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
//并发修改异常
throw new ConcurrentModificationException();
//next返回的下标 +1
cursor = i + 1; // 0+1 = 1
// 返回元素
return (E) elementData[lastRet = i]; // elementData【0】
}
// 删除迭代器返回的元素
public void remove() {
//判断 最近一次访问的元素下标 是否正确
if (lastRet < 0) // 0< 0 flase
//非法状态异常 --- 集合不存在
throw new IllegalStateException();
checkForComodification();
try {
//删除元素
ArrayList.this.remove(lastRet); // 0 modCount +1 = 4
// 1 = 0
cursor = lastRet;
//最近一次调用的下标赋值为-1
// 0 = -1
lastRet = -1;
// 3 = 4
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
// fail-fast（快速失败机制）单线程和多线程中会出现
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
fail-fast 快速失败机制
java集合中的一种错误检查机制，是不确定性。主要用于线程操作（单线程也会发生）
触发条件
1.在循环遍历集合时，向集合中插入值或删除集合中值时会出现这个异常。
public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
for (Integer integer : list) {
list.remove(integer);
}
}
}
2.当多个线程对同一个Collection集合进行修改数据的操作。其中一个线程用迭代器进行循环，但是当前集合的数据被其他线程所改变。单线程也会。
why
迭代器在调用add，next、等方法时中会调用checkForComodification() 方法，他主要用来检测modCount 是否 expectedModCount相同，不相同就会触发异常。
解决
1.使用线程安全的集合 ConcurrentHashMap，CopyOnWriteArrayList ，CopyOnWriteArraySet
2.添加锁，在所有涉及改变数据结构即modcout值的操作加上Synchronized。
List
有序可重复，允许多个null值，按照插入顺序添加数据，获取元素时可以根据迭代器和获取元素下标
ArrayList
底层是一个数组，增删慢，查询快，最常使用
数组长度固定，超出以后需要扩容，也就是创建一个新的数组，将旧的内容放到新的里面，使用尾插法并指定初始容量可以极大提高性能，甚至超过Liked list（需要创建大量的node对象）
LinkedList
底层是一个双向数组，保存下一个元素的下标引用，查询慢，增删快
循环数据时只能使用迭代器，不能用for，因为数据是零散的存储在内存中，当我们用for循环来get某个元素时，都要对List重新进行遍历，性能消耗极大，并且indexof(获取内容第一次出现的下标)，结果为空时会遍历整个集合
Set
无序不重复，最多允许一个null值，通过迭代器或者转变为数组来获取元素
HaseSet
底层是哈希表，无序，查询速度最快，TreeSet其次（按内容查询，如果按索引查询，Arraylist最快）
TreeSet
底层是TreeMap（红黑树），有序（可以自定义）
LinkedHaseSet
底层是哈希表+链表，有序（插入顺序）
注意-----唯一性
1.存储自定义类在一个底层实现为哈希表的时候，我们要重写hasecode 和 equals 方法。
java定义的类比如String，本身就已经重写了这两个方法，如果我们自定的类没有重写着两种方法，那么会存入相同的数据，破坏了唯一性。
2.存储元素在一个底层为红黑树的集合时想要自定义排序，我们要实现comparable（内部比较器）或Comparator（外部比较器）接口，内部比较器只有一个，外部比较器有多个。
Comparable 外部比较器 <0 倒序 ， = 0 相同 > 0 正序
被abstract修饰，不能作为内部类使用
public class Student implements Comparable<Student>{
private Integer age;
private String name;
//重写compareTo方法
@Override
public int compareTo(Student o) {
return this.age - o.age; // 按年龄正序排列
//return o.age - this.age; 按年龄倒序排列
}
}
Comparator 内部比较器 有多个参数
public class iterator1 {
public static void main(String[] args) {
test1 test1 = new test1(1,"A");
test1 test2 = new test1(2,"Q");
test1 test3 = new test1(2,"C");
// 匿名内部类 --- 当这个比较方法只使用一次，我们淡出创建一个类有点浪费
Set<test1> tests = new TreeSet<test1>(new Comparator<test1>() {
@Override
public int compare(test1 o1, test1 o2) {
double age = o1.age -o2.age;
if (age> 0) return 1;
else if (age< 0) return 0;
// 如果年龄相同，按照姓名倒序
else return o1.name.compareTo(o2.name);
}
});
}
Map
key - value 形式存储，key不重复
HaseMap：无序，key可以为null
TreeMap： 有序 key 不为null
LinkedHaseMap： key不为null，有序（按照插入顺序，get的元素放在最后面）
key相同时，后者会覆盖前者，返回前者
Hase
1.为什么使用
无序数组的查询时间复杂度为O(n) , 全部遍历一遍
有序数组 用二分查找，时间复杂度0（long2^n）
二叉平衡树 用二分查找，时间复杂度0（long2^n）
hase表 通过hase算法得到存储地址 时间复杂度 O（1）
2.hase冲突
hase算法计算的数据是无限，但是计算后的范围是有限的，所以会出现不同的数据，他们的hasecode是相同的
解决
1.链地址法：HaseMap常用（JDK1.7之前链表+数组，JDK1.8之后链表+数组+红黑树）
Hash Map采用的是单向链表法，它具有Next指针，可以连接下一个实体，以此来解决Hash冲突的问题。
2，再哈希法：提供多个hase函数，如果第一冲突了，就用第二个hase值去计算
3，公共溢出法：创建一个公共区域。将这些溢出的元素都放在这里
4，开发地址法：当key的哈希地址出现冲突时，从冲突的位置向下找一个为空的数组下标进行存储，如果到最后一个依旧没有找到，那么就从头开始查找（注：该方法有三种分类，这只是其中一个）
3.HaseMap
https://www.bilibili.com/video/av60318686
https://blog.csdn.net/wangzhipeng47/article/details/106751172#comments
JDK1.7之前链表+数组（头插），JDK1.8之后链表+数组+红黑树（尾插）
1.7：在构造方法中创建一个长度16的 Entry【】table数组对象用来存储数据
1.8：在第一次调用put方法创建数组 Node【】table用来存储数据
底层实现
从Java8开始HashMap底层由数组+链表变成数组+链表+红黑树。
使用HashMap时，当使用无参构造方法实例化时，设置扩容因子为默认扩容因子0.75。
当向HashMap添加内容时，会对Key做Hash计算，把得到的Hash值和数组长度-1按位与，计算出存储的位置。
如果数组中该没有内容, 直接存入数组中(Node节点对象), 该下标中有Node对象了, 把内容添加到对应的链表或红黑树中。
如果添加后链表长度大于等于8，会判断数组的长度是否大于等于64，如果小于64对数组扩容，扩容长度为原长度的2倍，扩容后把原Hash表内容重新放入到新的Hash表中。如果Hash长度大于等于64会把链表转换红黑树。
最终判断HashMap中元素个数是否已经达到扩容值(threshold)，如果达到扩容值，需要进行扩容，扩容一倍。
反之，如果删除元素后，红黑树的元素个数小于等于6，由红黑树转换为链表。
问题
1. key值怎么选择，用自定义类需要注意什么
一般选择Interager和String类型，因为他们是被final修饰的，不可改变，保证hase值具有不可更改性和计算准确性，减少hase碰撞的几率
1.被final修饰，保证了其不可变性，也就是key不可更改，不会存在获取到的hase值不同的情情
2.重写了equals和hasecode方法，不会出出现hase值计算错误
使用自定义类时，我们要重写equals和hasecode方法.
2. 为什么使用红黑树而不用二叉树
二叉树在特殊情况下会生成一条线性结构，和链表相似，查询速度太慢。红黑树是二叉平衡树，会通过左旋优璇等操作保持平衡，虽然会付出一些代价，但是比起遍历链表而言，代价比较小，如果链表长度过小，就没必要转换为红核数，转换了反而浪费性能，查询速度慢。
3. 什么时候需要把链表转为红黑树
链化：红黑树节点<6
树化：链表长度大于等于8,数组长度大于等于64
4. 加载因子为什么是0.75
加载因子就是元素个数/数组容量
如果加载因子为1，空间利用率大大提升，但是产生hase冲突的机会就会大大增加，链表过长，查询效率慢
如果加载因子为0.5，hase冲突大大减少，但是空间利用率不高，频繁扩容，代价太大。
5. 为什么扩容
当我们添加的数据过多，产生的链表也就越长，当我们查询元素时，就需要遍历整个列表，速度太慢，哈希表的意义也就没有了。为了避免这种情况发生，我们就需要减少链表的长度-----扩容也就是增加数组的长度。
6.什么时候扩容
1.集合初始化，也就是第一次put的时候，数组长度默认为16
2.数组长度<64,链表长度>8
3.达到了阀值 = 加载因子*数组容量
7.HaseMap扩容机制
1.7之前: 数组+链表
1.先生成一个新的数组，之前的2倍
2.遍历老数组中所有的元素
3.获取每个元素的key值，并基于新数组的长度重新进行哈希运算，得到新的下标
4.将元素添加新的数组中
5.所有元素添加完成之后，将新数组赋值给对HaseMap象的table
1.8之后: 数组+链表+红黑树
1.先生成一个新的数组，之前的2倍
2.遍历老数组的每一个元素
链表：直接获取key值，重新计算下标，添加
红黑树：先遍历红黑树，计算出每个元素的下标，统计每个下标位置的元素个数，如果这个位置的元素大于8，则生成一个新的红黑树，并将红黑树的根节点添加到新数组的对应的位置，小于8，生成链表，将头节点添加到新数组对应的下标位置
3.所有元素添加完成之后，将新数组赋值给对HaseMap象的table
8. 存储在Node中的hash值, 是否就是key的Hasecode()？
不是，存储的是对Key先做(hasecode)计算, 然后再无符号右位移16, 再按位异或，为了减少hase冲突。`
9. 怎么获取一个线程安全的HaseMap
1.加锁 --- 使用Collections中的`Collections.synchronizedMap(map);`方法返回一个线程安全的HaseMap但是返回的并HaseMap不是真正的。只是一个引用
2.使用ConcurrentHashMapMap,HaseTable（已经废弃）
10. HaseMap和HaseTable的区别
1.线程是否安全: HaseMap是非线程安全的，HaseTable是线程安全的，内部使用的方法基本都经过synchronized修饰（如果想保证线程安全建议使用ConcurrentHashMap，HaseTable已经被淘汰了)
2.效率: 因为线程问题，HaseMap要比HaseTable效率要高一些
3.null值: HaseMap中可以支持key和value为null，key只有一个，value可以为多个。HaseTable key不能为null
4.初始容量和扩容: HaseMap默认初始容量为16，每次扩容，数组为之前的两倍，如果指定了初始容量，将其扩容为2的幂次方。HaseTable默认初始容量为11，每次扩容，数组为之前的两倍+1，如果指定了初始容量，将其扩容为2的幂次方
5.底层结构: HaseMap在JDK1.8之后，使用链表+数组+红黑树来提高查询效率
6.hase计算: HaseMap的对key的Hasecode进行了二次hash，以获得更好的散列值，然后对table数组长度取模，Hashtable直接使用key的hashcode对table数组的长度直接进行取模
11.哈希表底层采用什么算法计算hase值，还有什么算法可以用
底层采用key的hasecode方法值结合数组长度进行无符号右移，按位异或（^），按位与（&）计算出索引。
换可以用：平方取中法，取余数，伪随机数法，位运算效率最高，其他较低
HaseMap为什么线程不安全
put
有两个线程A和B
首先A插入一个key-value值到HashMap中，计算得到桶的索引坐标，然后获取到该桶里面的链表头结点,此时线程A的时间片用完了
此时线程B被调度得以执行，和线程A一样执行，只不过线程B成功将记录插到了桶里面
假设线程A插入的记录计算出来的桶索引和线程B要插入的记录计算出来的桶索引是一样的
那么当线程B成功插入之后，线程A再次被调度运行时，它依然持有过期的链表头但是它对此一无所知，以至于它认为它应该这样做，
如此一来就覆盖了线程B插入的记录，这样线程B插入的记录就凭空消失了，造成了数据不一致的行为。
resize扩容
JDK1.7时会发生，因为他使用的头插法
单向链表对表头操作效率最高，因此我们要保证先加入的数据在表头，然后将链表整体下移，因此新添加得数据放在链头，最先加入的数值放在链尾，但如果这个位置没有数据，那就直接放就完了。
【大厂经典面试题，CTO带你深入解读：为什么HashMap会产生死循环？【Java面试】-哔哩哔哩】 https://b23.tv/0fGpcmU
两个线程同时修改一个链表结构会产生一个循环链表（JDK1.7中，会出现resize前后元素顺序倒置的情况）。接下来再想通过get()获取某一个元素，就会出现死循环。
在对table进行扩容到newTable后，需要将原来数据转移到newTable中，注意10-12行代码，
转移元素的过程中，使用的是头插法，也就是链表的顺序会翻转，这里也是形成死循环的关键点。
我们假设有两个线程同时需要执行resize操作
此时线程A中运行结果如下：
线程A挂起后，此时线程B正常执行，并完成resize操作，结果如下：
这里需要特别注意的点：由于线程B已经执行完毕，根据Java内存模型，现在newTable和table中的Entry
都是主存中最新值：7.next=3，3.next=null。
此时切换到线程A上，在线程A挂起时内存中值如下：e=3，next=7，newTable[3]=null，代码执行过程如下：
newTable[3]=e ----> newTable[3]=3 e=next ----> e=7
此时结果如下：
继续循环：
e=7 next=e.next ----> next=3【从主存中取值】
e.next=newTable[3] ----> e.next=3【从主存中取值】
newTable[3]=e ----> newTable[3]=7
e=next ----> e=3
结果如下：
再次进行循环：
e=3 next=e.next ----> next=null
e.next=newTable[3] ----> e.next=7
即：3.next=7
newTable[3]=e ----> newTable[3]=3
e=next ----> e=null
注意此次循环：e.next=7，而在上次循环中7.next=3，出现环形链表，并且此时e=null循环结束。
结果如下：
源码JDK1.8之后
1.基本属性
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//序列化和反序列化时使用相同的id
private static final long serialVersionUID = 362498820763181265L;
//初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树形阈值
static final int TREEIFY_THRESHOLD = 8;
//链形阀值
static final int UNTREEIFY_THRESHOLD = 6;
//最小树形容量
static final int MIN_TREEIFY_CAPACITY = 64;
//节点
transient Node<K,V>[] table;
//存储键值对的个数
transient int size;
//散列表被修改的次数
transient int modCount;
//扩容之后的数组大小 容量*加载因子
int threshold;
//负载因子
final float loadFactor;
}
2. 构造方法
//无参构造器
public HashMap() {
//加载因子默认为0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//指定容量大小的构造器，调用的是全参构造器
public HashMap(int initialCapacity) {
// 指定的容器长度 ， 加载因子 0.75
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//全参构造器 指定的容器长度 加载因子
public HashMap(int initialCapacity, float loadFactor) {
// 如果指定的容器长度 小于 0
if (initialCapacity < 0)
// 抛出异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//HashMap 的最大容量只能是 MAXIMUM_CAPACITY，哪怕传入的数值大于最大容量，也按照最大容量赋值
// 如果容器大小大于 最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
// 容器长度 设置为 最大容量
initialCapacity = MAXIMUM_CAPACITY;
// 加载因子小于0 或者 不是一个数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//加载因子为0.75
this.loadFactor = loadFactor;
//扩容之后的数组大小
this.threshold = tableSizeFor(initialCapacity);
}
//返回给定目标容量的 2 大小的幂。
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
//创建一个新的HaseMap将传入的子Map中的全部元素逐个添加到HashMap中
public HashMap(Map<? extends K, ? extends V> m) {
//设置加载因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
3.Node 结点
1.7 之前是Entry 结点，1.8之后则是 Node 结点，其实相差不大，因为都是实现了 Map.Entry （Map 接口中的 Entry 接口）接口，即，实现了 getKey() ， getValue() ， equals(Object o )和 hashCode() 等方法；
static class Node<K,V> implements Map.Entry<K,V> {
//hash 值
final int hash;
//键
final K key;
//值
V value;
//后继，链表下一个结点
Node<K,V> next;
//全参构造器
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
//返回与此项对应的键
public final K getKey() { return key; }
//返回与此项对应的值
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
//hash 值
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//判断2个Entry是否相等，必须key和value都相等，才返回true
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
4. 添加键值对
4.1 put()方法
//添加键值对
public V put(K key, V value) {
/*
*参数一: 调用hash()方法
*参数二: 键
*参数三: 值
**/
return putVal(hash(key), key, value, false, true);
}
4.2 hash()方法
static final int hash(Object key) {
int h;
//key为空，hase值就是 0 ，否则hasecode移位右移16位进行按位异或运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
4.3 putVal()方法
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
onlyIfAbsent如果为真，则不更改现有值
*@param onlyIfAbsent if true, don't change existing value
exist如果为false，则表处于创建模式。
* @param evict if false, the table is in creation mode.
return上一个值，如果没有，则返回null
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//申明tab 和 p 用于操作原数组和结点
Node<K,V>[] tab; Node<K,V> p;
int n, i;
//如果原数组是空或者原数组的长度等于0，那么通过resize()方法进行创建初始化
if ((tab = table) == null || (n = tab.length) == 0)
//获取到创建后数组的长度n
n = (tab = resize()).length;
//通过key的hash值和 数组长度-1 计算出存储元素结点的数组中位置（和1.7一样）
//并且，如果该位置为空时，则直接创建元素结点赋值给该位置，后继元素结点为null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//否则，说明该位置存在元素
Node<K,V> e; K k;
//判断table[i]的元素的key是否与添加的key相同，若相同则直接用新value覆盖旧value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//判断是否是红黑树的结点，如果是，那么就直接在树中添加或者更新键值对
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//否则，就是链表，则在链表中添加或替换
else {
//遍历table[i]，并判断添加的key是否已经存在，和之前判断一样，hash和equals
//遍历完毕后仍无发现上述情况，则直接在链表尾部插入数据
for (int binCount = 0; ; ++binCount) {
//如果遍历的下一个结点为空，那么直接插入
//该方法是尾插法（与1.7不同）
//将p的next赋值给e进行以下判断
if ((e = p.next) == null) {
//直接创建新结点连接在上一个结点的后继上
p.next = newNode(hash, key, value, null);
//如果插入结点后，链表的结点数大于等7（8-1，即大于8）时，则进行红黑树的转换
//注意:不仅仅是链表大于8，并且会在treeifyBin方法中判断数组是否为空或数组长度是否小于64
//如果小于64则进行扩容，并且不是直接转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//完成后直接退出循环
break;
}
//不退出循环时，则判断两个元素的key是否相同
//若相同，则直接退出循环，进行下面替换的操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//否则，让p指向下一个元素结点
p = e;
}
}
//接着上面的第二个break，如果e不为空，直接用新value覆盖旧value并且返回旧value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//添加成功后，判断实际存在的键值对数量size是否大于扩容阈值threshold（第一次时为12）
if (++size > threshold)
//若大于，扩容
resize();
//添加成功时会调用的方法（默认实现为空）
afterNodeInsertion(evict);
return null;
}
4.4 resize()方法
//该函数有两种使用情况：初始化哈希表 前数组容量过小，需要扩容
final Node<K,V>[] resize() {
//获取原数组
Node<K,V>[] oldTab = table;
//获取到原数组的容量oldCap
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//获取原扩容之后的大小
int oldThr = threshold;
//新的容量和阈值目前都为0
int newCap, newThr = 0;
if (oldCap > 0) {
//如果原数组容量大于等于最大容量，那么不再扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//而没有超过最大容量，并且大于初始容量 16，那么扩容为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//扩容为原2倍
newThr = oldThr << 1; // double threshold
}
//经过上面的if，那么这步为初始化容量（使用有参构造器的初始化）
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//否则，使用的无参构造器
//那么，容量为16，阈值为12（0.75*16）
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//计算新的resize的上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//使用新的容量床架一个新的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将新的数组引用赋值给table
table = newTab;
//如果原数组不为空，那么就进行元素的移动
if (oldTab != null) {
//遍历原数组中的每个位置的元素
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//如果该位置元素不为空，那么上一步获取元素接着置为空
oldTab[j] = null;
//判断该元素上是否有链表
if (e.next == null)
//如果无链表，确定元素存放位置，
//扩容前的元素位置为 (oldCap - 1) & e.hash ,所以这里的新的位置只有两种可能：1.位置不变，
//2.变为 原来的位置+oldCap，下面会详细介绍
newTab[e.hash & (newCap - 1)] = e;
//判断是否是树结点，如果是则执行树的操作
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//否则，说明该元素上存在链表，那么进行元素的移动
//根据变化的最高位的不同，也就是0或者1，将链表拆分开
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//最高位为0时，则将节点加入 loTail.next
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//最高位为1，则将节点加入 hiTail.next
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//通过loHead和hiHead来保存链表的头结点，然后将两个头结点放到newTab[j]与newTab[j+oldCap]上面去
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
ConcurrentHashMap
https://blog.csdn.net/qq_41737716/article/details/90549847
JDK1.7之前
首先将数据分为一段一段的进行存储，然后每一段数据配上一把锁（lock锁），当一个线程占用锁访问其中一个数据时，其他的数据段也可以被其他的线程进行访问。
JDK1.8 之后
锁的的是节点，volatile+CAS实现无锁化，底层使用数组+链表+红黑树
CAS是compare and swap的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后,下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。
CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。
