双列集合

Map 接口

1. map与collection并列存在，用于保存具有映射关系的数据：key-value；
2. map中的key和value可以是任意引用类型数据，会封装到HashMap$Node对象中；
3. map 中的 key 不允许重复，原因和 HashSet 一样，如果有相同的 key ，就会替换原来 key 对应的value 值；
4. map 的 value 可以重复；
5. map 的 key 可以为 null，value 也可以为 null，注意 key 为 null 只能有一个，value 为 null 可以有多个；
6. 常用String作为key；

7. 一对 k-v是放在一个Node中的，因为Node实现了Entry接口，所以一对k-v也叫做一个entry；

HashMap

HashMap 是 Map 接口使用频率最高的实现类，以 key - value 的形式存储数据，key 不能重复，但值可以重复，可以存储 null 键 和 null 值

字段

Node<K,V>[] table：Node 数组

Set<Map.Entry<K,V>> entrySet：存储所有的 Entry 类型的数组，便于获得所有的键和所有的值

int size：Node 的个数

int modCount：修改次数

int threshold：阈值，在 put 方法中，元素的个数超过这个阈值会进行扩容

float loadFactor：加载因子，默认为 0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f

构造函数

无参构造函数

初始化加载因子

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

有参构造函数

1. 判读初始化容量是否小于 0
2. 判断是否超过规定的最大值
3. 初始化加载因子和阈值

public HashMap(int initialCapacity) {
    // 调用另一个有参构造函数
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    // 初始化加载因子和阈值
    this.loadFactor = loadFactor;
    // 计算阈值
    this.threshold = tableSizeFor(initialCapacity);
}

计算阈值容量大小

分别右移 1,2,4,8,16 位，把原来的数的每一位上都填上 0 ，最后加一，就可以得到大于 n 的最小二次方

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

计算散列值和下标

1. 得到 hashCode 的值
2. 将 hashcode 右移 16 位
3. 与原来的 hashcode 的值 异或，达到异或高低位的目的， 这样就混合了原哈希值中的高位和低位，增大 了随机性。

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

4. 将 散列值和数组长度 - 1进行与运算，得出对应的下标位置

因为数组长度为 2 的 n 次方，减一后对应的二进制数为全1

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

底层数据结构

HashMap 的底层为 数组+链表和红黑树

transient Node<K,V>[] table;

HashMap的 put 方法

hashMap 的 put 方法 其实是调用了 putVal 方法

1. 判断 table 表示是否为空，若为空则进行扩容；
2. 根据 hash 计算数组下标，若下标对应的 table[i] 是否为空，为空则直接创建一个 Node 节点；
3. 先判断table[i]是否与传入的 hash 和 key 相同，相同的赋值给临时结点 e；
4. 接着判断table[i]是不是一个树结点，若为树结点则根据树的方式添加节点；
5. 接着遍历整个链表，若有相同的节点则结束，否则在链表尾部添加上新的节点，并赋值给临时结点 e；
6. 添加完后，则判断链表的长度是否大于等于 8 ，若大于则进行树化；
7. 给临时节点 e 添加上 value，这个临时节点 e 是为了 修改已经存在的 key 对应的 value 值；
8. 最后判断添加上新元素后，元素的个数 size 是否大于当前的阈值，若大于则进行扩容处理；

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 判断 table 表示是否为空，若为空则进行扩容；
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 根据 hash 计算数组下标，判断tabel[i]是否为空
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 先判断table[i]是否与传入的 hash 和 key 相同，相同的赋值给临时结点 e
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 接着判断table[i]是不是一个树结点，若为树结点则根据树的方式添加节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 接着遍历整个链表，若有相同的节点则结束
            // 否则在链表尾部添加上新的节点，并赋值给临时结点 e
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 若添加后链表的长度大于等于 8 则进行树化
                        treeifyBin(tab, hash);
                    break; 
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 为临时节点加上 value 值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 增加个数并进行扩容的判断
    if (++size > threshold)
        resize();
    afterNodeInsertion(e	vict);
    return null;
}

判断是否进行树化

1. 判断 table 数组是否为空 或者 table 数组的长度 小于 MIN_TREEIFY_CAPACITY，若满足这两个则先进行扩容处理；MIN_TREEIFY_CAPACITY 的值为 64
2. 两者都不满足才对该链表进行树化；

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

扩容机制

1. 获取旧的数组长度和旧的阈值

2. 数组的长度不为 0

   a. 新的数组长度扩为旧的数组长度的 两倍

   b. 新的阈值扩为旧的阈值的 两倍

3. 使用了有参构造后的第一次扩容

   a . 新的数组长度为旧的阈值（旧的阈值在有参构造中已经进行赋值了）

   b. 新的阈值大小为 新的数组长度 * 加载因子

4. 使用了无参构造后的第一次扩容

   a. 新的数组长度为默认值 DEFAULT_INITIAL_CAPACITY 16

   b. 新的阈值为 DEFAULT_INITIAL_CAPACITY 加载因子

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 数组的长度不为 0
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // 使用了有参构造后的第一次扩容
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    // 使用了无参构造后的第一次扩容
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 使用了有参构造 重新生成新的阈值
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 数据迁移部分
    ....
    return newTab;
}

扩容中的数据迁移

1. 遍历数组中的每一个桶位

2. 将桶位下的 链表 / 红黑树 进行遍历

3. 链表的判断：

   1. 用当前节点的 hash 值 & 旧的数组长度
   2. 若值为 0 ，则在当前节点的对应的数组下标不变；
   3. 若值不为 0，则当前节点对应的数组下标为 当前数组下标 + 旧的数组长度

4. 将上述两种情况分别赋值到相应的位置

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
    for (int j = 0; j < oldCap; ++j) {
        Node<K,V> e;
        if ((e = oldTab[j]) != null) {
            oldTab[j] = null;
            if (e.next == null)
                newTab[e.hash & (newCap - 1)] = e;
            else if (e instanceof TreeNode)
                ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
            else { // preserve order
                Node<K,V> loHead = null, loTail = null;
                Node<K,V> hiHead = null, hiTail = null;
                Node<K,V> next;
                do {
                    next = e.next;
                    if ((e.hash & oldCap) == 0) {
                        if (loTail == null)
                            loHead = e;
                        else
                            loTail.next = e;
                        loTail = e;
                    }
                    else {
                        if (hiTail == null)
                            hiHead = e;
                        else
                            hiTail.next = e;
                        hiTail = e;
                    }
                } while ((e = next) != null);
                if (loTail != null) {
                    loTail.next = null;
                    newTab[j] = loHead;
                }
                if (hiTail != null) {
                    hiTail.next = null;
                    newTab[j + oldCap] = hiHead;
                }
            }
        }
    }
}
return newTab;

原理：

因为扩容后的长度为原来的两倍，且计算下标索引的与运算时，只不过是前面多了个 1，这个1就代表旧的数组长度。那么，只需要判断原来的 hash 值 与 旧的数组长度 的值是否为0，如果为0，表示在与新的数组长度进行hash的时候，与前面的1无关，即为原值；否则就加上旧的长度即可；

获取元素

1. 判断 table 表是否为空，不为空才继续操作；
2. 根据 hash 获取相应的数组下标；
3. 然后根据 hash值 和 key值 进行比较，在链表或者树中找到相同的即可；

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

删除元素

1. 根据 hash值 和 key值找到对应的 Node 节点；
2. 若该节点为为树结点，则进行树的删除节点的逻辑；
3. 若该节点为链表上的节点，则将 node 前面节点的指针指向 node 后面的节点；

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}