Java容器之HashMap源码分析

在java的容器框架中，hashMap是最常用的容器之一，下面我们就来深入了解下它的数据结构和实现原理

先看下HashMap的继承结构图

下面针对各个实现类的特点进行下说明：
1）HashMap: 它是根据key的hashCode值进行存储的，大部分时候都可以很快的定位的，因此具有很快的访问速度，

但是遍历的顺序是不一定的。HashMap最多只允许一个key的值为null,但是允许多个value的值为null。HashMap是非线程安全的，

因此在多线程环境中使用的时候要加锁，也可以用Collections的synchronizedMap方法对HashMap进行封装，使HashMap成为线程安全的，

还可以用ConcurrentHashMap,ConcurrentHashMap本身是线程安全的，并发效率很高。

2）HashTable: HashTable是jdk1.0的时候就存在的，是线程安全的，它的所有方法都是syncronized的，所以效率很低，不建议使用。

如果在单线程中使用可以用HashMap，多线程中可以用ConcurrentHashMap.

3) LinkedHashMap: 它是HashMap的一个子类，会记录插入的顺序，在遍历的时候会按照放入的顺序遍历。是非线程安全的。

4）TreeMap: TreeMap实现了SortedMap接口，因此他是有序的。默认是按key的升序进行排序的，所以在向TreeMap中放对象时，

key要么实现Comparable接口要么单独传入一个Comparator比较器。

接下来我们来说下HashMap的存储结构:
HashMap在jdk8中做了优化，在存储结构中加入了红黑树。从结构上来说HashMap的存储结构是
数组 + 链表 + 红黑树 如下图：

下面我们根据源码进行下分析这样的存储结构有什么特点：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  //默认HashMap创建时的大小16
static final int MAXIMUM_CAPACITY = 1 << 30;    // 最大大小
static final float DEFAULT_LOAD_FACTOR = 0.75f;  // 装填因子默认值
    
transient Node<K,V>[] table;   // 哈希桶数组
       int threshold;            // 存放数据的最大数量 
final float loadFactor;        //　装填因子
}

从上面这段ＨashMap的源码中我们看到，有一个 叫table的Node<K,V>数组，显然这就是用来存放数据 的，那么我们来看下Node的结构

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;  // key的hash值
        final K key;
        V value;
        Node<K,V> next;  // 链表的下个结点

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }
.........
}

从代码中可以看到Node是一个链表的数据结构。
HashMap在存放数据的时候会根据key的hash值放到哈希数组中，如果数组的位置已经有数据了，那么就会放到这个数据的后面。
所以这个计算key的哈希值的算法就显的很重要了，如果这个算法不好，就会出现哈希冲突，会严重影响到HashMap的使用效率了.

下面我们再来看是HashMap是如何通过key的hash值定位到数组的位置的呢？看代码

static final int hash(Object key) {
        int h;   // h = key.hashCode()  key的hash值
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

这是jdk8中的代码，分析这这个方法可以知道，它是通过使key的hash值的低16位与高16位异或运算来得到了一个新的hash值，
在jdk7中有这样一个方法：

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

这个方法在jdk8中已经没有了，在jdk8中是直接使用这个方法里的 h & (length-1) 进行计算的
从这个方法中我们看到，是用新的hash值与数组的长度进行 &运算。我们知道HashMap每次进行扩容的时候是按照2的次幂进行扩容的。
正常来说在对hash表的数据结构进行扩容的时候最好要用素数，因为用素数可以减少hash算法的hash值冲突，
在HashTable中的初始容量就是11.但是HashMap每次扩容都是2的次幂，这是因为如果HashMap的长数组长度如果是2的次幂的话
h&(length-1)实际上就是对length取模，这样运算效率就大大提高了。这是个很巧妙的算法。
所以总结起来Hash是如果定位数组位置的：
1：计算key的hash值
2：用key的hash值的高16位与低16位取异或得到新的hash值
3：用这个新的hash值到数组长度取模
这样就得到了这个key应该在哈希桶数组的哪个位置了

HashMap的put方法分析
put方法可以通过这张流程图来分析，大家可以通过这个图对比源码进行研究

1）首先判断table数组是否为空，如果为空则扩容，否则转入2
2）如果table不为空则计算插入点的索引i，如果table[i]为空则新加节点，转向6。否则转向3
3）如果首个节点的元素key与新元素相同，则覆盖，否则转向4
4）判断是否为treeNode，如果是则直接在红黑树中插入，如果不是则转向5
5）遍历链表，如果链表长度大于8则转为红黑树插入，否则在链接中判断，是否有相同key，如果有则
覆盖，否则插入。
6）插入成功后看size是否大于threshold，如果是就扩容

下面是put的源码

public V put(K key, V value) {
     // 对key的hashCode()做hash
     return putVal(hash(key), key, value, false, true);
 }
 
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                boolean evict) {
     Node<K,V>[] tab; Node<K,V> p; int n, i;
     // 步骤①：tab为空则创建
     if ((tab = table) == null || (n = tab.length) == 0)
         n = (tab = resize()).length;
     // 步骤②：计算index，并对null做处理 
     if ((p = tab[i = (n - 1) & hash]) == null) 
         tab[i] = newNode(hash, key, value, null);
     else {
         Node<K,V> e; K k;
         // 步骤③：节点key存在，直接覆盖value
         if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))
             e = p;
         // 步骤④：判断该链为红黑树
         else if (p instanceof TreeNode)
             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         // 步骤⑤：该链为链表
         else {
             for (int binCount = 0; ; ++binCount) {
                 if ((e = p.next) == null) {
                     p.next = newNode(hash, key,value,null);
                      //链表长度大于8转换为红黑树进行处理
                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
                         treeifyBin(tab, hash);
                     break;
                 }
                  // key已经存在直接覆盖value
                 if (e.hash == hash &&
                     ((k = e.key) == key || (key != null && key.equals(k))))                                
             break;
                 p = e;
             }
         }
         
         if (e != null) { // existing mapping for key
             V oldValue = e.value;
             if (!onlyIfAbsent || oldValue == null)
                 e.value = value;
             afterNodeAccess(e);
             return oldValue;
         }
     }

     ++modCount;
     // 步骤⑥：超过最大容量 就扩容
     if (++size > threshold)
         resize();
     afterNodeInsertion(evict);
     return null;
 }

HashMap的扩容机制

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，
对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组
代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。

从上面put方法的代码中我们看到当HashMap的size的值如果大于threshold的时候就会扩容

因为jdk8对HashMap的扩容做了小小的优化，这里先看jdk7扩容的代码，稍后再看jdk8做了哪些优化

void resize(int newCapacity) {   //传入新的容量                                               
    Entry[] oldTable = table;    //引用扩容前的Entry数组                                       
    int oldCapacity = oldTable.length;                                                         
    if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了         
        threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了   
        return;                                                                                
    }                                                                                          
                                                                                               
    Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组                      
    transfer(newTable);                         //！！将数据转移到新的Entry数组里              
    table = newTable;                           //HashMap的table属性引用新的Entry数组          
    threshold = (int)(newCapacity * loadFactor);//修改阈值                                     
}        

从代码中我们可以看到，方法参数是一个新的容量大小，当原容量等于默认的最大容量时
就把threshold设置为2^31-1 也就是最大的整数值。然后就跳出了，也就是说当容量已经
是默认最大值的时候只是修改了threshold的值，桶数组的容量并没有扩大。
然后就是新创建了一个新的数组，把旧数组中的值放入新的数组 中。transfer(newtable)函数就是拷贝旧数组到新数组中的

void transfer(Entry[] newTable) {                                                                
    Entry[] src = table;                   //src引用了旧的Entry数组                               
    int newCapacity = newTable.length;                                                            
    for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组                                    
        Entry<K,V> e = src[j];             //取得旧Entry数组的每个元素                            
        if (e != null) {                                                                          
            src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象） 
            do {                                                                                  
                Entry<K,V> next = e.next;                                                         
                int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置       
                e.next = newTable[i]; //标记[1]                                                   
                newTable[i] = e;      //将新的元素放在数组上的链表的头部                                          
                e = next;             //访问下一个Entry链上的元素                                 
            } while (e != null);                                                                  
        }                                                                                         
    }                                                                                             
}            

从transfer函数中我们可以看到，在放旧数组中的数据时，重新计算了每个数组在新数组中的位置，
然后在放入数组中的链表是按照从头部放入的顺序插入的，也就是说扩容之后链表的数据被倒转了。

下面举个例子说明下扩容过程。假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。
其中的哈希桶数组table的size=2， 所以key = 3、7、5，put顺序依次为 5、7、3。在mod 2以后都冲突在table[1]这里了。
这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table的实际大小时进行扩容。
接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过程。

下面分析 下jdk8做了哪些优化

前面我们讲过HashMap中放入元素是根据hash值对HashMap的数组长度进行取模来进行定位的，
并且HashMap的Node数组每次扩容都会是原来的2倍.而且HashMap的原来的元素的hash值是不会变的。
如图的例子，a是扩容前的定位计算，b是扩容后的定位计算，key1，key1分别是两个元素的hash值

从图中可以看到，key1在扩容前后，它的位置都没有变，都是5。key2在扩容后位置从5变成了21。
我们可以发现数组原来的长度是16，并且扩容后n-1的二进制表示在最高位比原来多了1bit的（原来是1111，扩容后是1 1111）。
正是由于多出的这1位，在定位计算的时候如果元素的hash值在这1位上是0，那么它的位置就不会变，如果是1就会向后移动原来数组长度的位置。
根据这一特点，jdk8在扩容拷贝数据的时候就不需要重新定位计算元素的位置，只需要根据元素的hash值的需要多计算的这1位的值是0还是1就可以了，
并且不会把链表倒转

看下源代码：

 final Node<K,V>[] resize() {                                                            
    Node<K,V>[] oldTab = table;                                                          
    int oldCap = (oldTab == null) ? 0 : oldTab.length;                                   
    int oldThr = threshold;                                                              
    int newCap, newThr = 0;                                                              
    if (oldCap > 0) {                                                                    
        // 超过最大值就不再扩充了，就只好随你碰撞去吧                                    
        if (oldCap >= MAXIMUM_CAPACITY) {                                                
            threshold = Integer.MAX_VALUE;                                               
            return oldTab;                                                               
        }                                                                                
        // 没超过最大值，就扩充为原来的2倍                                               
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                            
                 oldCap >= DEFAULT_INITIAL_CAPACITY)                                     
            newThr = oldThr << 1; // double threshold                                    
    }                                                                                    
    else if (oldThr > 0) // initial capacity was placed in threshold                     
        newCap = oldThr;                                                                 
    else {               // zero initial threshold signifies using defaults              
        newCap = DEFAULT_INITIAL_CAPACITY;                                               
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);                  
    }                                                                                    
    // 计算新的resize上限                                                                
    if (newThr == 0) {                                                                   
                                                                                         
        float ft = (float)newCap * loadFactor;                                           
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?            
                  (int)ft : Integer.MAX_VALUE);                                          
    }                                                                                    
    threshold = newThr;                                                                  
    @SuppressWarnings({"rawtypes"，"unchecked"})                                         
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];                              
    table = newTab;                                                                      
    if (oldTab != null) {                                                                
        // 把每个bucket都移动到新的buckets中                                             
        for (int j = 0; j < oldCap; ++j) {                                               
            Node<K,V> e;                                                                 
            if ((e = oldTab[j]) != null) {                                               
                oldTab[j] = null;                                                        
                if (e.next == null)                                                      
                    newTab[e.hash & (newCap - 1)] = e;                                   
                else if (e instanceof TreeNode)                                          
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                   
                else { // 链表优化重hash的代码块                                         
                    Node<K,V> loHead = null, loTail = null;                              
                    Node<K,V> hiHead = null, hiTail = null;                              
                    Node<K,V> next;                                                      
                    do {                                                                 
                        next = e.next;                                                   
                        // 原索引                                                        
                        if ((e.hash & oldCap) == 0) {      // 判断新增的1位的值是0                              
                            if (loTail == null)                                          
                                loHead = e;                                              
                            else                                                         
                                loTail.next = e;                                         
                            loTail = e;                                                  
                        }                                                                
                        // 原索引+oldCap                                                 
                        else {                                                           
                            if (hiTail == null)                                          
                                hiHead = e;                                              
                            else                                                         
                                hiTail.next = e;                                         
                            hiTail = e;                                                  
                        }                                                                
                    } while ((e = next) != null);                                        
                    // 原索引放到bucket里                                                
                    if (loTail != null) {                                                
                        loTail.next = null;                                              
                        newTab[j] = loHead;                                              
                    }                                                                    
                    // 原索引+oldCap放到bucket里                                         
                    if (hiTail != null) {                                                
                        hiTail.next = null;                                              
                        newTab[j + oldCap] = hiHead;                                     
                    }                                                                    
                }                                                                        
            }                                                                            
        }                                                                                
    }                                                                                    
    return newTab;                                                                       
}                                                      

由于时间关系还有一些关于线程安全的问题以及jdk8与jdk7之间的性能差异，读者可以自行研究。

小结
1：HashMap的扩容是很消耗资源的，所以在使用的时候应该尽量估算好大小，给个初始值。
2：装载因子是可以改变的，但是最好不要改，除非特殊情况。
2：HashMap是非线程安全的，所以需要在并发的环境下使用的话请用ConcurrentHashMap。
3：Jdk8中对HashMap中增加了红黑树的结构，例HashMap的性能得到了提升。

本文参考互联网上其它一些资料，通过能jdk7,8的源码，进行的一些分析，如有错误敬请指出

如需转载请注明出处 http://www.cnblogs.com/taixuyingcai/