HashMap源码分析

HashMap源码分析
作者：十年砍材    撰写日期：2011-9-26

    HashMap是java中使用非常频繁的容器类，也是java笔试面试中经常会问到的。深入理解HashMap有助于我们更好的使用它。

    1. HashMap内部结构 
    了解HashMap的数据结构，有助于理解HashMap的各种操作。HashMap内部结构如下图：    

    由上图可知，整个HashMap内部构造是一个数组，数组元素是一个链表。熟悉哈希的应该知道，数组元素的存储位置使用哈希方法得到，而链表的作用就是解决哈希存在的冲突。
    HashMap中数组长度为2的整数幂，默认初始长度为16 ，装载因子为0.75。

static final int DEFAULT_INITIAL_CAPACITY = 16; 
static final float DEFAULT_LOAD_FACTOR = 0.75f; 
    初始化一个HashMap类，可以指定一个容量参数initialCapacity，构造函数会根据initialCapacity进行初始化，找到一个大于等于initialCapacity且为2的整数幂的值作为哈希数组的长度：

     int capacity = 1; 
     while (capacity < initialCapacity) 
            capacity <<= 1; 
     this.loadFactor = loadFactor; 
     threshold = (int)(capacity * loadFactor); 
     table = new Entry[capacity]; 

     HashMap 中存储的元素为Entry类，此类是HashMap中定义的内部类： 
      static class Entry<K,V> implements Map.Entry<K,V> { 
        final K key; 
        V value; 
        Entry<K,V> next; 
        final int hash; 
     } 

     其中key为存入的key值，value为存入的value值，next是指向下一个Entry元素的指针，hash为key的hashcode经过hash后的值。

2. HashMap中的各种操作
    插入操作put： 

 public V put(K key, V value) {
       if (key = = null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());  //对key的hashcode值重新hash
        int i = indexFor(hash, table.length);    //找到key在table中的放入位置        
        for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
                          //检查内部是否已存在key，若存在，则更新其value
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);  //将新的Entry<key,value>放入table中
        return null;
    }

    插入算法对key为null的情况进行了特别处理，HashMap会将key为null的值插入到table数组的一个位置所在的链表中。HashMap采用如下算法进行hash：

    static int hash(int h) {

        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);

    }

       addEntry算法将Entry<key, value>插入链表的头部

   void addEntry(int hash, K key, V value, int bucketIndex) {

      Entry<K,V> e = table[bucketIndex];
      table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
      if (size++ >= threshold)
          resize(2 * table.length);//数组扩容

    }

    插入元素后，检查数组中存放的元素是否超过门限值（数组长度*装载因子），若超过，扩展数组的长度为原来的2倍，并对原数组的元素重新进行哈希，并放入新数组中的新的位置。

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }
/**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    数组空间重新分配及数组元素重新哈希是非常耗时的，因此，在使用HashMap的过程中，如果可以预知存放元素个数的大致范围，可以在初始化一个HashMap时指定数组长度，从而可以有效避免重新哈希的情况。下面看HashMap是如何快速取值的：

public V get(Object key) {
        if (key == null)
            return getForNullKey(); //从数组第一个元素所在的链表取
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; 
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
}

    key等于null的情况比较简单，不再说明，对于key不为null的情况，首先通过hash方法，找到带查找的key所在数组中的位置，然后遍历相应的链表。

    遍历操作：

    由于hashMap中元素的存储位置与插入顺序无关，在遍历时，hashMap不保证遍历结果与插入顺序一致。HashMap通常使用keySet与entrySet进行遍历，keySet遍历方式将元素集的key值转换成一个Set，代码如下：

Map map = new HashMap();
　　Iterator iter = map.keySet().iterator();
　　while (iter.hasNext()) {
　　   Object key = iter.next();
　   　Object value = map.get(key);
　　}
entrySet将hashMap中存储的元素Entry转换成entrySet，其遍历方式如下：
 for(Map.Entry<Integer, String>m:map.entrySet()){
		   Object key=m.getKey();
          Object value=m.getValue();
 }

    这两种遍历方式在效率上有所差别：ketSet遍历了两次，第一次将元素集转换成keySet，第二次通过map.get(key)有遍历了一次；entrySet遍历方式只遍历了一次，因此在效率上较前者有所提高。