HashMap类图结构
引用参考
https://blog.csdn.net/m0_37914588/article/details/82287191
https://blog.csdn.net/hefenglian/article/details/79763634
HashMap的类结构
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
}
属性
//序列号，序列化的时候使用。
private static final long serialVersionUID = 362498820763181265L;
/**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。【默认容量=16】**/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，2的30次方。最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子，用于扩容使用。
为什么java Hashmap 中的加载因子是默认为0.75【https://www.jianshu.com/p/dff8f4641814】
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当某个桶节点数量大于8时，会转换为红黑树。
static final int TREEIFY_THRESHOLD = 8;
//当某个桶节点数量小于6时，会转换为链表，前提是它当前是红黑树结构。
static final int UNTREEIFY_THRESHOLD = 6;
//当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
static final int MIN_TREEIFY_CAPACITY = 64;
//存储元素的数组，transient关键字表示该属性不能被序列化
transient Node<K,V>[] table;
//将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set<Map.Entry<K,V>> entrySet;
//元素数量
transient int size;
//统计该map修改的次数
transient int modCount;
//临界值，也就是元素数量达到临界值时，会进行扩容。
int threshold;
//也是加载因子，只不过这个是变量。
final float loadFactor; HashMap构造方法
//根据初始化容量，加载因子初始化HashMap
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)//如果大于最大容量时，给定2的30次方
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;//设置加载因子变量
this.threshold = tableSizeFor(initialCapacity);
}
HashMap.tableSizeFor方法详解
/**
*
*
*返回大于输入参数且最近的2的整数次幂的数
*
*/
static final int tableSizeFor(int cap) {
//必须要先减1，为什么呢？
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;
/**
* 解释：
* 1、将输入参数-1的目的：
* 这个方法的目的是将：得到比输出参数'大'且最近的2的整数次幂的数，如：1得到2,3得到4,4得到4,15得到16,16得到16。而
* 当输入的是2的整数次幂如：2的时候，如果不-1,执行这个方法得到的就是4了，并不是我们所希望的2，这可不行。
*
* 2、位或是如何操作的？(以输入的数字为26举例)
* 首先-1，得到25
* n |= n >>> 1; 就是 n = n | n >>> 1;
* (1) n >>> 1 右位移1位 即 11001 移后的结果为 01100
* (2) n | n >>> 1 现在是这样的 11001 | 01100 ，这个位运算的结果是 11101，11101转成十进制的结果为 29
* (3) 同理！！！继续将29也就是n继续操作， n |= n >>> 2 ......直到n |= n >>> 16结束，得到的结果就这样的二进制了 11111
* (4) 11111结果是31，别忘了，最后return中还是需要+1的。
*
* 3、以输入的数字是32举例
* 首先-1，得到31
* n |= n >>> 1; 就是 n = n | n >>> 1;
* (1) n >>> 1 右位移1位 即 11111 移后的结果为 01111
* (2) n | n >>> 1 现在是这样的 11111 | 01111 ，这个位运算的结果是 11111，11111转成十进制的结果为 31
* (3) 同理！！！继续将31也就是n继续操作， n |= n >>> 2 ......直到n |= n >>> 16结束，得到的结果二进制还是 11111
* (4) 11111结果还是31，最后return中还是需要+1的，得到32。
*
*
*/
}
PUT
//存放
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//hash key的hashCode值
//key key值
//value value值
//如果为null的话，则插入新的value
//evict 此参数在hashMap中，不管true还是false都没的实际用，因为最终实现为一个空方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 哈希数组，p 该哈希桶的首节点，n hashMap的长度，i 计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果table=null活着tab的长度为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;
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 {
//这里一直循环，在循环内部去查找p为首节点
for (int binCount = 0; ; ++binCount) {
//如果首节点的下一个节点为空，说么这个为最后一个节点
if ((e = p.next) == null) {
//new一个新Node，放到最后一个节点的后面
p.next = newNode(hash, key, value, null);
//判断要不要转红黑树；binCount开始，TREEIFY_THRESHOLD =8，也就是说如果链表的长度大于=8时，就要转红黑树
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;
}
//
void afterNodeInsertion(boolean evict) { }
//初始化或扩容。如果为空，则在
符合场阈值内的初始容量目标。
否则，因为我们使用的是二次展开的能力
每个bin中的元素必须保持在同一索引中，或者移动
在新表中有两个偏移量的幂。
final Node<K,V>[] resize() {
//历史的哈希数组
Node<K,V>[] oldTab = table;
//历史的哈希数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//历史数组临界值
int oldThr = threshold;
int newCap, newThr = 0;
//如果oldCap大于0，表示hashMap不是首次加载（通过代码可以发现hashMap为存放数据时，才加载或设置容量），那么这里就是判断是否需要扩容
if (oldCap > 0) {
//如果最大值已经大于哈希数组最大容量，这个时候返回MAXIMUM_CAPACITY 2的30次方
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;//将临界值设置为Integer的最大值（Integer.MAX_VALUE）
return oldTab;
}else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//newCap=oldCap*2(oldCap << 1)如果newCap < 2的30次方 且 oldCap>=16（1<<4 二进制往左边移4位，相当于1*2*2*2*2=16咯）
//新的临界值为threshold*2，相当于在原有基础上扩容2倍
newThr = oldThr << 1; // double threshold
}else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//初始容量处于阈值
else {// zero initial threshold signifies using defaults
//零初始阈值表示使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;//取默认16
//newThr=16*0.75
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的临界值为0时
if (newThr == 0) {
//新临界值为数组长度*加载因子
float ft = (float)newCap * loadFactor;
//这里看临界值是不是超过最大值不是就去这个新临界值否则取int最大值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将hashMap属性设置为新临界值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//根据新哈希数组长度，初始化新的table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//将newTab覆盖hashMap属性table
if (oldTab != null) {//如果历史哈希数组不为空时，这里要将历史的数据拷贝到新的table中
//根据历史哈希数组长度进行遍历
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;//临时变量（节点）
//将哈希数组的节点取出来判断是不是空的
if ((e = oldTab[j]) != null) {//如果不是，那莫就要拷贝了
oldTab[j] = null;//让GC-work
if (e.next == null)//如果e.next没有一个元素
//把该变量的值存入newCap中，(注意：e.hash & (newCap - 1)并不等于j）
newTab[e.hash & (newCap - 1)] = e;//newCap-1这样随便怎么范围都在数组长度范围内，然后将e放入到table中
else if (e instanceof TreeNode)//该节点为红黑树结构，也就是存在哈希冲突，该哈希桶中有多个元素
//把此树进行转移到newCap中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//此处表示为链表结构，同样把链表转移到newCap中，就是把链表遍历后，把值转过去，在置位nul
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;
}
}
}
}
}
return newTab;
}remove
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
*
* @param hash 要删除key的hash值
* @param key key
* @param value value default=null
* @param matchValue false 如果为true，则仅在值相等时移除
* @param movable true 如果为false，则在移除时不要移动其他节点
* @return
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab;//哈希数组
Node<K,V> p;//当前节点
int n,index;//n为哈希数组长度
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//node 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
Node<K,V> node = null,e; K k; V v;
//如果当前节点的hash值与要删除的hash值相等&&
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;//要删除的节点--如果p为tree时，key的hash与p.hash肯定是不相等的。
else if ((e = p.next) != null) {//如果有next
//如果为红黑树
if (p instanceof TreeNode)
//找到要删除节点--根据hash和key
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//如果为链表时
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;//这个p为链表里面要删除节点的上一个节点prev
} while ((e = e.next) != null);
}
}
//找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue（matchValue默认为false）都为true
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
//如果是链表结构，且删除的节点为数组下标节点，也就是头结点，直接让下一个作为头
tab[index] = node.next;//假如不是这个next就是null，GC-work
else//为链表结构，删除的节点在链表中，把要删除的下一个结点设为上一个结点的下一个节点
p.next = node.next;
++modCount;
--size;
//此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理
afterNodeRemoval(node);
return node;
}
}
return null;
}clear
//清空
public void clear() {
//管你是哈希数组里面的元素时链表结构还是普通节点还是红黑树，都统统设置null，GC-work
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}get
//获取value
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
/**
* 在hashMap里面取数据，有3种情况
* 1、待取数据就是hashMap里面哈希数组的节点（Node元素）
* 2、待取数据为哈希数组的节点（为链表）中的某一个Node元素
* 3、待取数据为哈希数组的节点（为红黑树）中的某个Node元素
*/
Node<K,V>[] tab;//哈希数组容器
Node<K,V> first, e;//第一个节点，临时变量
int n; K k;//n=tab.length
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//第一个节点first有内容
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//先看看第一个节点的hash是否=当前key的hash，如果相等，在判断key是否相等，如果就是相等
//说明哈希数组该位置的元素就是key
return first;
//如果first.next有内容，说明key不在哈希数据index（(n - 1) & hash）所在元素，key在链表中或者红黑树中
if ((e = first.next) != null) {
//如果为红黑树时，去树里面获取Node
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//否则为链表，为链表时，直接循环获取。e=first.next，从首节点第二个节点开始遍历，因为首节点在第一个if条件时，已经做了
//排除，这里少循环一次，增加程序效率
do {
//e=要匹配的节点Node，比较其实很简单就是比较node.key是否等于传入的key（==等和equals等）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}将哈希map的key转化为Set集合
有个疑问参考：https://blog.csdn.net/li_canhui/article/details/85051250
//HashMap属性--定义了一个Set
transient volatile Set<K> keySet = null;
public Set<K> keySet() {
Set<K> ks;
return (ks = keySet) == null ? (keySet = new KeySet()) : ks;
}
//注意Set是一个接口（不包含具体的属性，包含了一堆方法）就算实现类KeySet也是一堆方法，也不包含任何属性--思路继续往下走
第一次调用keySet方法时，keySet属性是null，然后进行了初始化，再将keySet属性返回。
也就是说，HashMap里并不会随着put和remove的进行也维护一个keySet集合，而是在第一次调用keySet方法时，才给keySet属性初始化。
//我们的思路不能将keySet理解为一个集合，要把它理解为时一个实例对象，这个实例对象能够实现获取哈希数组节点Node里面所有的Key的遍历（具有集合的功能）
//
按照自己以往的理解，以为keySet返回的是一个集合，集合里面保存了HashMap的所有的Key【这个想法是有问题的，上面已经说了keySet具有遍历HashMap所有key的功能，但它不会将HahsMap里面的Key持有（实例中有集合包含key）】。
因为有了中先入为主的印象，所以读源码时，才感觉源码很奇怪。从源码中可以看到，初始化时，只是创建了一个KeySet类的对象，并没有把HashMap的key都加入进来，方法就返回了。
除了自己以往的理解外，还有一个现象，让我坚信这时HashMap的key已经加入到keySet了，那就是在调试代码过程中IDE给出的调试信息。如下图。从图中可以看出，创建完成KeySet()后，调试信息就已经可以显示出，ks中有2个元素了。这个信息更加坚定了自己之前的理解。
【那么，HashMap的key是什么时候加入到keySet集合(???这里不是集合哟)中的呢？】===我的疑问在这里
1、其实HashMap的key并没有加入到keySet集合中，而是在遍历的时候，使用迭代器对key进行的遍历。
2、KeySet类中的迭代器函数，返回的是一个KeyIterator类的对象。它的next方法返回的是HashIterator的nextNode的key。也就是说，当使用迭代器遍历set内的元素时，KeySet类的迭代器，会保证能够依次获取到HashMap的节点的key值，这就是我们遍历keySet的过程的实质。
final class KeySet extends AbstractSet<K> {
public final Iterator<K> iterator() { return new KeyIterator(); }
}
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
//HashIterator
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {
} while (index < t.length && (next = t[index++]) == null);
//index<哈希数组的长度且通过index取出的节点不为空
//next=一个不为空的在table中的第一个节点（元素）
}
}
//是否有下一个节点
public final boolean hasNext() {
return next != null;
}
//获取下一个节点
final Node<K,V> nextNode() {
Node<K,V>[] t;//定义一个变量
Node<K,V> e = next;//第一个节点元素
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
//语句拆分(next = (current = e).next) == null
//1、将当前节点current=e(next)这个next为第一个待取出的节点（初始化的时候设置过）
//2、看看next.next还有没得元素（链表或者红黑树）
//3、next=next.next
//4、判断第三步的next==null
if ((next = (current = e).next) == null && (t = table) != null) {
//由构造函数代码index在初始化的时候index为table索引第一个不为空的节点的索引位子(0开始）index取完第一个节点已经+1操作。那么这里的next=t[index++]就是原next的下一个节点
do {
} while (index < t.length && (next = t[index++]) == null);
//这里然后根据index取出next节点
}
//如果next.next不为空，那么下一个节点就设置为next.next这里就巧妙的形成了链表/红黑树的遍历（一层一层进入链表/红黑树直到next为空为止）
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
使用
HashMap map1 = new HashMap();
map1.put("a","b");
map1.put("a1","b");
map1.put("a2","b");
map1.put("a3","b");
map1.put("a4","b");
Set<String> ketSet = map1.keySet();//获取Set实例
Iterator iterable = ketSet.iterator();//拿到迭代器--这个迭代器实现为KeyIterator
while (iterable.hasNext()){
System.out.println(iterable.next());
}
参考：
http://www.importnew.com/7099.html
http://www.importnew.com/23164.html
https://my.oschina.net/xianggao/blog/393990
1）介绍HashMap：
按照特性来说明一下：储存的是键值对，线程不安全，非Synchronied，储存的比较快，能够接受null。
按照工作原理来叙述一下：Map的put（key，value）来储存元素，通过get（key）来得到value值，通过hash算法来计算hascode值，用hashCode标识Entry在bucket中存储的位置，储存结构就算哈希表。
“2）你知道HashMap的工作原理吗？” “你知道HashMap的get()方法的工作原理吗？”
“HashMap是基于hashing的原理，我们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。
当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。
”这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，作为Map.Entry。
这一点有助于理解获取对象的逻辑。如果你没有意识到这一点，或者错误的认为仅仅只在bucket中存储值的话，你将不会回答如何从HashMap中获取对象的逻辑。这个答案相当的正确，也显示出面试者确实知道hashing以及HashMap的工作原理。
put方法实现思路：
判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
②根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
③如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等，相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。
④如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
⑤如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
⑥接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
⑦如果在遍历过程中找到 key 相同时直接退出遍历。
⑧如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。
⑨最后判断是否需要进行扩容。
get 方法实现思路：
- 首先将 key hash 之后取得所定位的桶。
- 如果桶为空则直接返回 null 。
- 否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
- 如果第一个不匹配，则判断它的下一个是红黑树还是链表。
- 红黑树就按照树的查找方式返回值。
- 不然就按照链表的方式遍历匹配返回值。
从这两个核心方法（get/put）可以看出 1.8 中对大链表做了优化，修改为红黑树之后查询效率直接提高到了 O(logn)。
3）提问：两个hashcode相同的时候会发生说明？
hashcode相同，bucket的位置会相同，也就是说会发生碰撞，哈希表中的结构其实有链表（LinkedList），这种冲突通过将元素储存到LinkedList中，解决碰撞。储存顺序是放在表头。
4）如果两个键的hashcode相同，如何获取值对象？
如果两个键的hashcode相同，即找到bucket位置之后，我们通过key.equals（）找到链表LinkedList中正确的节点，最终找到要找的值对象。
一些优秀的开发者会指出使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性使得能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择。
5）如果HashMap的大小超过了负载因子(load factor)定义的容量？怎么办？
HashMap里面默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来HashMap大小的两倍的bucket数组，来重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因为它调用hash方法找到新的bucket位置。
6）重新调整HashMap大小的话会出现什么问题？
多线程情况下会出现竞争问题，因为你在调节的时候，LinkedList储存是按照顺序储存，调节的时候回将原来最先储存的元素（也就是最下面的）遍历，多线程就好试图重新调整，这个时候就会出现死循环。
当多线程的情况下，可能产生条件竞争(race condition)。
当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。
7）HashMap在并发执行put操作，会引起死循环，为什么？
是因为多线程会导致hashmap的node链表形成环形链表，一旦形成环形链表，node 的next节点永远不为空，就会产生死循环获取node。从而导致CPU利用率接近100%。
8）为什么String, Interger这样的wrapper类适合作为键？
因为他们一般不是不可变的，源码上面final，使用不可变类，而且重写了equals和hashcode方法，避免了键值对改写。提高HashMap性能。
String, Interger这样的wrapper类作为HashMap的键是再适合不过了，而且String最为常用。因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。
9）使用CocurrentHashMap代替Hashtable？
可以，但是Hashtable提供的线程更加安全。
Hashtable是synchronized的，但是ConcurrentHashMap同步性能更好，因为它仅仅根据同步级别对map的一部分进行上锁。ConcurrentHashMap当然可以代替HashTable，但是HashTable提供更强的线程安全性。
10）hashing的概念
散列法（Hashing）或哈希法是一种将字符组成的字符串转换为固定长度（一般是更短长度）的数值或索引值的方法，称为散列法，也叫哈希法。由于通过更短的哈希值比用原始值进行数据库搜索更快，这种方法一般用来在数据库中建立索引并进行搜索，同时还用在各种解密算法中。
11）扩展：为什么equals()方法要重写？
判断两个对象在逻辑上是否相等，如根据类的成员变量来判断两个类的实例是否相等，而继承Object中的equals方法只能判断两个引用变量是否是同一个对象。这样我们往往需要重写equals()方法。
我们向一个没有重复对象的集合中添加元素时，集合中存放的往往是对象，我们需要先判断集合中是否存在已知对象，这样就必须重写equals方法。
怎样重写equals()方法？
重写equals方法的注意点：
1、自反性：对于任何非空引用x，x.equals(x)应该返回true。
2、对称性：对于任何引用x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。
3、传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。
4、一致性：如果x和y引用的对象没有发生变化，那么反复调用x.equals(y)应该返回同样的结果。
5、非空性：对于任意非空引用x，x.equals(null)应该返回false。
扫一扫
329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
