Java中HashMap底层源码学习(一)--基于JDK1.8

目录

1.成员变量

1）初始容量

2)最大容量

3)加载因子

4)链表转红黑树阈值

5)链表还原阈值

6)最小树形化容量阈值

2.节点内部类Node

3.构造方法

1)设置初始容量和加载因子的构造方法

2)只设置初始容量的构造方法

3)无参构造方法

4)参数为map的构造方法

---

1.成员变量

1）初始容量

设置了HashMap的初始化之后的容量位16，"1<<4"是指将二进制的1左移4位，相当于是1×2^4，也就是16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

2)最大容量

设置了Hash Map的最大容量，同上可知最大容量位1×2^30，这个数就非常大了，

1×2^30=10 7374 1824（长度为10亿多）

 static final int MAXIMUM_CAPACITY = 1 << 30

3)加载因子

HashMap初始化后默认的长度为16，当HashMap中元素的个数超过  容量*加载因子 的时候，会自动触发HashMap中的resize()方法进行扩容，也就是扩大两倍。

例子：如果是初始的HashMap默认容量为16，当HashMap中的元素个数超过16*0.75=12的时候，会触发resize()的方法扩容至32，具体的扩容原理我们会在后面的方法中详细解释。

 static final float DEFAULT_LOAD_FACTOR = 0.75f;

4)链表转红黑树阈值

HashMap的数据结构是数组+链表的，但是在JDK1.8版本以后HashMap增加了新的数组+红黑树的数据结构，单个hash槽内元素个数小于等于8的时候，是以链表形式存储数据，当单个hash槽内元素个数大于8个的时候，元素存储的结构就从链表结构转化为红黑树结构，虽然红黑树会消耗更多的存储空间，但是可以更高效地查询。

至于为什么阈值时8，这个与hashcode碰撞次数的泊松分布有关（不懂觉厉）而且当数组元素比较小的时候，即使遍历链表速度和遍历红黑树也不会有太大的差别。

static final int TREEIFY_THRESHOLD = 8;

5)链表还原阈值

当HashMap中单个hash槽内元素的个数超过8个后会转变为红黑树，那么同样的，当单个hash槽内元素的个数减少到一定数量的时候，单个hash槽内元素的结构也会从红黑树转为链表结构，这个临界点就是6

为什么两个临界点不一致？这是为了避免当元素个数在8个左右反复徘徊的时候链表结构转红黑树结构的运算消耗。

static final int UNTREEIFY_THRESHOLD = 6;

6)最小树形化容量阈值

当哈希表中的容量大于4*TREEIFY_THRESHOLD，也就是链表转红黑树阈值的四倍的时候，将链表转化为红黑树，TREEIFY_THRESHOLD是指的单个hash槽内元素的数据结构转红黑树的阈值，可以理解为key对应的value的数据结构，而MIN_TREEIFY_CAPACITY是指的哈希表中的容量，可以理解为key的数据结构

static final int MIN_TREEIFY_CAPACITY = 64;

2.节点内部类Node<K,V>

这是链式数据结构的Node节点,里面的Node<K,V> next 指向的时链式数据结构的下一个数据节点。

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;//指向下一个节点

        Node(int hash, K key, V value, Node<K,V> next) {//内部类的全参构造
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        //gets和sets的方法，以及重写toString方法
        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

3.构造方法

1)设置初始容量和加载因子的构造方法

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)//设置的初始容量小于0，则抛出异常
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//设置的初始容量大于最大值2^30，则把初始容量设置为该最大值
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//加载因子小于零或者不是float类型则抛出异常
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);//把初始容量传递给tableSizeFor方法计算出hashmap的容量。（其实就是乘以2）
    }

2)只设置初始容量的构造方法

我们在设置初始容量的时候尽量设置为2^n的值，比方说64，128，1024等等，这种构造方法我们使用的不多，但是当我们知道要存入的数据数量的时候可以通过设置提高效率，避免了反复调用resize()方法扩容。

假设我们要存入1000个数据的时候，初始容量可以设置为2048！注意，不是1024，因为如果设置为初始容量1024的时候，当数据量达到1024*0.75=768的时候就会调用resize()方法进行扩容了。

public HashMap(int initialCapacity) {
         //调用第一个构造方法，把initialCapacity和默认的加载因子0.75传过去
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

3)无参构造方法

这也是我们用的比较多的一个构造方法，

Map<key,value> map = new HashMap()就是调用的这个方法

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 加载因子设置为默认的0.75，此时的初始容量为16
    }

4)参数为map的构造方法

该方法将传递过来的map复制，加载因子设置为默认的0.75，这里时调用了 putMapEntries()方法来复制entry数组以及map的一些基本设置，我们会在方法模块中继续讲解该方法。

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;//设置加载因子为默认的0.75
        putMapEntries(m, false);
    }