Java HashMap的工作原理和实现

目录

概述

HashMap的基本操作如下：

map.put("Chinese", 1);
map.put("Math", 2);
map.put("Englist", 3);
map.put("Chemistry", 4);
map.put("Biology", 5);

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

定义

HashMap实现了Map接口，继承子AbstractMap。其中，Map接口定义了键映射到值的规则。

    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable { }

构造函数

HashMap提供了三个构造函数，具体实现如下。

• 构造一个默认具有初始容量(16)和默认加载因子(0.75)的空HashMap

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

• 构造一个具有默认因子(0.75)的空HashMap

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

• 构造一个带指定初始容量和加载因子的空HashMap

    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函数为空，需要有特殊需求的子类单独实现
        init();
    }

通过上面的三个构造函数，我们可以看出，HashMap的构造函数完成的工作就是对loadFactor和threshold这两个成员属性赋值。而这两个成员属性的含义如下：

• threshold: 初始容量，表示哈希表中桶的数量。
• loadFactor：负载因子，表示当前哈希表的最大填满比例。当threshold * loadFactor < 当前哈希表中桶数目时，哈希表的threshold需要扩大为当前的2倍。

数据结构

JAVA中HashMap是由数组和引用实现的”链表散列”。HashMap底层实现是数组，但是数组的每一项都是一个链表，其中initialCapacity就代表了数组的长度。HashMap初始化数据结构的代码如下：

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

其中，Entry为HashMap的内部类，它包含了键key、值value、下一个节点next，以及hash值。这个内部类非常重要，正是由于Entry才构成table数组的项为链表。

存储实现：put(key, value)

讲完了HashMap的数据结构，我们就来看一下put存储函数的源码实现：

    public V put(K key, V value) {
        // 当有数据需要存储时，才对table数组分配内存
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 当key为null时，调用putForNullKey方法存储key为null的键值对。将该key保存在table数组下标为0的位置上。
        if (key == null)
            return putForNullKey(value);

        // 计算key的hash值
        int hash = hash(key);
        // 计算插入数据所在链表的下标，使用的方法是hash值取余数组长度
        int i = indexFor(hash, table.length);
        // 遍历此下标对应的链表，看是否存在该key值
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 判断该条链表上是否有相同hash值的entry，如果有，则替换entry的value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                // 返回旧值，结束插入操作
                return oldValue;
            }
        }

        // 在下标i对应的链表中没有找到key相同的Entry，则创建一个新的Entry，进行插入操作
        modCount++;
        // 使用头插法在下标为i的链表中进行插入操作
        addEntry(hash, key, value, i);
        return null;
    }

读取实现：get(key)

通过对存储函数put方法的讲解，我们很容易就能理解get方法的实现。源码如下：

    public V get(Object key) {
        // 若key为null，调用getForNullKey方法，其实就是查找下标为0的链表中key为null的Entry的value
        if (key == null)
            return getForNullKey();
        // getEntry方法实现见下面的函数
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        // 获取key的hash值
        int hash = (key == null) ? 0 : hash(key);
        // 根据hash值获取索引值
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            // 若搜索的key与查找的key相同，则返回对应的value
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

JAVA实现HashMap

在Github上实现了一个HashMap的代码，还没来得及实现扩容，欢迎指导。
自定义HashMap

面试常考问题

什么时候会使用HashMap？他有什么特点？

当需要存储键值对时需要使用HashMap，它可以接收key为null的键值对，但是是非线程同步的。

HashMap的工作原理？

这个问题很大，其实上面讲的就是HashMap的工作原理。简单的说如下：
HashMap底层是数组实现的，数组的每个元素是链表，由Entry内部类实现。HashMap通过put方法存储对象，通过get方法获取对象。
存储对象时，我们将K/V键值对传给put方法，它首先调用hash方法计算K的hash值，取余HashMap数组长度后获取该键值对所在链表的数组下标，进一步存储时，会适当调整数组大小，并且采用头插法将Entry键值对插入到链表中。
获取对象时，我们将K传给get方法，也是先调用hash方法计算hash值获取数组中所在链表的下标。然后，顺序遍历链表，查找相同Entry的key的value值。

equals()和hashCode()都有什么作用？

通过取key的hashCode()获取初步的hash值，使用equals()方法来判断key值是否相等。

如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

如果超过了负载因子(默认0.75)，则会重新resize一个原来长度两倍的HashMap，并且重新调用hash方法。

HashMap和HashTable的区别

1. HashTable是线程安全的，HashMap不是。所以，在不需要线程安全的场景下，HashMap的效率更高。
2. HashTable不允许存储key为null的键值对，HashMap可以存储，保存在数据下标为0的链表中。

参考文献

1. Java HashMap工作原理