JAVA集合
HashMap
哈希算法，源码，初始化，扩容，存入和查询，底层结构，是否线程安全。。。。
put()
存储entry对象，先根据hash算法决定在数据的位置，再根据equals方法决定其在链表中的存储位置；
取出一个entry对象时，根据hash算法找到其在数组中的存储位置，再根据equals方法获取到该位置的链表种的entry。
put源码
将指定的值与此映射中的指定键相关联。如果映射先前包含键的映射，则替换旧值。
参数：
key – 与指定值关联的键
value – 与指定键关联的值
回报：
与key关联的前一个值，如果没有key映射，则返回 null 。 （返回null还可以指示映射先前将null与key关联。）
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
实现 Map.put 和相关方法。
参数：
hash – 键的散列
钥匙——钥匙
value – 要放置的值
onlyIfAbsent – 如果为真，则不更改现有值
evict – 如果为 false，则表处于创建模式。
回报：
前一个值，如果没有，则为 null
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果数组为空，则进行数组初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果存入的key的hash值经过计算在该数组中的位置上为空，则新建一个节点,使用尾插法
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果当前位置有元素，并且与此时位置上的key相等，那么让e引用p。p是当前位置上的元素
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果p结点属于红黑树类型，则是否putTreeVal方法存入数据
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//遍历链表，
//遍历时，binCount的值从0开始，为0，1，2，3，4，5，6，7。也就是说binCount为7时，链表中的元素已经8个了，再加上我们传进来的这个key，一共9个元素，此时就会进行树化。
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;
}
//如果链表中存在相同的key，则直接覆盖该数据
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 这里的e是当前数组位置上的值，并不是我们传入进来，此时拿到旧值，将旧值替换为新值。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
// 结构被修改了，要++的
++modCount;
// 如果此时size大于了阈值，要扩容的。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
putTreeVal红黑树插入
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// root()方法是返回红黑树的根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 比较旧key与新key的hahs值，如果大于为-1，如果小于为1
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// 如果此时根节点与传入的key相等，直接返回p
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// kc上面已经赋值为null，所以对于短路与来讲，comparableClassFor(k)此方法必会执行。
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
// 在通过 hash 值跟 k 比较不出的情况下，则判断插入的 key 是否
// 是 Comparable 类型，以及两个类是否属于同一类型，如果是则
// 调用 compareTo 比较两个 key 的大小，如果无法比较则从当前
// 节点开始，查询所有子节点是否存在 key 相等的情况，如果有就
// 直接返回。
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
// 左子树不为空，先查左子树
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
// 右子树不为空，先查右子树
(q = ch.find(h, k, kc)) != null))
// 返回key
return q;
}
dir = tieBreakOrder(k, pk);
}
// 往树节点中插入此key
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
// 插入完后进行平衡(balanceInsertion()方法)，左旋右旋变色等操作。此树还有一个隐藏的双向链 表，确保给定的根节点是双向链表的头节点。
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
resize扩容
final Node<K,V>[] resize() {
// 旧数组
Node<K,V>[] oldTab = table;
// 如果数组为0，说明未进行初始化，后面会进行初始化，否则返回表的length
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取阈值
int oldThr = threshold;
int newCap, newThr = 0;
// 如果旧数组的容量大于0
if (oldCap > 0) {
// 旧数组容量是否大于最大支持容量
if (oldCap >= MAXIMUM_CAPACITY) {
// 阈值设置为最大，因为容量已经最大了，不能再扩容了。
threshold = Integer.MAX_VALUE;
// 返回旧值
return oldTab;
}
// 阈值为2倍，比如默认容量为16，阈值为12，然后下次扩容为32，那么阈值就是24。所以进行左移
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 newThr重新计算阈值 容量*加载因子
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 = newTab;
if (oldTab != null) {
// 遍历旧数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果下一个元素为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;
// 旧数组往新数组上进行转移
// 这个循环对旧数组上的元素进行重hash优化 以0和1分隔
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;
}
// 原索引+旧数组长度放入桶中
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
get方法
- 传入key的hash值，和key
- 判断table是否为空且表的长度大于0，以及&操作得出下标，判断数组当前位置是否元素存在
- 判断头节点是否是我们要get的元素
- 如果头界定啊的下一个节点不为null，判断头节点是否是红黑树，如果是树，那么以树节点的方式去获取，调用getTreeNode方法，然后里面其实也就是调用的find()方法。
- 如果不是树，遍历边表，找到返回
- 如果没有找到key，就返回null
public V get(Object key) {
Node<K,V> e;
//也是调用getNode方法来完成的
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
//first 头结点，e 临时变量，n 长度,k key
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//头结点也就是数组下标的节点
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果是头结点，则直接返回头结点
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//不是头结点
if ((e = first.next) != null) {
//判断是否是红黑树结构
if (first instanceof TreeNode)
//去红黑树中找，然后返回
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do { //链表节点，一样遍历链表，找到该节点并返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//找不到，表示不存在该节点
return null;
}
hashMap1.7和1.8的区别
| 区别 | 1.8 | 1.7 |
|---|---|---|
| 扩容后存储位置的计算方式 | 扩容后的位置=原位置或者原位置+旧容量 | 按照原来方法重新计算，hashcode经过扰动处理并于数组长度进行与操作 |
| 转移数据的方式 | 尾插法(直接插入到链表尾部/红黑树) | 头插法 （先将原位置的数据往后移动一位，再将数据插入到该位置） |
| 插入数据的时机 | 扩容前插入 | 扩容后插入 |
| 插入数据位置重新计算的时机 | 转移数据前统一计算 | 单独计算 |
| 存储的数据结构 | 数组+链表+红黑树 | 数组+链表 |
| 数组和链表节点的实现类 | Node类 | Entry类 |
| 初始化方式 | 直接继承在扩容函数resize() | 单独函数：inflateTable() |
| hash值的计算方式 | 扰动处理=2次扰动（1次位运算+1次异或运算） | 扰动处理=9次扰动（4次位运算+5次异或运算） |
| 存放数据规则 | 无冲突时放入链表/冲突且链表长度小于8存入单链表/冲突且单链表长度大于8存入红黑树 | 无冲突时，存放数组/冲突存放到单链表中 |
为什么采用hash值和运算数组长度-1来计算数组下标？
-
提高运算效率，计算下标的方式其实就是hash值对数组进行取模计算，为了等价所以必须h&(length-1)，h&(length-1)等于 h%length。并且采用位运算可以提高效率
-
均匀分部再数组的各个位置，降低hash冲突
首先数组长度可为奇，也可以为偶数，如果为奇数，那么二进制最后一位肯定为1，如果在奇数上减1，最后一位就为0，那么再与hash值进行与操作时，所有的下标都会是偶数，浪费了一半的存储空间，容易出现hash冲突。
-
接入hash码与数组大小不匹配的情况
为什么不直接使用hashCode()处理的哈希码作为存储数组table的下标位置？
容易出现hash码与数组大小不匹配的情况，计算出来的哈希码可能不在数组大小范围内，导致如法匹配存储位置hashmap的容量范围一般不会取到最大值，而且需求上并不需要这么多的存储空间。
为什么在计算数组下标前，需要对哈希码进行扰动处理？
加大哈希码低位的随机性，使得分部更加均匀，从而提高对数组存储下标位置的随机性与均匀性，最终较少hash碰撞。
为什么引入红黑树？
因为在查找数据时，单链表的时间复杂度为O(n)，当单链表长度大于8，并且数组元素大于64时，链表会转换为红黑树，这样查找元素的时间复杂度只需要O(logn)。
hashmap扩容
hashmap在扩容之后，阈值会变为原来的2倍，并且会对所有节点进行rehash分布。分布之后的位置只可能有两个，原索引的位置或者原索引+旧容量(oldCap)的位置。
线程安全问题
hashmap中，如果两个线程同时进行put操作，这两个key的hash值一样，但是数据不同，此时A线程进入，假设A线程还未进行数据插入时挂起，此时线程B正常执行，插入数据。然后A线程获取cpu时间片，此时线程A不会进行hash判断，直接将B线程插入的数据直接覆盖。
ConcurrentHashMap
在jdk1.8的改进
-
结构改变
首先是结构上的变化，和HashMap一样，数组+链表+红黑树
-
HashEntry改为Node
和JDK7的HashEntry作用相同，对val和next 都用了volatile 关键字，保证了可见性。
-
put的变化
- 根据key计算出HashCode，然后遍历table；
- 判断是否需要初始化；
- f 即为当前key定位出的Node，如果为空表示当前位置可以写入数据，利用CAS尝试写入，失败则自旋保证成功；
- 如果当前位置的 hashCode == MOVED == -1，则需要等进行扩容；
- 如果都不满足，则利用synchronized 锁写入数据；
- 如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树；
1.8在1.7的数据结构上做了大的改动，采用红黑树之后可以保证查询效率，甚至取消了ReentrantLock改为了synchronized，这样可以看出在新版的JDK中对synchronized 优化是很到位的。
98
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
