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>());