1、Set
Set 不允许元素重复，主要有两个实现类：TreeSet 和HashSet。
TreeSet 要求放进去的元素具有可比性，该类对象应该实现Comparable接 口，覆写 compareTo 方法。
HashSet 底层有个 HashMap ，是将添加的元素作为 key ,其 value 是一个 new 出来的 Object 对象：
private static final Object PRESENT = new Object();
它是通过元素的 hashCode 和 equals 方法来判断是否重复。这里的 hashCode 是个 native 方法，不由 java 实现，(本地方法可用于 Java 与底层操作系统交互) 为不同的对象生成不同的整型数字（可为负数），即内存地址。
public native int hashCode();
2、Map
Map用来存键值对类型的数据。重要的子类有HashMap,TreeMap。
Map 的每一个键值对都是一个 Entry。
♥ HashMap 是基于 hash 表的数组（索引效率高，查找快，插入、删除慢）和链表（相反）相结合的数据结构。数组被分为若干个桶。桶可以提供常量级时间性能。
HashMap 不能保证 map 的次序，不能保证次序随时间不变。
HashMap 与 HashTable 大致相同，不过它非同步，线程不安全，它允许null。
有参构造
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: "
+
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
阈值
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
阈值设置为 2 的幂次方。
最大容许阈值
static final int MAXIMUM_CAPACITY = 1 << 30;
即2的30次方。
♥ 它的有参构造方法会传入两个重要参数：initialCapacity 【初始容量】 和loadFactor 【负载因子】。（如果是无参构造，在构造方法中只会给 负载因子 赋值，resize() 时才会给 初始容量赋值）初始容量即桶的初始数量，负载因子用来描述当桶的装载程度达到多少时会进行再散列。负载因子不宜太大：说明空间利用程度高，散列冲突的几率大，链表就长，查找效率变低；不宜太小:容易触发扩容，造成空间浪费。
这个构造方法还会给threshold 【阈值】 属性赋值，阈值=容量*负载因子，调用 tableSizefor (initialCapacity) ,该方法会先判断传入的值是否为2的幂次方 且大于0且小于最大容许阈值(2^30)，否则返回比它大的最小的2次幂。
❓ 为什么要设置成2次幂呢❓ 因为计算 key 对应的桶索引时，是用 key 对应的 hashCode%桶的数量，如果桶的数量是 2 的幂次方，那么该区域计算等价于&（除数-1），按位与计算效率高。而桶的数量受阈值影响，如果通过有参构造算出的阈值为2的幂次方，那么这个桶的数量也一定会为2的幂次方。
transient Node<K,V>[] table;
//数组是由 Node 构成的，Node 是实现了 Entry 的静态类
//Entry 是个接口
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
数组被分为一个个桶（bucket），即一个桶对应一个下标，给定 key值 时，用 key 对应的 hashCode 对桶的数量取余，求得桶的索引，如果索引相同，用拉链法解决冲突，即桶上链链表。每一个桶都是Node<Key,Value>，属性为key,value,next; 整个hash表是一个Node数组:Node<Key,Value>[] table。
在 JDK1.8上添加了新性能：当链表长度大于 8 时转换为红黑树。节点变为TreeNode，属性为 parent, left, right, red(boolean类型)。
HashMap采用的是懒加载机制，当第一次调用 put 时，（put内部只是调用putVal方法）发现table==null或table.length==0,才调用 resize() 进行扩容。每次put完都会给 size+1,（ ArrayList也是这样 ）如果size>threshold,则需要扩容，调用resize()方法。
resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//原容量，即数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//原阈值
int oldThr = threshold;
int newCap, newThr = 0;
//如果数组已经有元素
if (oldCap > 0) {
//如果初始容量大于2的30次方
if (oldCap >= MAXIMUM_CAPACITY) {
//阈值赋为 2的31次方 -1
threshold = Integer.MAX_VALUE;
//返回原数组
return oldTab;
}
//如果初始容量没有大于2的30次方
//如果双倍扩容后小于2的30次方，且 原容量大于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//阈值加倍
newThr = oldThr << 1;
// double threshold
}
//数组为空
//如果已经通过构造方法改变初始容量和负载因子，则阈值也被改变
else if (oldThr > 0)
// initial capacity was placed in threshold
//将原阈值作为新容量
newCap = oldThr;
//无参构造的情况
else {
// zero initial threshold signifies using defaults
//无参构造，就将新容量赋为 16
newCap = DEFAULT_INITIAL_CAPACITY;
//新阈值为 初始容量*负载因子 即 16*0.75=12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//通过构造方法传入初始容量和负载因子的
//新阈值为 初始容量*负载因子
float ft = (float)newCap * loadFactor;
//判断新容量、阈值是否小于 是否小于允许最大的2的30次方
//赋值 或 只能是允许的最大整数值 2的31次方-1
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
♥下面来分析resize()方法，由上一段可知，它起到两个作用：
（1）初始化桶数组。
（2）填充程度达到 threshold 时进行扩容。其实它不仅是容量、阈值变化，还完成了扩容后数据的转移。先看容量、阈值变化的部分，其中newCap的值用于扩容后数据转移至新table用，newThreshold会再赋给threshold,用于判断何时需要再散列。
是这样的：
以 数组是否为空 分情况：
先计算当前数组的长度，如果数组不为空，而长度大于 2的30次方，那么阈值就赋为 整数最大值 2的 31次方-1，返回原数组即可；
如果数组没有那么大，就双倍扩容，如果双倍扩容后的容量大于 2的30次方，阈值取 整数最大值 2的31次方-1，如果没有，那么阈值也跟着双倍扩容（因为负载因子不变呀）。
对于默认无参构造的情况，会先给 初始容量赋默认值 16，阈值是160.75=12。
如果数组为空（比如清空了，有别于默认无参构造，它是传入过初始容量和负载因子的），那么就以阈值作为新容量。然后用新容量乘以负载因子求得 新阈值。举个例子，通过构造方法传入初始容量为16，负载因子为 0.75，而这个 HashMap 被清空了，那么新容量就是 160.75=12，新的阈值是 12*0.75=9，数组的长度为12，达到 9就扩容。
确定了阈值和新容量后，就会把原来数组的内容放到新数组 newTab中 。♥
@SuppressWarnings({"rawtypes","unchecked"})
//新建容量为 newCap 的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//遍历原数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//取得节点，并把该节点置为 null
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果没有链链表
if (e.next == null)
//直接赋值，因为长度变化了，需要重新计算
newTab[e.hash & (newCap - 1)] = e;
//如果是红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//说明位置不需要改变
//链成链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//将位置需要改变的也链成链表
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//然后将两个链表链到新数组对应的位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//位置改变的也就是坐标加了个 oldCap
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
♥执行完扩容，新建长度为newCap 的 newTab ,接下来需要转移数据，步骤如下：
遍历Node[ ] oldTab数组，先取得当前节点，后把原数组oldTab该节点置为null。
如果该节点并没有链链表，直接往新数组 newTab 赋值即可，但是因为经历了扩容，数组长度即桶的数量改变，因此需要再散列，下标为e.hash & (newCap - 1)。
如果该节点链了链表，先判断是否红黑树，如果是，会调用 split() 方法拆分，如果只是链表，会通过（e.hash()&oldCap），结果为0，说明位置不需要改变。将位置不需要改变【lohead，,lotail）的和位置需要改变(hihead,hitail)的分别链成两个链表，然后才把这两个链表链到新数组newTab的相应位置。
这样避免了因为HashMap线程不安全可能导致的循环链表，调用get方法时出现死循环，而且链表尾插，数据不会逆序。♥
Map的public Set<key,value> entrySet()方法返回的是一个EntrySet类的对象，EntrySet继承了AbstractSet,返回的并不是真正的Set，只是一个Set视图，格式是 [key=value] 。
同理，keySet方法返回的是一个KeySet类的对象，KeySet类继承了AbstractSet。
values方法返回的是一个Value类的对象，Value类继承了AbstractCollection。（因为value是允许重复的，所以不是Set）
put方法
❓ 为什么调用 HashMap 的 put 给的 key 重复时，会覆盖原来 key 对应的 value，然后返回原来的 value ❓
答：HashMap的 put 方法是这样的：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
相当于调用了putVal方法：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//数组为null或长度为0时
if ((tab = table) == null || (n = tab.length) == 0)
//扩容
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果数组已经有元素
else {
Node<K,V> e; K k;
//就根据 key 求得的 hash 计算桶索引
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果索引处节点为 null，直接插入即可
e = p;
//如果已有元素，直接覆盖，返回原 key 对应的 value
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
从这个方法可以看到：
如果当前 table=null 或 长度为0，就调用 resize() 方法，初始化 table,否则根据桶的长度和由 key 求得的 hash 值计算桶索引，
如果当前node节点为null，直接插入即可；
如果当前node节点不为null，已经有元素了，说明发生了哈希冲突，如果key值相同，直接将节点覆盖，返回原来的 key 对应的 value 。
如果key值不同，检查该节点是否为红黑树的节点，如果是，调用putTreeVal，如果不是，在链表尾插元素即可，尾插时注意当链表节点为8时需要转换成二叉树，返回null。
HashTable 和HashMap 的区别：
（1）与 Hashtable 1.2 相比，HashMap 1.0 不同步，是非线程安全的，允许 null 值。
（2）Hashtable 继承自 Directory，HashMap 继承自 AbstractMap.
（3）HashMap 默认初始容量为 16，总是 2 的幂次方。
（4）Hashtable默认初始容量为11，扩容机制是oldCap*2+1。
（5）HashMap 的 keySet 方法中遍历元素用的是 Iterator，而Hashtable由于版本遗留原因，用的是Iterator和Enumeration。（线程安全的 Vector 也用的是Enumeration.）
（6）HashMap 取消了原来 HashTable 有的 contains(Object value) 方法，改成了containsKey 和 containsValue。
（7）散列方式不同，Hashtable 直接用的 hashCode。
Hashtable 源码里说，如果需要线程安全，建议使用 HashMap;如果需要并发操作，建议使用 ConCurrentMap。
（我自己发现的🤭 ：在 Map 接口中有 Entry 接口，在 Hashtable 中有个静态内部类Entry 实现了这个接口，而在 JDK1.8 中，HashMap 是有个静态类 Node 实现了 Entry接口。）
HashMap中出现的与运算
- putVal() 通过 key 确定桶索引
tab[i = (n - 1) & hash]
除数是 2 的幂次 则等价于 其除数-1 的与& 操作。
比如 7%4=7&(4-1)。
- resize() 无链表时，直接转移数据
newTab[e.hash & (newCap - 1)] = e;
- resize()桶链不是红黑树时，判断节点位置是否改变
if ((e.hash & oldCap) == 0)
以 oldCap=16 为例。我们知道，为 key 寻找对应的桶索引是用 key.hash&(capacity-1)，16-1=15 的二进制表示为：
00001111
经过双倍扩容后，这时的 capacity-1 变为 16*2-1=31，二进制表示为:
00011111
与 key 的 hashCode 进行与运算，可以看出，主要影响结果的是 hashCode 的低 5 位，而 oldCap=16，它的二进制表示为：
00010000
如果 hashCode 的低 5 位为 “0”，它 &（oldCap-1）与&（newCap-1）结果相同，即位置不需要改变，而 &oldCap 结果为0；同理，如果hashCode 的低 5 位为“1”，它&（oldCap-1）与&（newCap-1）结果不同，即位置需要改变，且到新数组 newTab 中的位置正好是原位置 +oldTab,而 &oldCap 结果为1。
1301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
