HashMap概述
在JDK1.6中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的都存储在一个链表里；但是当位于一个数组中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低；
所以，JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值8时，将链表转换为红黑树，这样大大减少了查找时间。
原本Map.Entry接口的实现类Entry改名为了Node。转化为红黑树时改用另一种实现TreeNode；
JDK 1.7中的HashMap
底层结构
底层是一个Entry<K,V>类型的数组table，数组中的每一个位置被当成一个桶；用拉链法解决哈希冲突；
transient Entry[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
int hash; //hashCode
final K key; //Key
V value; //Value
Entry<K,V> next;
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();
//key相等，而且value相等
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();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}拉链法解决哈希冲突
HashMap<String, String> map = new HashMap<>();
map.put("K1", "V1");
map.put("K2", "V2");
map.put("K3", "V3"); 1.新建一个 HashMap，默认大小为 16；
2.插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3；
3.插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6；
4.插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面；
应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部；
查找需要分成两步进行：1.计算键值对所在的桶；2.在链表上顺序查找，时间复杂度显然和链表的长度成正比；
put方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 键为 null 单独处理
if (key == null)
return putForNullKey(value);
// 计算hash值
int hash = hash(key);
// 确定桶下标
int i = indexFor(hash, table.length);
// 先找出是否已经存在键位 key 的键值对，如果存在的话就更新这个键值对的值为 value
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;
}HashMap 允许插入键位 null 的键值对，因为无法调用 null 的 hashCode()，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对；
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部；
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);
}
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++;
}Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}确定桶下标
很多操作都需要先确定一个键值对所在的桶下标；
int hash = hash(key);
int i = indexFor(hash, table.length);计算hash值
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}取模
令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：x : 00010000
x-1 : 00001111y : 10110010
x-1 : 00001111
y&(x-1) : 00000010x : 00010000
y : 10110010
y%x : 00000010确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的幂次方，那么就可以将这个操作转换位位运算。
扩容
设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
和扩容相关的参数主要有：capacity、size、threshold 和 load_factor；
| 参数 | 含义 |
|---|---|
| capacity | table 的容量大小，默认为 16，需要注意的是 capacity 必须保证为 2 的次方。 |
| size | table 的实际使用量。 |
| threshold | size 的临界值，size 必须小于 threshold，如果大于等于，就必须进行扩容操作。 |
| load_factor | table 能够使用的比例，threshold = capacity * load_factor。 |
static final int DEFAULT_INITIAL_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry[] table;
transient int size;
int threshold;
final float loadFactor;
transient int modCount;从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍；
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把旧 table 的所有键值对重新插入新的 table 中，因此这一步是很费时的；
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);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}扩容-重新计算桶下标
在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作；假设原数组长度 capacity 为 8，扩容之后 new capacity 为 16：
capacity : 00010000
new capacity : 00100000对于一个 Key，它的 hash 如果在第 6 位上为 0，那么取模得到的结果和之前一样；如果为 1，那么得到的结果为原来的结果 + 8；
扩容-计算数组容量
HashMap 构造函数允许用户传入的容量不是 2 的幂次方，因为它可以自动地将传入的容量转换为 2 的幂次方；先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
mask |= mask >> 1 11011000
mask |= mask >> 2 11111100
mask |= mask >> 4 11111111mask+1 是大于原始数字的最小的 2 幂次方；
num 10010000
mask+1 100000000以下是 HashMap 中计算数组容量的代码：
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;
}JDK 1.8的HashMap
HashMap的属性
/**
* 默认的初始容量(容量为HashMap中桶的数目)是16，且实际容量必须是2的整数次幂
* 桶的个数不能太多或太少；如果太少，很容易触发扩容，如果太多，遍历哈希表会比较慢
*
* 为什么必须是2的整数次幂？
* 如果length是2的次幂 则length-1转化为二进制必定是11111……的形式，这样对hashcode的操作效率会非常的快，而且空间不浪费
* 如果length不是2的次幂，比如length为15，则length-1为14，对应的二进制为1110，hashcode的最后一位都为0
* 所以，0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，
* 这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！这样就会造成空间的浪费
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16
/**
* 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认装填因子0.75，如果当前键值对个数 >= HashMap最大容量*装填因子，就会触发扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* Entry链表最大长度
*
* 如果哈希函数不合理，即使扩容也无法减少箱子中链表的长度，
* 因此JDK1.8 的处理方案是当Entry链表太长时，转换成红黑树。这个值表示当某个桶中，链表长度大于8时，会转化成树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* JDK1.8 新加，当桶中节点数小于该长度，将红黑树转为链表存储；
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。
* 这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化
*
* 桶可能被转化为树形结构的最小容量。当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突。
* 应该至少4*TREEIFY_THRESHOLD，即64，来避免扩容和树形结构化之间的冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64;HashMap的内部类Node
/**
* JDK1.6用Entry描述键值对，JDK1.8中用Node代替Entry
*/
static class Node<K, V> implements Map.Entry<K, V> {
final int hash; //hash存储key的hashCode
final K key; //final:一个键值对的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;
}
}HashMap的构造函数
//initialCapacity：初始大小
//loadFactor：装载因子
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); //返回一个大于等于initialCapacity的2次幂
}
//返回大于等于cap的最小的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;
}参考：https://www.cnblogs.com/loading4/p/6239441.html
https://blog.csdn.net/fan2012huan/article/details/51097331
看完上面可能会感到奇怪的是：为啥是将2的整数幂的数赋给threshold？threshold这个成员变量是阈值，决定了是否要将散列表再散列。它的值应该是：capacity * load factor才对的。其实这里仅仅是一个初始化，当创建哈希表的时候，它会重新赋值的，在resize函数里；
put方法
public V put(K key, V value) {
//以key计算hash值
return putVal(hash(key), key, value, false, true);
}static final int hash(Object key) {
int h;
//key的hashCode与key.hashCode的高16位做异或操作
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}为什么要这样干呢？？我们一般来说直接将key作为哈希值不就好了吗，做异或运算是干嘛用的？我们可以看看putVal方法；
我们是根据key的哈希值来保存在散列表中的，我们表默认的初始容量是16，要放到散列表中，就是0-15的位置上。也就是tab[i = (n - 1) & hash]。可以发现的是：在做&运算的时候，仅仅是后4位有效~那如果我们key的哈希值高位变化很大，低位变化很小。直接拿过去做&运算，这就会导致计算出来的Hash值相同的很多。
而设计者将key的哈希值的高位也做了运算(与高16位做异或运算，使得在做&运算时，此时的低位实际上是高位与低位的结合)，这就增加了随机性，减少了碰撞冲突的可能性；
这里在原生hashCode的基础上做了一次与高16位相异或的处理，这样做的目的是将哈希值的高位纳入到取余运算中来，防止由于低位相同造成的频繁冲突的情况;
-------------------------------------------------
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//1.初始化，当散列表为null时，调用rsize函数初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//2.bin为null，初始化第一个节点
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))))
//hashCode和key都相等，那么记录下原先的值
e = p;
else if (p instanceof TreeNode)
//红黑树结构，调用树的插入函数
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//链表结构，找到key相等的那个节点，更新value，退出循环
//如果没有找到key相等的节点，则在链表尾部插入，为什么要从表尾插入
//因为HashMap需要判断链表中元素的个数以决定是否将其转为红黑树。
//插入后，如果节点数量大于TREEIFY_THRESHOLD，则转换为红黑树
//bin不为空，且与链表头不相同(==或equals)
//3.
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)
//onlyIfAbsent参数如果为true，那么对于已经存在的key，将不替换其值
e.value = value;
//空实现，为LinkedHashMap预留
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//4.
if (++size > threshold)
resize();
//空实现，为LinkedHashMap预留
afterNodeInsertion(evict);
return null;
}size
HashMap中维护有一个字段size记录当前元素的个数，从上面putVal方法源码(4)中可以看到其改变方式；
transient int size;get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}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) {
//计算出来的hash值在散列表上
//如果在桶的首位上就能直接找到，那就直接返回
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;
}resize方法
当散列表元素大于capacity * load factor的时候也是调用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;
//原table不为null，
if (oldCap > 0) {
//MAXIMUM_CAPACITY取1 << 30，即table数组的大小，如果已到达此值，那么无需扩容
//即，如果旧的容量比最大容量还要大，那就不能再散列了，直接返回旧的散列表
if (oldCap >= MAXIMUM_CAPACITY) {
//threshold，CAPACITY乘以负载因子即扩容的临界值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//没有达到最大值，两倍扩容
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
//如果旧容量<=0，而且旧阈值>0，散列表的新容量设置为老散列表扩容的阈值
newCap = oldThr;
else {
//初始化，默认大小为16
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
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;
}
}
}
}
}
return newTab;
}remove方法
public V remove(Object key) {
Node<K,V> e;
//计算key的hash值来删除
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}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;
//桶不为空，要删除的hash值也存在
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) {
//不是首位，就得去链表或红黑树里找
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);
}
}
//找到了对应的节点，且value对应的上，那就得分三种情况去删除：链表，红黑树，首位
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;
}containsValue函数
查询是否包含特定的key较为简单，等同于一次get操作，而查询value则不是:
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}HashMap和HashTable的异同
HashMap是基于哈希表和Map接口实现的；不保证有序；与HashTable最大的区别在于，非线程安全和允许null作为key和value；
如果需要同步的HashMap，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap；
当初始容量*装载因子<哈希表的容量时，哈希表会再散列，桶数会*2；
初始容量太高或装载因子太低都会影响遍历的性能；装载因子默认是0.75，设置高了虽然会减少空间浪费，但遍历的开销会增大；在设置的时候，最后初始容量*装载因子=需要的容量；
- HashTable 是同步的，它使用了 synchronized 来进行同步。它也是线程安全的，多个线程可以共享同一个 HashTable。HashMap 不是同步的，但是可以使用 ConcurrentHashMap，它是 HashTable 的替代，而且比 HashTable 可扩展性更好。
- HashMap 可以插入键为 null 的 Entry。
- HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
- 由于 Hashtable 是线程安全的也是 synchronized，所以在单线程环境下它比 HashMap 要慢。
- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
HashTable的源码阅读：https://blog.csdn.net/panweiwei1994/article/details/77427010
https://blog.csdn.net/panweiwei1994/article/details/77428710
参考
https://blog.csdn.net/panweiwei1994/article/details/76555359https://zhuanlan.zhihu.com/p/28216267
https://blog.csdn.net/fan2012huan/article/details/51097331
https://www.cnblogs.com/chinajava/p/5808416.html
https://zhongfucheng.bitcron.com/post/javaji-chu/hashmapjiu-shi-zhe-yao-jian-dan-yuan-ma-pou-xi
1278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
