Java 哈希机制

通过分析HashMap和HashSet源码分析其Hash存储机制

  对于HashSet而言，系统采用hash算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；
  对于HashMap而言，系统key-value当成一个整体进行处理，系统总是根据Hash算法来计算key-value的存储位置，这样可以保证能快速存、取Map的key-value对。
  虽然集合号称存储的是Java对象，但实际上并不会真正将Java对象放入Set集合中，只是在Set集合中保留这些对象的引用。
  即，Java集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的Java对象。
 
HashMap的存储实现
   

  HashMap<String , Double> map = new HashMap<String , Double>();
      map.put("语文" , 80.0);
      map.put("数学" , 89.0);
      map.put("英语" , 78.2);

    HashMap采用一种所谓的“Hash算法”来决定每个元素的存储位置。
    当程序执行map.put(“语文”，80.0)；时，系统将调用“语文”的hashCode()方法得到其hashCode值————每个Java对象都有hashCode（）方法，都可以通过该方法获得它的hashCode值。
    得到这个对象的hashCode值之后，系统会根据该HashCode值来决定该元素的存储位置。
    

 public V put(K key, V value)
       {
           // 如果 key 为 null，调用 putForNullKey 方法进行处理
           if (key == null)
               return putForNullKey(value);
           // 根据 key 的 keyCode 计算 Hash 值
           int hash = hash(key.hashCode());
           // 搜索指定 hash 值在对应 table 中的索引
       <strong> int i = indexFor(hash, table.length);</strong>
           // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素
           for (Entry<K,V> e = table[i]; e != null; e = e.next)
           {
               Object k;
               // 找到指定 key 与需要放入的 key 相等（hash 值相同
               // 通过 equals 比较放回 true）
               if (e.hash == hash && ((k = e.key) == key
                   || key.equals(k)))
               {
                   V oldValue = e.value;
                   e.value = value;
                   e.recordAccess(this);
                   return oldValue;
               }
           }
           // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry
           modCount++;
           // 将 key、value 添加到 i 索引处
           addEntry(hash, key, value, i);
           return null;
       }

       上面程序中用到了Map.Entry，每个Map.Entry其实就是一个key-value对。
       从上面程序中可以看出：当系统决定存储HashMap中的key-value对时，完全没有考虑Entry中的value，仅仅只是根据key来计算并决定每个Entry的存储位置。
       这也说明：Map集合中的value完全是key的附属，当系统决定了key的存储位置之后，value随之保存在那里即可。
       
       上面方法提供了一个hashCode()返回值来计算Hash码的方法：hash()，这个方法是一个纯粹的数学计算，其方法如下：
      

 static int hash(int h)
          {
              h ^= (h >>> 20) ^ (h >>> 12);
              return h ^ (h >>> 7) ^ (h >>> 4);
          }

      对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用hash(int  h)方法所计算得到的hash码值总是相同的。
      接下来程序会调用indexFor(int h, int length)方法来计算该对象应该保存在table数组的哪个索引处。
     

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

      这个方法总是通过h & (table.length-1)来得到该对象的保存位置
      而HashMap底层数组的长度总是2的n次方。
      当length总是2的倍数时，h & (length - 1)将是一个非常巧妙的设计：
          假设h=5, length = 16,那么h & (length-1)将得到5；
          h=6，length=16，那么h&(length-1)将得到6。。。。。h=15,length=16,那么h&(length-1)将得到15；
          但是当h=16,length=16时，那么h&(length-1)将得到0；
          当h=17,length=16,那么h&length-1将得到1
          这样保证计算得到的索引值总是位于table数组的索引之内。
          
      当程序试图将一个key-value对放入HashMap中时，程序首先根据该key的hashCode()返回值决定该Entry的存储位置：
          如果两个Entry的key的hashCode()返回值相同，那么它们的存储位置相同。
      如果这两个Entry的key通过equals比较返回true，新添加Entry的value将覆盖集合中原有Entry的value，但key不会覆盖。
      如果这两个Entry的key通过equals比较返回false，新添加的Entry将与集合中原有Entry形成Entry链，而且新添加的Entry位于Entry链的头部。
      当向HashMap中添加key-value对，由其key的hashCode()返回值决定该key-value对（就是Entry对象）的存储位置。
      当两个Entry对象的key的hashCode()返回值相同时，将由key通过equals()比较值决定是采用覆盖行为（返回true），还是产生Entry链（返回false）。
      上面程序中还调用了addEntry(hash, key, value, i);代码，其中addEntry是HashMap提供的一个包访问权限的方法，该方法仅用于添加一个key-value对。
        

 void addEntry(int hash, K key, V value, int bucketIndex)
              {
                  // 获取指定 bucketIndex 索引处的 Entry
                  Entry<K,V> e = table[bucketIndex];      // ①
                  // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
                  table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
                  // 如果 Map 中的 key-value 对的数量超过了极限
                  if (size++ >= threshold)
                      // 把 table 对象的长度扩充到 2 倍。
                      resize(2 * table.length);      // ②
              }

        上面方法的代码中包含了一个非常优雅的设计：系统总是将新添加的Entry对象放入table数组的bucketIndex索引处————
            如果bucketIndex索引处已经有了一个Entry对象，那新添加的Entry对象指向原有的Entry对象（产生一个Entry链），
            如果bucketIndex索引处没有Entry对象，即e变量是null，也就是新放入的Entry对象指向null，也就是没有产生Entry链。
            
Hash算法的性能选项
    由以上代码可以看出，在同一个bucket存储Entry链的情况下，新放入的Entry总是位于bucket中，而最早放入该bucket中的Entry则位于这个Entry链的最末端。
    
    上面程序中还有这样两个变量：
        size:该变量保存了该HashMap中所包含的key-value对的数量。
        threshold：该变量包含了HashMap能容纳的key-value对的极限，它的值等于HashMap的容量乘以负载因子（load factor）。
        
    当Size++ >= threshold时，HashMap会自动调用resize方法扩充HashMap的容量。每扩充一次，HashMap的容量就增大一倍。
    
    使用的table数组其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是HashMap的容量。
    HashMap包含如下几个构造器：
        HashMap():构建一个初始容量为16，负载因子为0.75的hashMap
        HashMap（int initialCapacity）：构建一个初始容量为initialCapacity，负载因子为0.75的HashMap
        HashMap（int initialCapacity, float loadFactor）：以指定初始容量、指定的负载因子创建一个HashMap。
    
    当创建一个HashMap时，系统会自动创建一个table数组来保存HashMap中的Entry，下面是HashMap中一个构造器的代码：
      

 // 以指定初始化容量、负载因子创建 HashMap
         public HashMap(int initialCapacity, float loadFactor)
         {
             // 初始容量不能为负数
             if (initialCapacity < 0)
                 throw new IllegalArgumentException(
                "Illegal initial capacity: " +
                     initialCapacity);
             // 如果初始容量大于最大容量，让出示容量
             if (initialCapacity > MAXIMUM_CAPACITY)
                 initialCapacity = MAXIMUM_CAPACITY;
             // 负载因子必须大于 0 的数值
             if (loadFactor <= 0 || Float.isNaN(loadFactor))
                 throw new IllegalArgumentException(
                 loadFactor);
             // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
             int capacity = 1;
             while (capacity < initialCapacity)
                 capacity <<= 1;
             this.loadFactor = loadFactor;
             // 设置容量极限等于容量 * 负载因子
             threshold = (int)(capacity * loadFactor);
             // 初始化 table 数组
             table = new Entry[capacity];              // ①
             init();
         }

        
        上面代码中包含了一个简洁的代码实现：找出大于initialCapacity的，最小的2的n次方值，并将其作为HashMap的实际容量（由capacity变量保存）。
         table的实质就是一个数组，一个长度为capacity的数组。
          对于HashMap及其子类而言，它们采用Hash算法来决定集合中元素的存储位置。
          当系统开始初始化HashMap时，系统会创建一个长度为capacity的Entry数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个bucket都有其指定索引，系统可以根据其索引快速访问该bucket里存储的元素。
          
          无论何时，HashMap的每个“桶”只存储一个元素（即一个Entry），由于Entry对象可以包含一个引用变量（就是Entry构造器的最后一个参数）用于指向下一个Entry，
              因此可能出现的情况是：HashMap的bucket中只有一个Entry，但这个Entry指向另一个Entry————这就形成了一个Entry链。
              
  HashMap的读取实现
        当HashMap的每个bucket里存储的Entry只是单个Entry————也就是没有通过指针产生Entry链时，此时的HashMap具有最好的性能：
              当程序通过key取对应value时，系统只要先计算出该key的hashCode（）返回值，在根据该hashCode返回值找出该key在table数组中的索引，然后取出该索引处的Entry，最后返回该key对应的value即可。
                 

public V get(Object key)
                   {
                       // 如果 key 是 null，调用 getForNullKey 取出对应的 value
                       if (key == null)
                           return getForNullKey();
                       // 根据该 key 的 hashCode 值计算它的 hash 码
                       int hash = hash(key.hashCode());
                       // 直接取出 table 数组中指定索引处的值，
                       for (Entry<K,V> e = table[indexFor(hash, table.length)];
                           e != null;
                           // 搜索该 Entry 链的下一个 Entr
                           e = e.next)          // ①
                       {
                           Object k;
                           // 如果该 Entry 的 key 与被搜索 key 相同
                           if (e.hash == hash && ((k = e.key) == key
                               || key.equals(k)))
                               return e.value;
                       }
                       return null;
                   }

            从上面的代码中可以看出，如果HashMap的每个bucket里只有一个Entry时，HashMap可以根据索引，快速地取出该bucket里的Entry；
              在发生“Hash冲突”的情况下，单个bucket里存储的不是一个Entry，而是一个Entry链，系统只能必须按顺序遍历每个Entry，直到找到想搜索的Entry为止————
              如果恰好要搜索的Entry位于该Entry链的最末端（该Entry最早放入该bucket中），那系统必须循环到最后才能找到该元素。
          
            HashMap在底层将key-value当成一个整体进行处理，这个整体就是一个Entry对象。
              HashMap底层采用一个Entry[]数组来保存所有的key-value对，当需要存储一个Entry对象时，会根据hash算法来决定其存储位置；
              当需要取出一个Entry时，也会根据hash算法找到其存储位置，直接取出该Entry。
              由此可见：HashMap之所以能快速存、取所包含的Entry，完全类似于一个生活哲理：不同的东西要放在不同的位置，需要时才能快速找到它
              
            当创建HashMap时，有一个默认的负载因子（load factor），其默认值为0.75，这是时间和空间成本上的一种折衷：增大负载因子可以减少hash表（即Entry数组）所占用的内存空间，
              但会增加查询数据的时间开销，而查询是最频繁的操作（HashMap的get()与put()方法都要用到查询）；
              减小负载因子会提高数据查询的性能，但会增加hash表所占用的内存空间。
            
            我们可以在创建HashMap时根据实际需要适当地调整load factor的值，如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；
                如果程序比较关心时间开销，内存比较宽裕则可以适当地减少负载因子。
                通常情况下，程序员无需改变负载因子的值。
                
            如果开始就知道HashMap会保存多个key-value对，可以在创建时就使用较大的初始化容量，如果HashMap中Entry的数量一直不会超过极限容量（capacity*load factor），
              HashMap就无需调用resize()方法重新分配table数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为capacity的Entry数组），
              因此创建HashMap时初始化容量设置也需小心对待。
      
HashSet的实现
    对于HashSet而言，它是基于HashMap实现的，Hashset底层采用HashMap来保存所有元素，
 

  public class HashSet<E>
         extends AbstractSet<E>
         implements Set<E>, Cloneable, java.io.Serializable
     {
         // 使用 HashMap 的 key 保存 HashSet 中所有元素
         private transient HashMap<E,Object> map;
         // 定义一个虚拟的 Object 对象作为 HashMap 的 value
         private static final Object PRESENT = new Object();
         ...
         // 初始化 HashSet，底层会初始化一个 HashMap
         public HashSet()
         {
             map = new HashMap<E,Object>();
         }
         // 以指定的 initialCapacity、loadFactor 创建 HashSet
         // 其实就是以相应的参数创建 HashMap
         public HashSet(int initialCapacity, float loadFactor)
         {
             map = new HashMap<E,Object>(initialCapacity, loadFactor);
         }
         public HashSet(int initialCapacity)
         {
             map = new HashMap<E,Object>(initialCapacity);
         }
         HashSet(int initialCapacity, float loadFactor, boolean dummy)
         {
             map = new LinkedHashMap<E,Object>(initialCapacity
                 , loadFactor);
         }
         // 调用 map 的 keySet 来返回所有的 key
         public Iterator<E> iterator()
         {
             return map.keySet().iterator();
         }
         // 调用 HashMap 的 size() 方法返回 Entry 的数量，就得到该 Set 里元素的个数
         public int size()
         {
             return map.size();
         }
         // 调用 HashMap 的 isEmpty() 判断该 HashSet 是否为空，
         // 当 HashMap 为空时，对应的 HashSet 也为空
         public boolean isEmpty()
         {
             return map.isEmpty();
         }
         // 调用 HashMap 的 containsKey 判断是否包含指定 key
         //HashSet 的所有元素就是通过 HashMap 的 key 来保存的
         public boolean contains(Object o)
         {
             return map.containsKey(o);
         }
         // 将指定元素放入 HashSet 中，也就是将该元素作为 key 放入 HashMap
         public boolean add(E e)
         {
             return map.put(e, PRESENT) == null;
         }
         // 调用 HashMap 的 remove 方法删除指定 Entry，也就删除了 HashSet 中对应的元素
         public boolean remove(Object o)
         {
             return map.remove(o)==PRESENT;
         }
         // 调用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素
         public void clear()
         {
             map.clear();
         }
         ...
     }

    由源码可以看出，Hashset的实现只是封装了一个HashMap对象来存储所有的集合元素，
      所有放入HashSet中的集合元素实际上有HashMap的key来保存，
      而HashMap的value则存储了一个present，它是一个静态的Object对象。
      
    HashSet的绝大部分方法都是通过调用HashMap的方法实现的，因此HashSet和HashMap两个集合在实现本质上是相同的。
    
HashMap的put与HashSet的add
    由于HashSet的add()方法添加集合元素实际上转变为调用HashMap的put（）方法来添加key-value对，
      当新放入HashMap的Entry中key与集合中原有Entry的key相同（hashcode（）返回值相等，通过equals比较也返回true），新添加的Entry的value将覆盖原来Entry的value，但key不会有任何改变，
      因此如果向HashSet中添加一个已经存在的元素，新添加的集合元素（底层由HashMap的key保存）不会覆盖已有的集合元素。
      
  HashSet判断两个对象相等的标准除了要求通过equals（）方法比较返回true之外，还要求两个对象的hashcode（）返回值相等。
  所以如果类只重写equals()方法没有重写hashCode()方法，两个所有属性都相同的同类对象的hashCode()返回值并不同，所以HashSet会把它们当成2个对象。
 
当我们试图把某个类的对象当成HashMap的key，或试图将这个类的对象放入HashSet中保存时，重写该类 的equals（Object obj）方法和hashCode()方法很重要，
  而且这两个方法的返回值必须保持一致：当该类的两个对象的hashCode（）返回值相同时，他们通过equals（）方法比较也应该返回true。
  通常来说，所有参与计算hashcode（）返回值的关键属性，都应该用于作为equals()比较的标准。