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遍历方式只遍历了一次，因此在效率上较前者有所提高。