Java面试之HashMap存储原理

Hashmap存储原理

哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表。

• 什么是哈希表
• Hashmap实现原理
• 为什么Hashmap的数组长度一定是2的次幂
• 重写equals方法需同时重写hashCode方法

---

哈希表

先大概了解数据结构在基础操作上的执行性能

• 数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)
• 线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)
• 二叉树：对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)。
• 哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。
  在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作，这函数就是哈希函数
  ####哈希冲突
  　　如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？
  ####Hash算法解决冲突的方法一般有以下几种常用的解决方法 :
• 开放定址法：所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入 公式为：fi(key) = (f(key)+di) MOD m (di=1,2,3,……,m-1)
  当冲突发生时，使用某种探测技术在散列表中形成一个探测序列。沿此序列逐个单元地查找，直到找到给定的关键字，或者碰到一个开放的地址（即该地址单元为空）为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探测到开放的地址则表明表中无待查的关键字，即查找失败。
  比如说，我们的关键字集合为{12,67,56,16,25,37,22,29,15,47,48,34},表长为12。
  我们用散列函数f(key) = key mod l2，当计算前S个数{12,67,56,16,25}时，都是没有冲突的散列地址，直接存入：
  
  计算key = 37时，发现f(37) = 1，此时就与25所在的位置冲突。 于是我们应用上面的公式f(37) = (f(37)+1)
  mod 12 = 2。于是将37存入下标为2的位置：
  
• 再哈希法：再哈希法又叫双哈希法，有多个不同的Hash函数，当发生冲突时，使用第二个，第三个，….，等哈希函数计算地址，直到无冲突。虽然不易发生聚集，但是增加了计算时间。
• 链地址法：每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来，如：键值对k2, v2与键值对k1, v1通过计算后的索引值都为2，这时及产生冲突，但是可以通过next指针将k2, k1所在的节点连接起来，这样就解决了哈希的冲突问题。
  
• 建立公共溢出区：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表。
  ##HashMap实现原理
  ####存储结构
• hashMap底层是以数组的方式进行存储，将key-value对作为数组中的一个元素存储。
• key-value都是Map.Entry中的属性，将key的值进行hash之后存储，每一个hash值对应一个数组下标，数组下标识根据hash值和数组长度计算。
• 由于不同的key可能hash值相同，hashmap采用链表形式存储。

//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

####Entry结构分析
Entry是HashMap中封装key-value键值对的一个静态内部类。

static class Entry<K,V> implements Map.Entry<K,V> {
    
        final K key;//map中key值，可以为null
        V value;//map中value值，可以为null
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构链表引用，防止可以值不同，hash值相同
        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;
        } 
        public final K getKey() {
    
            return key;
        }

        public final V getValue() {
    
            return value;
        }
        // 同一个key时，新值替换旧值，返回旧值
        public final V setValue(V newValue) {
    
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
         // key值重写equals方法
        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();
            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;
        }
        // 重写hashCode值
        public final int hashCode() {
    
            return Objects.hashCode(