目录
成员变量
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
/**
* 默认初始容量 - 必须是 2 的幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
最大容量，在两个带参数的构造函数隐式指定更高值时使用。 必须是 2 的幂 <= 1<<30。
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 在构造函数中未指定时使用的负载因子。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
使用树而不是列表的 bin 计数阈值。 将元素添加到至少具有这么多节点的 bin 时，bin 会转换为树。 该值必须大于 2 且至少应为 8，以与树移除中关于在收缩时转换回普通 bin 的假设相匹配。
*/
static final int TREEIFY_THRESHOLD = 8;
/**
在调整大小操作期间取消（拆分）bin 的 bin 计数阈值。 应小于 TREEIFY_THRESHOLD，最多为 6 以在移除下进行收缩检测。
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
可以将 bin 树化的最小表容量。 （否则，如果 bin 中的节点过多，则表将调整大小。）应至少为 4 * TREEIFY_THRESHOLD，以避免调整大小和树化阈值之间发生冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
static class Node<K,V> implements Map.Entry<K,V> {
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; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
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;
}
}
...
/**
表，在第一次使用时初始化，并根据需要调整大小。 分配时，长度始终是 2 的幂。 （我们还在某些操作中容忍长度为零，以允许当前不需要的引导机制。）
*/
transient Node<K,V>[] tab[i = (n - 1) & hash];
/**
保存缓存的 entrySet()。 请注意，AbstractMap 字段用于 keySet() 和 values()。
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 此映射中包含的键值映射数。
*/
transient int size;
/**
* 该 HashMap 被结构修改的次数 结构修改是更改 HashMap 中的映射数量或以其他方式修改其内部结构（例如，重新散列）的那些。 该字段用于在 HashMap 的 Collection-views 上创建迭代器快速失败。 （请参阅 ConcurrentModificationException）。
*/
transient int modCount;
/**
* 要调整大小的下一个大小值（容量 * 负载因子）。
*/
int threshold;
/**
哈希表的负载因子。
*/
final float loadFactor;hashmap底层基础结构即数组table，每个位置的起始为一个Node，以该Node为开头又可以生产单链表结构或者红黑树结构。
构造函数
/* ---------------- Public operations -------------- */
/**
构造一个具有指定初始容量和负载因子的空HashMap 。
参数：
initialCapacity – 初始容量
loadFactor – 负载因子
抛出：
IllegalArgumentException – 如果初始容量为负或负载因子为非正
*/
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);
}
/**
构造一个具有指定初始容量和默认负载因子 (0.75) 的空HashMap 。
参数：
initialCapacity – 初始容量。
抛出：
IllegalArgumentException – 如果初始容量为负。
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
构造一个具有默认初始容量 (16) 和默认负载因子 (0.75) 的空HashMap 。
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
使用与指定Map相同的映射构造一个新的HashMap 。
HashMap是使用默认负载因子 (0.75) 创建的，初始容量足以在指定的Map 中保存映射。
参数：
m – 要在此地图中放置其映射的地图
抛出：
NullPointerException – 如果指定的地图为空
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
其中默认构造参数就采取默认负载因子0.75。其中比较关键的复制构造函数是以容量和负载因子为形参的复制构造函数，这里涉及到threshold值的赋值：
/**
* 是返回大于输入参数且最近的2的整数次幂的数
*/
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;
}这里例如cap为10，返回的就是16。
而以map为形参的构造方法涉及到 转换方法：
/**
* Implements Map.putAll and Map constructor.
*
实现 Map.putAll 和 Map 构造函数。
参数：
m——地图
evict – 最初构造此映射时为 false，否则为 true（中继到方法 afterNodeInsertion）
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize(); //涉及到扩容
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}这里主要涉及到对比当前map的threshhold以及形参size，会考虑以此是否扩容，然后再对于形参map的每个元素以此放到当前map中。
添加/修改
/*
将指定值与此映射中的指定键相关联。 如果映射先前包含键的映射，则旧值将被替换。
参数：
key – 与指定值关联的键
value – 要与指定键关联的值
返回：
与key关联的先前值，如果没有key 的映射，则为null 。 （ null返回也可以指示映射先前将null与key相关联。）
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
计算 key.hashCode() 并将散列的较高位（异或）传播到较低位。 由于该表使用二次幂掩码，因此仅在当前掩码之上位变化的散列集将始终发生冲突。 （众所周知的例子是在小表中保存连续整数的浮点键集。）所以我们应用了一种向下传播高位影响的变换。 位扩展的速度、效用和质量之间存在权衡。 因为许多常见的哈希集已经合理分布（因此不会从传播中受益），并且因为我们使用树来处理 bin 中的大量冲突，所以我们只是以最便宜的方式对一些移位的位进行异或以减少系统损失，以及合并最高位的影响，否则由于表边界而永远不会在索引计算中使用。
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
实现 Map.put 和相关方法。
参数：
hash – 密钥的散列
钥匙——钥匙
value – 要放置的值
onlyIfAbsent – 如果为真，则不更改现有值
evict – 如果为 false，则表处于创建模式。
返回：
以前的值，如果没有，则为 null
*/
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;
//如果当前tab为空，则需要初始化
if ((tab = table) == null || (n = tab.length) == 0)
//那么直接去扩容哈希表，并且将扩容后的哈希桶长度赋值给n
n = (tab = resize()).length;
//如果当前index的节点是空的，表示没有发生哈希碰撞。 直接构建一个新节点Node，挂载在index处即可。
//这里再啰嗦一下，index 是利用 哈希值 & 哈希桶的长度-1，替代模运算
if ((p = tab[i = (n - 1) & hash]) == null) //位操作代替取余提高性能
tab[i] = newNode(hash, key, value, null);
else {//发生hash冲突
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);
//追加后链表长度大于等于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;
}
}
//如果e不是null，说明有要覆盖的节点
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; //覆盖
//这是一个空实现的函数，用作LinkedHashMap重写使用。
afterNodeAccess(e);
return oldValue;
}
}
//如果执行到了这里，说明插入了一个新的节点，所以会修改modCount，以及返回null。
//修改modCount
++modCount;
if (++size > threshold) //大于阈值则进行再hash扩容
resize();
//这是一个空实现的函数，用作LinkedHashMap重写使用。
afterNodeInsertion(evict);
return null;
}
这里值得注意的是对于添加来的key，需要通过hash方法计算散列值，得到其在数组中的下表。从这里的散列方法看出对于特殊情况null即散列到0位置处，而对于其他对象，计算器hashcode与自身的高位16位的异或，其用高位的16位而不是低位的16位是因为这样能使得到散列值更加随机，即让数据分布更加平衡。而为什么用异或^而不是&或者|呢？这是因为&和|都会使得结果偏向0或者1 ,并不是均匀的概念,所以用^。
第一次put时由于table为空所以需要扩容，扩容的条件以及策略将在后续详细说明。然后考虑到table的size的原因，hash方法计算的位置需要取余后才能放到正确的位置。考虑到table的大小一定为2的幂次方时，有hash&table.length==hash%table.length。找到table数组中的正确位置后，就需要查看当前位置是否已经有了元素，如果没有则直接放入该节点，如果有的话则说明发生了hash冲突，需要解决。
解决冲突的策略：
-
首先判断待插入节点和当前位置的第一个节点的key值是否相同，如相同则两者本就应该是同一个节点，后续更新value即可。
-
若key值不相同，则表明的确产生了冲突。这里分当前节点所处的结构是红黑树还是链表来分别处理：
-
红黑树的话：则插入到红黑树中，再调整红黑树结构。
-
链表的话：从当前点遍历链表，若在遍历完之前找到相同的key值的node，后续更新该node的value即可。如果遍历完后没有找到就插入到当前链表中的最后，然后检查该链表长度是否大于等于8，如果是则需要将链表转为红黑树结构。
-
-
然后判断当前节点的个数，若大于threshold，则需要进行扩容。
这边也可以引申到一个问题HashMap是先插入还是先扩容：HashMap初始化后首次插入数据时，先发生resize扩容再插入数据，之后每当插入的数据个数达到threshold时就会发生resize，此时是先插入数据再resize。
扩容 (resize方法)
final Node<K,V>[] resize() {
//oldTab 为当前表的哈希桶
Node<K,V>[] oldTab = table
//当前的哈希桶的容量length
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前阈值
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//当前容量已经到达上限
if (oldCap >= MAXIMUM_CAPACITY) {
//则设置阈值是2的31次方-1
threshold = Integer.MAX_VALUE;
//同时返回当前的哈希桶，不再扩容
return oldTab;
}//否则新的容量为旧的容量的两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果旧的容量大于等于默认初始容量16
//那么新的阈值也等于旧的阈值的两倍
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 = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新的阈值为默认容量16 * 默认加载因子0.75f = 12
}
if (newThr == 0) {//如果新的阈值是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) {
//取出当前的节点 e
Node<K,V> e;
//如果当前桶中有元素,则将链表赋值给e
if ((e = oldTab[j]) != null) {
//将原哈希桶置空以便GC
oldTab[j] = null;
//如果当前链表中就一个元素，（没有发生哈希碰撞）
if (e.next == null)
//直接将这个元素放置在新的哈希桶里。
//注意这里取下标 是用 哈希值 与 桶的长度-1 。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高
newTab[e.hash & (newCap - 1)] = e;
//如果发生过哈希碰撞 ,而且是节点数超过8个，转化成了红黑树（暂且不谈 避免过于复杂， 后续专门研究一下红黑树）
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量
//低位链表的头结点、尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表的头节点、尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//这里又是一个利用位运算 代替常规运算的高效点： 利用哈希值 与 旧的容量，可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位
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);
//将低位链表存放在原index处，
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将高位链表存放在新index处
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}在该方法中，首先是根据不同情况获取目前合适的capacity和threshold。然后根据新的capacity构建新的table数组newTab，容量为原来的两倍(正常情况下)。
在数据转移过程中，需要遍历旧的oldTable，有几点需要说明：
-
对每一个节点，保存局部变量后就将其在原table中置null，以便后续gc。
-
如果原table该位置就一个node，则直接根据hash&(newCap-1)进行转移；如果存在冲突，看该节点是否为红黑树节点，若为红黑树节点，有对应的红黑树处理策略，这里暂且不详谈；对于链表的结构需要这样考虑：因为目前newTab与OldTab来比原来扩容了，这里假设原table位置为low位，则扩容后的位置即high=low+oldCap。这里对于链表的每个元素根据其hash&OldCap是否为0作为筛选点来将链表的各个元素散列到low位或hig位中，等于将链表一分为二。
查询
/**
返回指定键映射到的值，如果此映射不包含键的映射，则返回null 。
更正式地说，如果此映射包含从键k到值v的映射，使得(key==null ? k==null : key.equals(k)) ，则此方法返回v ； 否则返回null 。 （最多可以有一个这样的映射。）
返回值null不一定表示映射不包含键的映射； 地图也有可能将键显式映射到null 。 containsKey操作可用于区分这两种情况。
也可以看看：
put(Object, Object)
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
实现 Map.get 和相关方法。
参数：
hash – 密钥的散列
钥匙——钥匙
返回：
节点，如果没有，则为 null
*/
final Node<K,V> getNode(int hash, Object 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 && // always check first node
((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;
}这里其实主要涉及到的就是红黑树和链表的查询过程。链表查询遍历即可。红黑树的查询原理其实就是二叉查找法。
删除
/**
如果存在，则从此映射中删除指定键的映射。
参数：
key – 要从映射中删除其映射的键
返回：
与key关联的先前值，如果没有key 的映射，则为null 。 （ null返回也可以指示映射先前将null与key相关联。）
*/
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
实现 Map.remove 和相关方法。
参数：
hash – 密钥的散列
钥匙——钥匙
value – 如果 matchValue 匹配的值，否则忽略
matchValue – 如果为真，则仅在值相等时删除
可移动 - 如果为false，则在删除时不移动其他节点
返回：
节点，如果没有，则为 null
*/
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;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p; //找到，第一个节点就是
else if ((e = p.next) != null) { //没找到，但有hash冲突，需要在链表或红黑树结构中继续找
if (p instanceof TreeNode)
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;
} while ((e = e.next) != null);
}
}
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;
else //中间节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}这里底层逻辑关键点仍在于链表的节点删除和红黑树的节点删除，链表删除较为简单，红黑树节点的删除这里不详述了。
序列化/反序列化
注意到table、size等元素都是transient的，所以自定义序列化反序列化方法在所难免。
/**
将HashMap实例的状态保存到一个流中（即序列化它）。
*/
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
int buckets = capacity(); //table.length/threshold/16
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();//将当前类的非静态和非瞬态字段写入此流
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
// Called only from writeObject, to ensure compatible ordering.
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K,V>[] tab;
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) { //这里有个移位，是否只考虑到结构为链表的时候，是否序列化前需要把红黑树转为链表
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
/**
从流中重建此映射（即反序列化它）。
参数：
s – 流
抛出：
ClassNotFoundException – 如果找不到序列化对象的类
IOException – 如果发生 I/O 错误
*/
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
// Check Map.Entry[].class since it's the nearest public type to
// what we're actually creating.
SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
这里主要说明序列化时的一个点，看源代码中貌似只考虑了每个节点所处的结构都是在链表中，难道是因为序列化前需要把所有红黑树结构先转化为链表，然后反序列化后再转换回来？这里目前我不得而知，后续确定而再更新。
与JDK1.7的比较
成员变量
/**
表未膨胀时共享的空表实例。
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
/**
* 表格，根据需要调整大小。 长度必须始终是 2 的幂。
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
每当条目中的值被 HashMap 中已经存在的键 k 的 put(k,v) 调用覆盖时，就会调用此方法。
*/
void recordAccess(HashMap<K,V> m) {
}
/**
*每当从表中删除条目时都会调用此方法。
*/
void recordRemoval(HashMap<K,V> m) {
}
}这里主要的变化点在于底层数组中的节点名1.7中为Entry，1.8中为Node。
构造函数
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;
threshold = initialCapacity; //差异
init();
}
/**
使用与指定Map相同的映射构造一个新的HashMap 。 HashMap是使用默认负载因子 (0.75) 创建的，初始容量足以在指定的Map 中保存映射。
参数：
m – 要在此地图中放置其映射的地图
抛出：
NullPointerException – 如果指定的地图为空
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
/**
* 膨胀table数组
*/
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
/**
初始化散列掩码值。 我们推迟初始化，直到我们真正需要它。
*/
final boolean initHashSeedAsNeeded(int capacity) {
boolean currentAltHashing = hashSeed != 0;
boolean useAltHashing = sun.misc.VM.isBooted() && //虚拟机真正启动时
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean switching = currentAltHashing ^ useAltHashing;
if (switching) {
hashSeed = useAltHashing
? sun.misc.Hashing.randomHashSeed(this)
: 0;
}
return switching;
}
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
/**
构造函数和伪构造函数（clone、readObject）使用此方法而不是放置。 它不会调整表的大小、检查共同修改等。它调用 createEntry 而不是 addEntry。
*/
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key);
int i = indexFor(hash, table.length);
/**
* Look for preexisting entry for key. This will never happen for
* clone or deserialize. It will only happen for construction if the
* input Map is a sorted map whose ordering is inconsistent w/ equals.
*/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
createEntry(hash, key, value, i);
}
/**
与 addEntry 类似，只是在创建条目作为 Map 构造或“伪构造”（克隆、反序列化）的一部分时使用此版本。 此版本无需担心调整表格大小。 子类覆盖它以改变 HashMap(Map)、clone 和 readObject 的行为
*/
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++;
}jdk1.7中threshold直接等于初始设置容量。在1.7中首先就会进行一个inflateTable操作，将table数组进行扩容，更新capacity和threshold，其它类似。
添加/修改
/**
将指定值与此映射中的指定键相关联。 如果映射先前包含键的映射，则旧值将被替换。
参数：
key – 与指定值关联的键
value – 要与指定键关联的值
返回：
与key关联的先前值，如果没有key 的映射，则为null 。 （ null返回也可以指示映射先前将null与key相关联。）
*/
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold); //膨胀：扩容
}
if (key == null)
return putForNullKey(value);
int hash = hash(key); //这里也有差异
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //找到即更新
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i); //新增
return null;
}
/**
将具有指定键、值和哈希码的新条目添加到指定存储桶。 如果合适，此方法负责调整表的大小。 子类覆盖它以改变 put 方法的行为。
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
/**
将此映射的内容重新散列到具有更大容量的新数组中。 当此映射中的键数达到其阈值时，将自动调用此方法。 如果当前容量为 MAXIMUM_CAPACITY，则此方法不会调整地图大小，而是将阈值设置为 Integer.MAX_VALUE。 这具有防止将来调用的效果。
参数：
newCapacity – 新容量，必须是 2 的幂； 必须大于当前容量，除非当前容量为 MAXIMUM_CAPACITY（在这种情况下，值无关紧要）。
*/
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity)); //转移
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
由此看出1.7中对链表的长度没有限制，碰撞次数过多时会降低查询，插入性能。
507
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
