集合类的深入理解

还是对自己的基础漏洞进行填坑~~~看了一些资料和Blog

今天是关于集合类的一丢丢姿势。

先说说map，Hashtable、HashMap、LinkedHashMap和 TreeMap都是Map的实现接口。其中hashmap和hashtable有所区别，

首先，HashTable 的大部分方法都做了同步，而 HashMap 没有，因此， HashMap 不是线程安全的。
其次，HashTable 不允许 key 或者 value 使用 null 值，而 HashMap 可以。
第三，在内部实现算法上，它们对 key 的 hash 算法和 hash 值到内存索引的映射算法不同。

那么，下面是HashMap的实现原理

1、HashMap 的实现原理

HashMap 内部维护一个数组，并且将 key 做 hash 算法，然后将 hash 值映射到内存地址，即数组的下标索引，这样就可以通过key直接取到所对应的数据。而对于发生碰撞的位置，则会维护一个链表，所有在同一位置发生碰撞的元素都会存放在同一位置的链表中。

如图 2，数组中的每一个元素都是一个 Entry 实例：

1 2 3 4 5 6 7

staticclass Entry<k,v> implementsMap.Entry<k,v> { finalK key; V value; Entry<k,v> next; inthash; //.....省略部分 }</k,v></k,v></k,v>

每一个实例都包含 元素key, 元素value , 元素hash值，以及指向下一个在当前位置发生冲突的 Entry实例。

也就是说，Map是由  一个包含指代内存地址哈希码的数组和由这些哈希码指代的地址起始的链表  组成的。

附上抄来的关于Put方法的过程理解：

/*
 * 将（key, value）放入 map
 */
publicV put(K key, V value) {
    if(key == null)
        returnputForNullKey(value);
    // 计算 key 对应的下标 。关于 hash 和 indexFor 方法，我们会在后面讲到。
    inthash = hash(key);
    inti = indexFor(hash, table.length);
    // 如果发生了冲突，那么就遍历当前冲突位置的链表。如果在链表中发现该元素已经存在(即两元素的 key 和 hash
    // 值一样)，则用新值替换原来的值，并返回原来的值。
    for(Entry<k, v=""> e = table[i]; e != null; e = e.next) {
        Object k;
        if(e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            // 将该元素的访问存入历史记录中（在LinkedHashMap才发挥作用）
            e.recordAccess(this);
            returnoldValue;
        }
    }
    // 标志容器被修改次数的计数器，在使用迭代器遍历时起作用
    modCount++;
    // 为新值创建一个新元素，并添加到数组中
    addEntry(hash, key, value, i);
    returnnull;
}

voidaddEntry(inthash, K key, V value, intbucketIndex) {
    // 如果数组需要扩容，则进行扩容
    if((size >= threshold) && (null!= table[bucketIndex])) {
        resize(2* table.length);
        hash = (null!= key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    // 创建新元素并添加到数组中
    createEntry(hash, key, value, bucketIndex);
}

/*
 * 创建新元素，并将该新元素加到下标位置的最前端，该新元素的next引用指向该位置原来的元素（如果有）
 */
voidcreateEntry(inthash, K key, V value, intbucketIndex) {
    Entry<k, v=""> e = table[bucketIndex];
    table[bucketIndex] = newEntry<>(hash, key, value, e);
    size++;
}</k,></k,>

好了，到了今天最主要的部分了，其实是为了弄清楚“当存在Hash码相同的两个键值对时如何区别”这个问题，面试时候问的，记得以前听到过但是忘了= =。太蠢，赶紧记下来。。

3、HashMap 的核心算法-hash 函数的实现

HashMap的高性能需要保证以下几点：

1、hash 算法必须是高效的
    2、hash 值到内存地址（数组索引）的算法是快速的
    3、根据内存地址（数组索引）可以直接取得对应的值

首先来看第一点，hash 算法的高效性，在 HashMap 中，put() 方法和 hash 算法有关代码如下：

 

publicV put(K key, V value) {
        if(key == null)
            returnputForNullKey(value);
        inthash = hash(key);
        inti = indexFor(hash, table.length);
        //...........省略部分
    }

 

 

finalint hash(Object k) {
        inth = 0;
        if(useAltHashing) {
            if(k instanceofString) {
                returnsun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // 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);
        returnh ^ (h >>> 7) ^ (h >>> 4);
    }

HashMap的功能是通过“键(key)”能够快速的找到“值”。下面我们分析下HashMap计算下标索引的思路：

1、 当调用put(key,value)时，首先获取key的hashcode，int hash = key.hashCode();
2、 再把hash通过一下运算得到一个int h。

hash ^= (hash >>> 20) ^ (hash >>> 12);
int h = hash ^ (hash >>> 7) ^ (hash >>> 4);

为什么要经过这样的运算呢？这就是HashMap的高明之处。先看个例子，一个十进制数32768(二进制1000 0000 0000 0000)，经过上述公式运算之后的结果是35080(二进制1000 1001 0000 1000)。看出来了吗？或许这样还看不出什么，再举个数字61440(二进制1111 0000 0000 0000)，运算结果是65263(二进制1111 1110 1110 1111)，现在应该很明显了，它的目的是让“1”变的均匀一点，散列的本意就是要尽量均匀分布。假设key.hashCode()的值为：0x7FFFFFFF， table.length为默认值16。它的详细运行过程如下图 3 所示。

图 3

3、 得到h之后，下一步便要解决，怎样通过 h ，得到元素的数组下标。

前面说过hashmap的底层采用数组盛放数据，所以我们当然希望这个hashmap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，这样当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表。 所以我们首先想到最简单的办法就是把hashcode对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。这也是 HashTable 采用的策略，HashTable中的算法只是把key的 hashcode与length相除取余，即hash % length，这样有可能会造成index分布不均匀。而且，“模”运算的消耗还是比较大的，能不能找一种更快速，消耗更小的方式那？java中是这样做的：

 

/**
     * Returns index for hash code h.
     */
    staticint indexFor(inth, intlength) {
        returnh & (length-1);
    }

将取得的 h 跟数组的长度-1做一次“与”运算（&）。看上去很简单，其实比较有玄机。比如数组的长度是2的4次方，那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问，为什么hashmap的数组初始化大小都是2的次方大小时，hashmap的效率最高，我以2的4次方举例，来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。

看下图 4，左边两组是数组长度为16（2的4次方），右边两组是数组长度为15。两组的hashcode均为8和9，但是很明显，当它们和1110“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到同一个链表上，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hashcode的值会与14（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个末尾都为1 的位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！

图 4

所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。

说到这里，我们再回头看一下hashmap中默认的数组大小是多少，查看源代码可以得知是16，为什么是16，而不是15，也不是20呢，看到上面annegu的解释之后我们就清楚了吧，显然是因为16是2的整数次幂的原因，在小数据量的情况下16比15和20更能减少key之间的碰撞，而加快查询的效率。

所以，在存储大容量数据的时候，最好预先指定hashmap的size为2的整数次幂次方。就算不指定的话，也会以大于且最接近指定值大小的2次幂来初始化的。