本文详细分析了HashMap的put操作、扩容(resize)与迁移(tansfer)机制，以及与TreeMap的差异，包括负载因子、线程安全问题、哈希原理和数据结构的选择。重点讲解了JDK8中HashMap的优化和如何在不同场景下使用LinkedHashMap和TreeMap以保持顺序。
HashMap
put值
1.8
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;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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 {
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;
}
--------------------------------------------------------------------
1.7
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
索引-键值对映射
hash原理
在数学中，取模运算和取余运算是等价的，都是计算⼀个数除以另⼀个数的余数
在计算机中，取模运算和取余运算的差别在于，当被除数为负数时，取模运算的结果符号与被除数相同，取余运算的结果符号与除数相同
在 Java 中，取模运算使⽤ % 运算符，取余运算使⽤ Math.floorMod() ⽅法。
a % 2n= a & (2n -1)
- &(与运算)有零为零，|(或运算符)有1为1，^(异或运算符)相同为0
- 运算逻辑(key哈希值、高低位混合同时保留高位、取余计算下标)
hash ⽅法的主要作⽤是将 key 的 hashCode 值进⾏处理，得到最终的哈希值。由于 key 的hashCode 值是不确定的，可能会出现哈希冲突，因此需要将哈希值通过⼀定的算法映射到HashMap 的实际存储位置上。
hash ⽅法的原理是，先获取 key 对象的 hashCode 值，然后将其⾼位与低位进⾏异或操作，得到⼀个新的哈希值。为什么要进⾏异或操作呢？因为对于 hashCode 的⾼位和低位，它们的分布是⽐较均匀的，如果只是简单地将它们加起来或者进⾏位运算，容易出现哈希冲突，⽽异或操作可以避免这个问题。
然后将新的哈希值取模（mod），得到⼀个实际的存储位置。这个取模操作的⽬的是将哈希值映射到桶（Bucket）的索引上，桶是 HashMap 中的⼀个数组，每个桶中会存储着⼀个链表（或者红⿊树），装载哈希值相同的键值对（没有相同哈希值的话就只存储⼀个键值对）。
总的来说，HashMap 的 hash ⽅法就是将 key 对象的 hashCode 值进⾏处理，得到最终的哈希值，并通过⼀定的算法映射到实际的存储位置上。这个过程决定了 HashMap 内部键值对的查找效率。
resize()
newCapacity = oldCapacity << 1;
tansfer()
1.7
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
-----------------------------------------------------------------------
1.8
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;
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;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
JDK 8 不需要像 JDK 7 那样᯿新计算 hash，只需要看原来的hash值新增的那个bit是1还是0就好了，是0的话就表示索引没变，是1的话，索引就变成了“原索引+原来的容量”。a&2n
1、在进⾏扩容操作时，HashMap 会先将数组的⻓度扩⼤⼀倍，然后将原来的元素重新散列（这个词还是挺贴切的）到新的数组中。由于元素的散列位置是通过 key 的 hashcode 和数组⻓度取模得到的，因此在数组⻓度扩⼤后，元素的散列位置也会发⽣⼀些改变。
2、在重新散列元素时，如果⼀个元素的散列位置发⽣了改变，那么它需要被移动到新的位置。如果新的位置上已经有元素了，那么这个元素就会被添加到链表的末尾，如果链表的⻓度超过了阈值（8个），那么它将会被转换成红⿊树。排队入座
负载因子0.75
Java 8 之前，HashMap 使⽤链表来解决冲突，即当两个或者多个键映射到同⼀个桶时，它们被放在同⼀个桶的链表上。当链表上的节点（Node）过多时，链表会变得很⻓，查找的效率（LinkedList 的查找效率为 O（n））就会受到影响。
Java 8 中，当链表的节点数超过⼀个阈值（8）时，链表将转为红⿊树（节点为TreeNode），红⿊树（在讲TreeMap时会细说）是⼀种⾼效的平衡树结构，能够在 O(log n) 的时间内完成插⼊、删除和查找等操作。这种结构在节点数很多时，可以提⾼ HashMap 的性能和可伸缩性。
HashMap 的加载因⼦（load factor，直译为加载因⼦，意译为负载因⼦）是指哈希表中填充元素的个数与桶的数量的⽐值，当元素个数达到负载因⼦与桶的数ᰁ的乘积时，就需要进⾏扩容。这个值⼀般选择 0.75，是因为这个值可以在时间和空间成本之间做到⼀个折中，使得哈希表的性能达到较好的表现。
如果负载因⼦过⼤，填充因⼦较多，那么哈希表中的元素就会越来越多地聚集在少数的桶中，这就导致了冲突的增加，这些冲突会导致查找、插⼊和删除操作的效率下降。同时，这也会导致需要更频繁地进⾏扩容，进⼀步降低了性能。
线程安全问题
- 1.7头插会引起环形链表问题（e.next = newTable[i];newTable[i] = e;）
- 元素丢失
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); - put 和 get 并发时会导致 get 到 null
线程 A 执⾏put时，因为元素个数超出阈值⽽出现扩容，线程B 此时执⾏get，有可能导致这个问题。
总结
HashMap是Java中最常⽤的集合之⼀，它是⼀种键值对存储的数据结构，可以根据键来快速访问对应的值。以下是对HashMap的总结：
HashMap采⽤数组+链表/红⿊树的存储结构，能够在O(1)的时间复杂度内实现元素的添加、删除、查找等操作。
HashMap是线程不安全的，因此在多线程环境下需要使⽤ConcurrentHashMap来保证线程安全。
HashMap的扩容机制是通过扩⼤数组容量和重新计算hash值来实现的，扩容时需要重新计算所有元素的hash值，因此在元素较多时扩容会影响性能。
在Java 8中，HashMap的实现引⼊了拉链法、树化等机制来优化元素存储的情况，进⼀步提升了性能。
HashMap中的key是唯⼀的，如果要存储重复的key，则后⾯的值会覆盖前⾯的值。
HashMap的初始容量和加载因⼦都可以设置，初始容ᰁ表示数组的初始⼤⼩，加载因⼦表示数组的填充因⼦。⼀般情况下，初始容ᰁ为16，加载因⼦为0.75。
HashMap在遍历时是⽆序的，因此如果需要有序遍历，可以使⽤TreeMap
LinkedHashMap
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
HashMap 是⼀种常⽤的哈希表数据结构，它可以快速地进⾏键值对的查找和插⼊操作。但是，HashMap 本身并不保证键值对的顺序，如果我们需要按照插⼊顺序或访问顺序来遍历键值对，就需要使⽤ LinkedHashMap 了。
LinkedHashMap 继承⾃ HashMap，它在 HashMap 的基础上，增加了⼀个双向链表来维护键值对的顺序。这个链表可以按照插⼊顺序或访问顺序排序，它的头节点表示最早插⼊或访问的元素，尾节点表示最晚插⼊或访问的元素。这个链表的作⽤就是让 LinkedHashMap 可以保持键值对的顺序，并且可以按照顺序遍历键值对。
LinkedHashMap 还提供了两个构造⽅法来指定排序⽅式，分别是按照插⼊顺序排序和按照访问
顺序排序。在按照访问顺序排序的情况下，每次访问⼀个键值对，都会将该键值对移到链表的尾部，以保证最近访问的元素在最后⾯。如果需要删除最早加⼊的元素，可以通过重写removeEldestEntry() ⽅法来实现。
LinkedHashMap<String, Integer> kvLinkedHashMap = new LinkedHashMap(32, .75f, true);
TreeMap
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
注意 cmp = k.compareTo(t.key) 这⾏代码，就是⽤来进⾏ key ⽐较的，由于此时 key 是
String，所以就会调⽤ String 类的 compareTo() ⽅法进⾏⽐较。
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
- ⾸先定义⼀个Entry类型的变量t，⽤于表示当前的根节点；如果t为null，说明TreeMap为空，直接创建⼀个新的节点作为根节点，并将size设置为1；
- 如果t不为null，说明需要在TreeMap中查找键所对应的节点。因为TreeMap中的元素是有序
的，所以可以使⽤⼆分查找的⽅式来查找节点； - 如果TreeMap中使⽤了Comparator来进⾏排序，则使⽤Comparator进⾏⽐较，否则使⽤
Comparable进⾏⽐较。如果查找到了相同的键，则直接更新键所对应的值； - 如果没有查找到相同的键，则创建⼀个新的节点，并将其插⼊到TreeMap中。然后使⽤
fixAfterInsertion()⽅法来修正插⼊节点后的平衡状态； - 最后将TreeMap的size加1，然后返回null。如果更新了键所对应的值，则返回原先的值。
TreeMap<Object, Object> treeMap = new TreeMap(Comparator.reverseOrder());
Object o = treeMap.lastKey();
Object o1 = treeMap.firstKey();
treeMap.headMap(3).entrySet();
treeMap.tailMap(3).entrySet();
差异性
扫一扫
764
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
