HashMap笔记

前言

HashMap还是挺重要的，因此参考着别人的博文自己归纳总结了一下。方便自己日后回顾，也方便其他人学习。参考文章在文章最后，都是很棒的文章，大家可以去看看。

正文

如何保证其容量为2的n次幂

HashMap的定义中规定，容量必须为2的n次幂。那么如何保证其容量为2的n次幂呢。
首先，如果是无参构造函数，生成的是容量为16的HashMap对象。
如果在构造方法中设置了容量值，即设置了initCapacity，那么在构造方法中通过如下代码来保证容量为2的n幂：

int capacity = 1;  
while (capacity < initialCapacity)  
    capacity <<= 1;  

譬如，你的构造方法中形参initCapacity为5，那么通过上面的代码，最终，capacity为8。因此容量为8。
即通过上面的三行代码，使得最终capacity的值大于等于initCapacity，且为2的n次幂。

为什么HashMap的容量必须为2的n次幂

那么，为什么HashMap的容量必须为2的n次幂呢。这是为了减少哈希碰撞。在HashMap的源码中，有一个获取数组下标的方法：

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

容量必须为2的n次幂的前提是我们获取bucketIndex值时使用的是位运算，h&(length-1)和h%length等价不等效，位运算的效率高很多，因此我们采用的是位运算。当容量为2的n次幂，length-1在二进制表示上就会是1个0和n个1，这样当执行h&(length-1)，得到的值就是在[0,length-1]这个范围中且最散列，即碰撞会最小。

加载因子

加载因子过高虽然可以更好的利用空间，但是却增加了查询的成本，也就是说哈希碰撞会更大。加载因子过小，虽然可以减少碰撞，但是却浪费了更多的内存空间。默认的加载因子为0.75在时间和空间成本上的一种折中。

重哈希

HashMap默认的初始容量为16，加载因子为0.75，因此最多能存放16*0.75个元素，也就是12个元素，这个值也称为阈值，即threshold。当放入第13个元素的时候，HashMap将发生rehash，rehash的一系列处理比较影响性能。当我们有很多映射关系要存储到HashMap中时，最好指定合适的初始容量，从而避免不必要的rehash操作。rehash方法中，通过transfer方法进行重哈希。(这是基于jdk1.6分析)在jdk1.8中，transfer方法和resize直接结合在一起。

这是jdk1.6中的transfer方法源码：

void transfer(Entry[] newTable) {

        // 将原数组 table 赋给数组 src
        Entry[] src = table;
        int newCapacity = newTable.length;

        // 将数组 src 中的每条链重新添加到 newTable 中
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;   // src 回收

                // 将每条链的每个元素依次添加到 newTable 中相应的桶中
                do {
                    Entry<K,V> next = e.next;

                    // e.hash指的是 hash(key.hashCode())的返回值;
                    // 计算在newTable中的位置，注意原来在同一条子链上的元素可能被分配到不同的子链
                    int i = indexFor(e.hash, newCapacity);   
                    //关键：将新的节点插入到新数组bucketIndex位置的第一个位置，并指向原来处于bucketIndex位置的节点（如果存在的话）
                    e.next = newTable[i];   //理解好，e表示的是被转移的节点
                    newTable[i] = e;
                    //e指向旧链表的下一个节点
                    e = next;               //e再次成为下一个要被转移的节点
                } while (e != null);
            }
        }
    }

fail-fast

HashMap所有集合类视图所返回的迭代器都是快速失败的（fail-fast），在迭代器创建在之后，如果从结构上对映射进行修改，除非通过迭代器自身的remove或add方法，其他任何方式的修改，都会导致迭代器抛出ConcurrentModificationException。

HashMap的数据结构

HashMap是由数组和链表组成，数组的长度为capacity。默认的capacity为16。当发生哈希冲突时，HashMap采用链地址法解决冲突。

hashcode方法和equals方法

在HashMap中，key是唯一的，那是如何确保key是唯一的呢。在HashMap中，并不是直接通过equals方法来与map对象中的每个key比较（这样效率会很低，这样如果已经存了1000个键值对，那么就得比较1000次），而是先通过key的hashcode方法获取hash值，再通过hash方法与indexOf方法获取到bucketIndex值，如果数组中下标的值为bucketIndex的位置为空，则直接将键值对存到该位置上，如果不为空，说明发生了哈希冲突，那么就要对该位置上的每个节点通过key的equals进行判断，若返回true，说明该key已存在，则用新的value值替代旧value值。若均返回false，则说明该key不存在，就将该键值对存放到bucketIndex对应的位置，即作为链表的第一个节点（并指向原来处于该bucketIndex位置的节点），从而形成新的链表。

HashMap允许key和value为空，而Hashtable和ConcurrentHashMap不允许key或value为空

HashMap最多允许一个key为null，但允许多个value值为null；Hashtable既不允许空的key，也不允许空的value。我们知道HashMap是线程不安全的，因此只使用于单线程下，当我们调用它的get（Object key）方法后，若返回值是NULL，则存在两种情况：一是该key对应的值就是null，二是HashMap对象中不存在该key。
那如何确认是属于哪一种情况呢，我们可以通过containsKey（Object key）方法，如果返回true，说明二不成立，一成立。如果返回false，说明二成立。
代码如：

if(map.containsKey(key))
    return map.get(k);
else
    throw new KeyNotPresentException();

但是对于Hashtable和ConcurrentHashMap此方法并不适用，因为这两个类适用于多线程下。举例来说，当线程A执行上述代码，执行完map.containsKey(key)返回true，说明该key是存在的。这时如果切换到了线程B，线程B中删除了该key对应的键值对。然后又切换回线程A，那么执行完map.get(k)就会返回一个null，这表示的是该key对应的value为null，而这是不正确的。因此，在Hashtable和ConcurrentHashMap中如果读取到的value值为null，说明该容器中不存在含有该key的键值对。

HashMap的遍历

①使用entrySet方法和iterator方法
②使用keySet方法和itreator方法

为什么String, Interger这样的wrapper类适合作为键？

String,Interger这样的wrapper类是final类型的，具有不可变性，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。

第一个桶中只存储键为NULL的一个键值对吗？

    private V putForNullKey(V value) {
        // 若key==null，则将其放入table的第一个桶，即 table[0]
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {   
            if (e.key == null) {   // 若已经存在key为null的键，则替换其值，并返回旧值
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;        // 快速失败
        addEntry(0, null, value, 0);       // 否则，将其添加到 table[0] 的桶中
        return null;
    }
    private V getForNullKey() {
        // 键为NULL的键值对若存在，则必定在第一个桶中
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        // 键为NULL的键值对若不存在，则直接返回 null
        return null;
    }

由上代码可知，当key为null，也会对第一个桶里的链表进行遍历。以及根据indexOf方法的方法体，return h&(length-1)，bucketIndex的范围是[0,length-1]。因此，第一个桶中不止存储键为NULL的键值对。

HashMap是线程不安全的

HashMap是线程不安全的，而Hashtable是线程安全的。另外可以通过java.util.Collections类的synchronizedMap方法将hashmap对象变成线程安全的对象。更好的，可以使用java.util.concurrent包下的ConcurrentHashMap类，这是线程安全的类，且效率比Hashtable更高。

HashMap是线程不安全的具体体现

①当多个线程同时使用put方法添加元素：假如两个put操作的key发生了碰撞（hash值一样），那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就有可能会发生————只添加了其中一个键值对（另一个添加进去的键值对被覆盖了）
②当多个线程同时检测到元素个数超过阈值threshold时，就会发生多个线程同时进行扩展操作。这样导致的问题是可能产生死循环、以及部分数据会丢失。详细原因参考 HashMap多线程并发死循环问题的分析，以及结合resize方法和transfer方法：

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;

        // 若 oldCapacity 已达到最大值，直接将 threshold 设为 Integer.MAX_VALUE
        if (oldCapacity == MAXIMUM_CAPACITY) {  
            threshold = Integer.MAX_VALUE;
            return;             // 直接返回
        }

        // 否则，创建一个更大的数组
        Entry[] newTable = new Entry[newCapacity];

        //将每条Entry重新哈希到新的数组中
        transfer(newTable);

        table = newTable;
        threshold = (int)(newCapacity * loadFactor);  // 重新设定 threshold
    }

要点1：根据上面的resize方法和transfer方法，每个执行resize方法的线程都会开辟一块新的内存空间，最终HashMap扩容后采用的是最后一个执行完transfer方法的那个线程开辟的空间。（该分析基于java6）
要点2：HashMap中存储的只是引用，而不是真的存储key和value对象。理解了这点，就能明白在[HashMap多线程并发问题死循环分析]的图解中，线程一的引用e和引用next为什么可以指向线程二中的指向的对象。

新增节点的放置位置

在jdk1.6和1.7中，新增的节点会插到链表的头部，而在jdk1.8中，新增的节点是插到尾部。
jdk1.8中，在HashMap中，创建新的节点是通过newNode方法，HashMap中的newNode方法如下：

    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

然后在putVal方法中，当bucketIndex位置不为空时且是链表时，执行的代码是：

if ((e = p.next) == null) {
    p.next = newNode(hash, key, value, null);

如代码所表达，p会一直遍历链表，直到p为最后一个非空节点，然后让p的next指向新节点。也就是把新增节点插入到链表尾部。

java8 HashMap 的红黑树相关内容

Java 集合深入理解（17）：HashMap 在 JDK 1.8 后新增的红黑树结构，这篇文章对HashMap的红黑树部分做了详细的讲解。

最后

参考文章：

HashMap深度解析(二)
Map 综述（一）：彻头彻尾理解
HashMap笔试面试题汇总解析
从源码理解HashMap(JDK1.8)
面试总结hashmap
HashMap多线程并发问题死循环分析