Java的HashMap实现原理整理总结

通过Debug 探寻Java-HashMap 实现原理：

一个简单的例子，代码如下，

测试方法 main:

     public static void main(String[] args) {

         KeyObj obj1 = new KeyObj("AAAA");
         KeyObj obj2 = new KeyObj("BBBB");
         KeyObj obj3 = new KeyObj("CCCCC");
         KeyObj obj4 = new KeyObj("DDDDD");

         HashMap<KeyObj, String> hashMap = new HashMap<KeyObj, String>();
         hashMap.put(obj1, "aaaa");
         hashMap.put(obj2, "bbbb");
         hashMap.put(obj3, "ccccc");
         hashMap.put(obj4, "ddddd");

         System.out.println(hashMap.values());

     }

KeyObj.java

 public class KeyObj {

     String keyStr;

     public KeyObj(String keyStr) {
         super();
         this.keyStr = keyStr;
     }

     public String getKeyStr() {
         return keyStr;
     }

     public void setKeyStr(String keyStr) {
         this.keyStr = keyStr;
     }
 　　
     @Override
　　　　// 覆盖hashCode方法，使得key的单双数分别获得一致的hash值，方便测试
     public int hashCode() {
         if (keyStr.length() % 2 == 0) {
             return 31;
         }
         return 95;
     }

     @Override
     public boolean equals(Object obj) {
         KeyObj obj1 = (KeyObj) obj;
         if (this.keyStr.equalsIgnoreCase(obj1.keyStr))
             return true;
         return false;
     }

 }

运行测试方法main，Debug查看HashMap:

1.可以看到HashMap其实是有一个名称为table的Entry数组，我们使用HashMap的put方法，本质是把我们的Key-Value作为Entry对象放入到HashMap中。

2.HashMap的table数组初始大小为16.

3.为何我们put了4个对象却只使用了table[10] 与 table[14]?

查看put方法JDK代码：

     public V put(K key, V value) {
         if (table == EMPTY_TABLE) {
             inflateTable(threshold); // 3.1 table若为空创建table，16大小
         }
         if (key == null)
             return putForNullKey(value); // 3.2 key若为空放入table[0]
         int hash = hash(key); // 3.3 计算放入key的hash，值为调用KeyObj的hashcode方法，再hash
         int i = indexFor(hash, table.length); 
　　　　　　 // 3.4 计算当前put的Enrty在table数组中精确位置(int i),跟踪代码可以很容易看出:
　　　　　　 // 3.4.1 精确位置i是由key的hash值与table.length取模
         for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 3.5 遍历table[i]的Entry
             Object k;
             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { // 3.6 若put相同key的KeyObj,则替换旧值
                 V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
             }
         }

         modCount++;
         addEntry(hash, key, value, i);// 3.7 创建Entry,当前table[i]的首节点变为当前put节点Entry对象的next节点，注：JDK8之前每一个table[i]上的Entry使用单链表存储的
         return null;
     }

理解了put，查看HashMap的get方法就很简单了：

     public V get(Object key) {
         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;
         }

         int hash = (key == null) ? 0 : hash(key);
         for (Entry<K,V> e = table[indexFor(hash, table.length)]; // 找到table[i]，并便利该位置节点
              e != null;
              e = e.next) {
             Object k;
             if (e.hash == hash &&
                 ((k = e.key) == key || (key != null && key.equals(k)))) // 找到，返回
                 return e;
         }
         return null;
     }

其他：

在put函数代码中有一个注释：

JDK8之前每一个table[i]上的Entry使用单链表存储的

一直到JDK7为止，HashMap的结构都是这么简单，基于一个数组以及多个链表的实现，hash值冲突的时候，就将对应节点以链表的形式存储。

这样子的HashMap性能上就抱有一定疑问，如果说成百上千个节点在hash时发生碰撞，存储一个链表中，那么如果要查找其中一个节点，那就不可避免的花费O(N)的查找时间，这将是多么大的性能损失。这个问题终于在JDK8中得到了解决。再最坏的情况下，链表查找的时间复杂度为O(n),而红黑树一直是O(logn),这样会提高HashMap的效率。

所以在JDK8中，当同一个hash值的节点数不小于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树。