HashMap,你知道多少？
一、前言
HashMap在面试中是个火热的话题，那么你能应付自如吗？下面抛出几个问题看你是否知道，如果知道那么本文对于你来说就不值一提了。
- HashMap的内部数据结构是什么？
- HashMap扩容机制时什么？什么时候扩容？
- HashMap其长度有什么特征？为什么是这样？
- HashMap为什么线程不安全？并发的场景会出现什么的情况？
本文是基于JDK1.7.0_79版本进行研究的。
二、源码解读
1、类的继承关系
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
其中继承了AbstractMap抽象类，别小看了这个抽象类哦，它实现了Map接口的许多重要方法，大大减少了实现此接口的工作量。
2、属性解析
2.1、capacity：容量
- DEFAULT_INITIAL_CAPACITY：默认的初始容量-必须是2的幂。为什么呢？先留个疑问在这
/** * The default initial capacity - MUST be a power of two. */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
- MAXIMUM_CAPACITY：最大容量为2^30。
2.2 threshold：阈值
/** * The next size value at which to resize (capacity * load factor). * @serial */ // If table == EMPTY_TABLE then this is the initial capacity at which the // table will be created when inflated. int threshold;
从上面注释可以看出， 它的值是由容量和加载因子决定的。
2.3 loadFactor：加载因子，默认为0.75
/** * The load factor used when none specified in constructor. */ static final float DEFAULT_LOAD_FACTOR = 0.75f;
2.4 size：键值对长度
/** * The number of key-value mappings contained in this map. */ transient int size;
2.5 modCount：修改内部结构的次数
transient int modCount;
上面五个属性字段都很重要， 后面再分析体现其重要。
3、底层数据结构
static final Entry<?,?>[] EMPTY_TABLE = {}; /** * The table, resized as necessary. Length MUST Always be a power of two. * 这里也强调扩容时，长度必须是2的指数次幂 */ transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
Entry内部结构如下：
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next; int hash; }
经分析后其数据结构为数组+链表的形式，展示图如下：
4、重要函数
4.1 构造函数
总共有四个构造函数， 主要分析含有两个参数的构造函数：
其实这个构造函数也主要是初始化加载因子和阈值。（可能1.7的其他版本会有点不一样，会在构造函数中初始化table）
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(); }
4.2 put()函数
public V put(K key, V value) { // 1 如果table为空则需要初始化 if (table == EMPTY_TABLE) { inflateTable(threshold); } // 2 如果key为空,则单独处理 if (key == null) return putForNullKey(value); // 3 根据key获取hash值 int hash = hash(key); // 4 根据hash值和长度求取索引值。 int i = indexFor(hash, table.length); // 5 根据索引值获取数组下的链表进行遍历，判断元素是否存在相同的key 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; } } // 6 如果不存在重复的key, 则需要创建新的Entry，然后添加至链表中。 // 先将修改次数加一 modCount++; addEntry(hash, key, value, i); return null; }
- 第一步：当table还没有初始化时，看下inflateTable()函数做了什么操作。
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); }
- 其中容量是根据toSize取第一个大于它的2的指数次幂的值， 如下，其中highestOneBit函数是返回其最高位的权值，用的最巧的就是(number - 1) << 1 其实就是取number的倍数， 但综合使用却能取得第一个大于等于该值的2的指数次幂。（用的牛逼）
private static int roundUpToPowerOf2(int number) { // assert number >= 0 : "number must be non-negative"; return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1; }
- 接着看put函数的第二步：当key为null时，会取数组下标为0的位置进行链表遍历，如果存在key=null，则替换值并返回。否则进入第六步（注意：索引值依然指定是0）。
private V putForNullKey(V value) { // 取数组下标为0的链表 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++; // 注意：索引值依然指定是0 addEntry(0, null, value, 0); return null; }
- 第三步：根据key的hashCode求取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); }
- 第四步：根据hash值和底层数组的长度计算索引下标。因为数组的长度是2的幂，所以h & (length-1)运算其实就是h与（length-1）的取模运算。不得不服啊，将计算运用的如此高效。
static int indexFor(int h, int length) { // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2"; return h & (length-1); }
找个数验证下：
- 第五步是验证是否有重复key,如果有则替换新值然后返回，源码很详细了就不再做解释了。
- 第六步：是将值添加到entry数组中，详细看下addEntry()函数。首先根据size和阈值判断是否需要扩容（进行两倍扩容），如果需要扩容则先扩容重新计算索引，则创建新的元素添加至数组。
void addEntry(int hash, K key, V value, int bucketIndex) { // 如果长度大于阈值，则需要进行扩容 if ((size >= threshold) && (null != table[bucketIndex])) { // 进行2倍扩容 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++; }
其中扩容机制resize()函数需要重点捞出来晒下：newCapacity = 2 * length，理论上会进行两倍扩容但会根最大容量进行对比取最小， 创建新数组然后将就数组中的值拷贝至新数组（其中会重新计算索引下标），然后再赋值给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, initHashSeedAsNeeded(newCapacity)); table = newTable; // 重新计算阈值 threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }
接着看transfer()函数，多注意这个函数中循环的内容
void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { // 定一个next 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; } } }
通过上面分析，其实put函数还是简单的，不是很绕。那么能从其中找到开头的第二和第三个问题的答案吗？下面总结下顺便回答下这两个问题：
1、数组长度不管是初始化还是扩容时，都始终保持是2的指数次幂。为什么呢？下面我的分析：
- 能使元素均匀分布，增大空间利用率。put值时需要根据key的hash值与长度进行取模运算得到索引下标，如果是2的幂，那么length一定是偶数，则length-1一定是奇数，那么它对应的二进制的最后一位一定是1，所以它能保证h&（length-1）既能到奇数也能得到偶数，这样保证了散列的均匀性。相反如果不是2的幂，那么length-1可能是偶数，这样h&(length-1)得到的都是偶数，就会浪费一半的空间了。
- 运算效率高效。位运算比%运算高效。
2、重复key的值会被新值替换，允许key为空且统一放在下标为0的链表上。
3、当size大于等于阈值（容量*加载因子）时，会进行扩容。扩容机制是：扩容量为原来数组长度的两倍，根据扩容量创建新数组然后进行数组拷贝，新元素落位需要重新计算索引下标。扩容后，阈值需要重新计算，需要插入的元素落位的索引下标也需要重新计算。
4、扩容很耗时，而扩容的次数主要取决于加载因子的值，因为它决定这扩容的次数。下面讲下它的取值的重要性：
- 加载因子越小，优点：存储的冲突机会减少；缺点：扩容次数越多（消耗性能就越大）、同时浪费空间较大（很多空间还没用，就开始扩容了）
- 加载因子越大，有点：扩容次数较少，空间利用率高；缺点：冲突几率就变大了、链表（后面介绍）长度会变长，查找的效率降低。
5、扩容时会重新计算索引下标。也就是所谓的rehash过程。
6、插入元素都是表头插入，而不是链表尾插入。
4.3、get()函数
知道了put方法的原理，那么get方法就很简单了。
public V get(Object key) { if (key == null) return getForNullKey(); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); }
第一步：如果key为空，则直接从table[0]所对应的链表中查找（应该还记得put的时候为null的key放在哪）。
private V getForNullKey() { if (size == 0) { return null; } for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; }
第二步：如果key不为空，则根据key获取hash值，然后再根据hash和length-1取模得到索引，然后再遍历索引对应的链表，存在与key相等的则返回。
final Entry<K,V> getEntry(Object key) { if (size == 0) { return null; } int hash = (key == null) ? 0 : hash(key); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } return null; }
三、并发场景中使用HashMap会怎么样？
1、肯定不能保证数据的安全性，因为内部方法没有一个是线程安全的。
2、有时会出现死锁情况。为什么呢？下面列个场景简单分析下：
- 假设当前容量为4， 有三个元素（a, b, c）都在table[2]下的链表中，另一个元素(d)在table[3]下。如图
- 假设此时有A,B两个线程都要往map中put一个元素则都需要扩容，当遍历到table[2]时，假设线程B先进入循环体的第一步：e 指向a, next指向b, 如图：
Entry<K,V> next = e.next;
- 此时线程B让出时间片，让A线程一直执行完扩容操作，最终落位同样也是落位到table[2],其链表元素已经倒序了。如图：
- A线程让出时间片，B线程操作：接着循环继续执行，执行到循环末尾的时候，table[2] 指向a, 同时 e 和 next 都是指向b,如图：
// 同理落位到2 int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; // 指向a newTable[i] = e; e = next;
- 接着第二轮循环， e = b, next = a, 进行第二轮循环后的结果是e = next 且 table[2] 指向b元素，b元素再指向a元素，如图：
- 接着第三轮循环， e = a, a的下个元素为null, 所以next = null，但是当执行到下面这步就改变形式了，e.next 又指向了b，此时a和b已经出现了环形。因为next = null，所以终止了循环。
e.next = newTable[i];
- 此时，问题还没有直接产生。当调用get()函数查找一个不存在的Key，而这个Key的Hash结果恰好等于3的时候，由于位置3带有环形链表，所以程序将会进入死循环！（上面图形均忽略四个元素和要插入元素的规划）
四、怎样合理使用HashMap?
- 1、创建HashMap时，指定足够大的容量，减少扩容次数。最好为：需要存的实际个数/除以加载因子。可以使用guava包中的Maps.newHashMapWithExpectedSize()方法。
为什么要这样指定大小呢？ 再去上面回顾下扩容时机吧
- 2、不要在并发场景中使用HashMap，如硬要使用通过Collections工具类创建线程安全的map,如：Collections.synchronizedMap(new HashMap<String, Object>());
这就是本该拼搏的年纪，却想得太多，做得太少！
