HashMap的实现原理

想了解HashMap的原因是，前几天去某公司面试，被问到这个，我一脸懵逼，所以决定回来补补知识。

1. 数据结构基础操作执行性能
   • 数组：采用一段连续的存储单元存储数据。对于查找指定数字的下标，时间复杂度是O(1)。对于查找关键字是否在数组里面，时间复杂度是O(n)。对于插入删除，时间复杂度是O(n)。
   • 线性链表：对于链表的新增删除等操作，时间复杂度为O(1)。而查找操作时间复杂度是O(n)。
   • 二叉树：对于相对平衡的有序二叉树，对其进行插入查找删除的操作，平均复杂度是O(logn)。
   • 哈希表：哈希表中进行添加，删除，查找的操作性能十分之高，不考虑哈希冲突的情况下，只需一次定位即可完成。时间复杂度为O(1)。
2. 数据结构的物理存储只有两种：顺序存储和链式存储。
3. 哈希表的主干就是数组。
4. 我们要新增或查找某个元素，通过把当前元素的关键字通过某函数映射到数组中的某个位置。这个函数被称为哈希函数，这个函数的好坏直接影响哈希表的优劣。
5. 哈希冲突：当我们对某个元素进行哈希运算，得到一个存储值，，在进行插入的时候发现地址被占用了，那么就发生了所谓的哈希冲突。好的哈希函数可以保证计算简单和散列地址分布均匀。
   • 哈希冲突的解决方法：开放定址法，再散列函数法，链地址法。而HashMap采用链地址法。也就是HashMap使用的是数组+链表。
6. HashMap的实现原理：HashMap的主干是一个Entry数组。Entry是HashMap的基本组成元素。每个Entry包含一个key-value键值对。初始值是空数组{}。主干数组的长度一定是2的次幂。

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

7. Entry是HashMap的静态内部类。

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        } 

则HashMap的整体结构

8. 简单来说，HashMap是由数组+链表组成。数组是HashMap的主体，链表是为了解决哈希冲突。如果定位到的数组不包含链表，那么查找和添加操作就很快，仅需一次寻址。如果定位到的数组包含链表，对于添加操作就是时间复杂度O(n)，首先遍历数组，存在就覆盖，不存在就新加。对于查找操作，仍需遍历链表，通过key对象的equals方法逐一比对查找。所以性能考虑，HashMap中的链表出现越少，性能越好。
9. HashMap类中其他几个重要的数据结构

• transient int size：实际存储key-value键值对的个数
• int threshold：阀值，当table={}时，这个值是初始值16。当table被填充，也就是为table分配内存空间之后，threshold一般为capacity*loadFactor。HashMap在进行扩容的时候回考虑threshold。
• final float loadFactor：负载因子，代表了HashMap的填充度有多少，一般是0.75。
• transient int modCount：用于快速失败，由于HashMap非线程安全，在对HashMap进行线程迭代的时候，如果其他线程的参与导致HashMap结构发生变化(比如：put,remove等操作)，需要抛出异常ConcurrentModificationException。

10. HashMap有四个构造器：

• HashMap()：构造一个空的HashMap，默认初始容量是16，负载因子是0.75。
• HashMap(int initialCapacity)：构造一个空的HashMap，初始容量是initialCapacity，负载因子是0.75。
• HashMap(int initialCapacity，float loadFactor)：构造一个空的HashMap，初始容量是initialCapacity，负载因子是loadFactor。
• HashMap(Map<? extends K,? extends V> m)：用相同的Map构造一个新的HashMap。

11. 看一下上面的第三个构造函数的代码。

public HashMap(int initialCapacity, float loadFactor) {
　　　　　//此处对传入的初始容量进行校验，最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
        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中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
    }

在这里可以看到，在常规构造器中，没有为数组table分配内存空间（除了第四个构造器）。而是在执行put操作的时候才真正构建table数组。
12. 在了解put操作之前，我们先了解一下inflateTable方法。

private void inflateTable(int toSize) {
        int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

inflateTable方法用于给主干数组table分配内存空间，通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂。如果toSize=13，那么capacity=16。如果toSize=20，那么capacity=32。
13. 接着了解一下，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();

        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

用了很多的异或，移位等运算，对key的hashcode进一步进行计算，以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀。
14. 当用hash()函数计算出了值之后，通过indexFor()进一步处理来获取实际存储位置。

static int indexFor(int h, int length) {
        return h & (length-1);
    }

h & (length -1 )可以保证最终获得的下标一定在数组范围内。举例：h = 23，length = 14，length-1 = 13。
   1 0 1 1 1
& 0 1 1 0 1
——————————————
    0 0 1 0 1 =5
则最后在数组中的下标是5。当然这也可以用模运算来实现，但是位运算对计算机来说性能更高。
15. addEntry()的实现：

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

当size大于阀值或者发生哈希冲突的时候，需要进行数组扩容。扩容时需要新建一个长度为之前数组2倍的新数组，然后将当前的Entry数组全部传输过去
16. 最后了解一下put()方法

 public V put(K key, V value) {
        //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，此时threshold为initialCapacity 默认是1<<4(24=16)
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
       //如果key为null，存储位置为table[0]或table[0]的冲突链上
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀
        int i = indexFor(hash, table.length);//获取在table中的实际位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
            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++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败
        addEntry(hash, key, value, i);//新增一个entry
        return null;
    }    

17. 关于HashMap的数组长度为何一定是2的次幂。
    resize方法是对数组进行扩容

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

如果数组发生可扩容，那么数组长度发生变化，存储位置index = h & (length-1)的肯定会发生变化。需要重新计算index。
再看看transfer方法。

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
　　　　　//for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去（数组不存储实际数据，所以仅仅是拷贝引用而已）
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
　　　　　　　　　 //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

数组长度一定是2的次幂是因为，为了保持新的数组索引和老的数组索引的大致上的一致。
举例：h = 21, length - 1 = 15 ,new_length - 1 = 31。
    1 0 1 0 1
&  0 1 1 1 1
————————
     0 0 1 0 1    =5

    0 1 0 1 0 1
&  0 1 1 1 1 1
————————
     0 1 0 1 0 1    =21
当length-1低位全为1的情况下，h的低位就只有一种情况。这样就避免了之前散列的很好的老数组的数据位置重新调换。

18. get()方法：

public V get(Object key) {
　　　　 //如果key为null,则直接去table[0]处去检索即可。
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);
        return null == entry ? null : entry.getValue();
 }

getEntry()方法：

final Entry<K,V> getEntry(Object key) {
            
        if (size == 0) {
            return null;
        }
        //通过key的hashcode值计算hash值
        int hash = (key == null) ? 0 : hash(key);
        //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录
        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;
    }    

19. 写equals()方法时需要重写hashCode()方法

转载自
作者： dreamcatcher-cx
出处： http://www.cnblogs.com/chengxiao/