HashMap的实现原理

       哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景极其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中。本文会对Java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。

目录

            一、什么是哈希表
            二、HashMap实现原理
            三、重写equals方法需同时重写hashCode方法
            四、HashMap的用法

一、什么是哈希表

       在讨论哈希表前，我们先大概了解一下其他数据结构在新增，查找等基础操作执行性能
数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)；当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高到O(logn)；对于一般的插入删除操作，十几道数组元素的移动，其平均复杂度也为O(n)。
线性链表：对于链表的新增，删除等操作，仅需处理结点间的引用即可，时间复杂度为O(1)；而查找操作需要遍历链表逐一比对，复杂度为O(n)
二叉树：对一颗相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度为O(logn)。
哈希表：相比上述几种数据结构，在哈希表中添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)。

      我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也是这两种物理组织形式）。而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特征，哈希表的主干就是数组。比如我们要新增或查找某个元素，我们通过把当前元素的关键字通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。
                                           存储位置=f（关键字）
其中，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。举个例子，比如我们要在哈希表中执行插入操作：

查找操作同理，先通过哈希函数计算出实际存储地址，然后从数组中对应地址取出即可。
哈希冲突
      然而万事无完美，如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能保证计算简单和散列地址分布均匀。但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多钟：开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap采用了链地址法，也就是数组+链表的方式。

二、HashMap实现原理

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。Entry是HashMap中的一个静态内部类。代码如下

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

static class Node<K,V> implements Map.Entry<K,V>{
       final K key;
       V value;
       Entry<K,V> next;      //存储指向下一个Entry的引用，单链表结构
       final int hash;            //对key的hashCode值进行hash运算后得到的值，存储在Entry，避免重复计算
       Node(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;}
          public final String toString()    {return key+"="+value;}
          public final int hashCode(){
                return Objects.hashCode(key)^Objects.hashCode(value);
            }
            public final boolean equals(Object o){
                  if(o==this)
                         return true;
                   if(o instanceof Map.Entry){
                        Map.Entry<?,?> e=(Map.Entry<?,?>) o;
                        if(Objects.equals(key,e.getKey()) &&
                          Objects.equals(value,e.getValue())
                             return true;
                      }
                      return false;
               }
   }

所以，HashMap的整体结构如下

简单来说，HashMap是由数组+链表组成的，数组是HashMap的主体，链表则主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前Entry的next指向null），那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n），首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会更好。
最终存储位置的确定流程是这样的：

三、重写equals方法需同时重写hashCode方法

public class MyTest{
        private static class Person{
                 int inCard;
                 String name;
                 public Person(int idCard,String name){
                        this.idCard=idCard;
                        this.name=name;
                  }
                  @Override
                  public boolean equals(Object o){
                            if(this==o){
                                 return true;
                            }
                            if(o==null || getClass()!=o.getClass()){
                                   return false;
                             }
                            Person person=(Person) o;
                            //两个对象是否等值，通过idCard来确定
                            return this.idCard=person.idCard;
                       }
         }
         public static void main(String[] args){
                HashMap<Person,String> map=new HashMap<>();
                Person person=new Person(1234,"乔峰");
                map.put(person,“天龙八部”);
                System.out.println("结果："+map.get(new Perosn(1234,"萧峰")));
         }
  }

实际输出结果：

结果：null

当我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)–>hash–>indexfor–>最终索引位置；而通过key取出value的时候key(hashcode2)–>hash–>indexfor–>最终索引位置。由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null(也有可能碰巧定位到一个数组位置，但是也会判断其entry的hash值是否相等）

所以在重写equals的方法的时候，必须重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）

更多知识参见：HashMap的工作原理

本文转载自dreamcatcher-cx
链接：https://www.cnblogs.com/chengxiao/p/6059914.html#t1