说说对HashMap的理解

HashMap简介

HashMap继承至Abstract抽象类，是基于哈希表的Map接口的非同步实现，此实现提供所有可选的映射操作，并允许使用null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变 （摘至Api1.6中文文档）。下面就说说对HashMap的理解。

存数据过程:put

我们都知道，调用put()方法就可以往Map中添加数据。此过程api文档是这样说的：在此映射中关联指定值于指定键。如果该映射以前就包含一个该键的映射关系，则旧值被替换。现在我们就来理解一下这个过程。

 public V put(K key, V value) {
        if (key == null)//null键处理
            return putForNullKey(value);
        int hash = hash(key.hashCode());//重新计算hash值
        int i = indexFor(hash, table.length);//找到数组中的索引
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;//若索引处Entry不为null，则循环比较，找到相同的key替换旧值就返回
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        //没找到或者此处entry==null
        modCount++;//记录hashmap中修改结构的次数
        addEntry(hash, key, value, i);//添加数据
        return null;
    }

在上面这段代码中，有一个重要的内部接口：Map.Entry<K,V>，观其代码你会发现，其实每个 Map.Entry 就是一个 key-value 键值对。还有一个成员变量就是Entry类型的table数组（该数组的长度必须是2的n次方），Entry是一个内部类实现了Map.Entry接口。

 /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry[] table;

继续put方法，null键处理比较简单（先不说），接着看Hash值的计算：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。

hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。

 static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

可以看出此方法就是一个数学运算。 接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处

/**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

这个方法非常巧妙，它总是通过 h  & (table.length -1) 来得到该对象的保存位置；我们就来分析一下它为什么巧妙、高效。

两个原因：1.hashmap存放数据的table数组长度始终是2的n次方； 2.这里使用了(按位于&)运算符，而不是(取模运算%)。

且看HashMap构造函数中有以下代码：

// Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

这就保证了table数组的长度始终是2的n次方。（无参构造函数，默认初始化数组长度是16）。当length总是 2 的n次方时，h& (length-1)运算等价于h%length，但&比%效率高。

继续put方法，接下来程序就会根据indexFor方法返回的索引找到对应数组中的元素及其链表，并与put的key进行循环比较，若已存在相同的key，则替换value即可；若未匹配到，则程序进入addEntry方法：

  void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];//先存放此索引在table中的元素的引用
		//在new一个新的Entry对象，并指向上一步得到的对象的引用，这样就形成了链表结构
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)//当存放元素size到达极限时，
            resize(2 * table.length);//扩容（）
    }

比较简单，就是将新Entry对象存放在table[bucketIndex]处，并指向之前存放在此处的Entry对象，这样就形成了链表结构。

到这里，我想大家应该大致清楚HashMap的内部存储结构了，就是数组+链表结构，新加入的对象总是存放在数组中，通过引用指向老对象。画张图理解下：

从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项都可以形成一个链表。

读取数据：get

 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 链的下一个 Entry 
		 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 中），那系统必须循环到最后才能找到该元素。

capacity 和 resize

hashmap的数组Length始终是2的n次方，前面也提过在其构造方法中会保证这一点。关于容量问题：如果开始就知道 HashMap 会存放多个元素，可以在创建时设置较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity * load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。关于resize问题我们来看下代码：

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];//索引处的Entry对象e
            if (e != null) {
                src[j] = null;//将原数组此处引用设置为null
                do {
                    Entry<K,V> next = e.next;//拿到e的下一个对象引用
                    int i = indexFor(e.hash, newCapacity);//在新的数组容量中计算此hash值的索引位置
                    e.next = newTable[i];//将e下一个对象指向当前对象引用（恰好和原数据链表结构顺序相反参考addEntry方法）
                    newTable[i] = e;//将当前对象e存放到新数组newTable[i]中
                    e = next;
                } while (e != null);
            }
        }
    }

上述代码，逻辑比较清晰；在transfer方法，循环遍历扩容前table数组，若找到Entry对象就重定向其在新数组中的位置，并依次copy其指向的Entry对象。

简单归纳一下：HashMap就是底层一个Entry[]数组实现的，相同hashcode的entry对象放在数组同一位置（正确的说应该是，新放进来的对象存放在数组中，然后指向之前存放在此处的对象）形成链表。当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。但是，当数组存储位置有多个Entry对象时，不管是存还是取数据，都会循环遍历该链表；所以我们希望HashMap中存放的数据尽量均匀分布，即数组每个位置尽量只存放一个对象，那我们根据Hash算法找到位置后，不需要遍历就找到我们要找的元素了，这样效率最高。

性能参数，理解hashcode

这里总结一下与HashMap效率有关的参数：

1.HashMap容量（数组长度）必须是2的N次方。上面提过，利用Hash值求其存储位置的方法：h & (length-1)。

我们来举个例子：假设数组长度分别为15和16，优化后的hash码分别为8和9，那么& 运算后的结果如下

从上面的例子中可以看出：当8、9两个数和(15-1)₂=(1110)进行“与运算&”的时候，产生了相同的结果，都为0100，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链 表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hash值会与(15-1)₂=(1110)进行“与运算&”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！

只要保证length是2的N次方，效率自然就上去了，而这个sun公司已经做了，我们只管使用。

上面关于“h & (length-1)”例子及分析，来源于博客园的xwdreamer。写的挺好，我就拿过来了，感谢分享。

2.负载因子loadFactor，默认是0.75。

增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销（因为同一位置形成的链表数据增多），而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。

我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值，默认值0.75，,是时间和空间成本上一种折衷。

3.初始容量initialCapacity

在前面我们分析过HashMap扩容的过程，它会新创建一个数组（length为原来的2倍），然后循环从老数组中copy所有数据，个人认为还是比较耗时的，所以根据实际需要设置一个合理的初始容量还是很有必要的。

4.hashcode方法的实现 --- 参考Java理论与实践（哈希）

这个方法写得好，会使数据均匀分布，进而提高Hashmap的效率。

总结：虽然集合号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入集合中，只是在集合中保留这些对象的引用而言。也就是说：Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java 对象。本文所用源码全部基于JDK1.6， 鉴于作者水平有限，错误之处在所难免，还望博友留言指正，与君共勉。

参考资料：jdk_1.6_api文档、 HashMap源码、分析HashMap存储机制 、HashMap实现原理 、

附：LinkedHashMap 理解；  http://uule.iteye.com/blog/1522291