java集合类三-聊聊HashMap

目录

 

1 HashMap数据结构

2 构造函数

3 put方法

4 链表和红黑树互相转换

5 hashmap扩容

---

1 HashMap数据结构

HashMap底层是通过数组和单向链表来实现的。HashMap底层是一个数组，数组的每一项又是一个链表节点或者红黑树(jdk1.8)，如图所示

2 构造函数

这里看一个参数比较完整的构造函数

    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);
    }

initialCapacity：初始容量

loadFactor：负载因子，默认0.75

threshold：初始化table的时候数组大小。计算值是刚刚超过initialCapacity的2的n次幂

    /**
     * Returns a power of two size for the given target capacity.
     */
    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;
    }

感兴趣的话可以了解一下移位运算。数组大小是2的n次幂可以减小哈希碰撞，具体原因下文解释

3 put方法

首先看方法入口

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

首先是计算key的hash()

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

hashcode是int类型32位，这里让高位和低位做异或运算使得重新生成的hash更具有随机性

putVal核心方法

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            // 扩容
            n = (tab = resize()).length;
            // (n - 1) & hash,计算存放数组下标
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 如果待插入位置node的key和需要插入的key一致则覆盖
                e = p;
            else if (p instanceof TreeNode)
                // 红黑树插入
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 遍历到链表尾部添加元素
                        p.next = newNode(hash, key, value, null);
                        // 链表长度为8的时候尝试转红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            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)
            // 元素个数超过阈值(table数组大小*负载因子)则进行扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

这里说一下计算存放数组下标的方法：i = (n - 1) & hash

首先说明这里是进行按位与运算而不是对数组长度取模，原因是对于计算机来说位运算比取模运算要快

选择与运算的原因：与运算的结果是小于等于参与运算的较小元素。如果采用或运算则计算结果有可能数组越界

为什么table数组长度要是2的n次幂：让table中每个位置都可以存放到元素。数组下标是0到n-1，只有n是2的n次幂的时候，n-1的二进制每一位都是1，这样可以尽可能的填满整个table。如果n不是2的n次幂，则n-1的二进制存在位数为0的情况，则与运算后该位置还是0，所以该位置为1的table位置存放不了元素。比如n=15，n-1=14，14的二进制结果是1110，则1001，1011，1101这三个数组下标即9，11，13存放不了数据

4 链表和红黑树互相转换

链表->红黑树：链表长度>=8的时候尝试转成红黑树，TREEIFY_THRESHOLD默认值为8。如果table大小>=64开始真正的转红黑树

    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)
            // 如果table数组长度<64则扩容
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                // 如果table数组长度>=64则转红黑树
                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);
        }
    }

红黑树->链表

hashmap中有两个地方会把红黑树转成链表

• remove元素

这里是remove元素其中的一段代码，通过红黑树根节点及其子节点是否为空来判断是否转红黑树

            if (root == null || root.right == null ||
                (rl = root.left) == null || rl.left == null) {
                tab[index] = first.untreeify(map);  // too small
                return;
            }

• resize方法

resize方法会对红黑树进行拆分(split)，拆分方法有转链表操作

            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    // 红黑树节点个数<=6时转换成链表
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }

 

5 hashmap扩容

当元素个数超过table数组大小*负载因子的时候开始扩容。每次扩容后table容量变为原来的2倍