Hashmap源码分析

最新推荐文章于 2024-10-11 10:08:02 发布

Fenglin1994

最新推荐文章于 2024-10-11 10:08:02 发布

阅读量140

点赞数

分类专栏： Java 文章标签： hashmap java

本文链接：https://blog.csdn.net/Fenglin1994/article/details/119774739

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Hashmap源码分析

前置知识

Hashmap的类属性

	/**
     * 默认初始化容量16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量为2的30次方
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默认加载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 当链表长度大于等于TREEIFY_THRESHOLD，就会转为红黑树
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 当红黑树数量少于等于UNTREEIFY_THRESHOLD，就会转为链表
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 红黑树最小容量
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

	/**
     * 存放放置的数据
     */
    transient Node<K,V>[] table;

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * 每存放一个数据，该值加1，在进行扩容时，就是判断size是否已经达到threshold
     */
    transient int size;

    /**
     * 修改的次数
     */
    transient int modCount;

	/**
	 * 阈值，如果没有指定，就是DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR
	 * 如果指定了初始容量，那初始容量就是阈值
	 */
    int threshold;

    /**
     * 实际的加载因子，如果用户没有指定就是DEFAULT_LOAD_FACTOR
     */
    final float loadFactor;

构造方法

无参的构造方法

Map<String, String> map = new HashMap<>();

方法体内容

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

单参数构造方法

// 参数1：初始容量&阈值
Map<String, String> map = new HashMap<>(8);

方法体内容

// 使用默认加载因子
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

两参数构造方法

// 参数1：初始容量&阈值		参数2：负载因子
Map<String, String> map = new HashMap<>(8, 0.75f);

方法体内容

// 参数1：初始容量		参数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;
    // 将阈值设置成2的整数倍
    this.threshold = tableSizeFor(initialCapacity);
}

hashmap通过tableSizeFor(initialCapacity)方法将初始化阈值设置成2的幂次方

// 或操作（|=）  补零右移位操作（>>>）
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    // 表示将n右移1位后的结果与n相与，例如n=2，执行后结果为：n = n | (n >>> 1),即n=3
    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;
}

put方法

// 参数1：key	 参数2：value
public V put(K key, V value) {
    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return 返回key的上一次结果，没有就返回null
     */
    return putVal(hash(key), key, value, false, true);
}

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;
    // 判断map中的数组是否已经被创建
    if ((tab = table) == null || (n = tab.length) == 0)
        // 如果没有创建，就通过resize()方法去创建默认初始容量长度的数组，并返回数组长度。
        n = (tab = resize()).length;
    // 将key的hash值与数组长度进行与运算，判断数组中是否已经存在节点(Node)
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 当数组中不存在节点时，就创建一个节点，并放置到数组第i个位置
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 发生hash碰撞后，如果数组中有值，判断hash是否相等，并且key值也相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)// 判断是否为红黑树
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 下面的整体操作都是为链表增加下一个节点
            for (int binCount = 0; ; ++binCount) {// 轮询，这里的binCount用于判断是否转红黑树
                if ((e = p.next) == null) {
                    // hash碰撞后，获取碰撞节点的next节点，如果为null，就去创建新节点，并将碰撞节点的next属性设置为新节点，形成链表结构
                    p.next = newNode(hash, key, value, null);
                    // 判断链表长度是否大于等于红黑树阈值，如果条件为true，就转为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);// 转为红黑树
                    break;
                }
                // 如果下一个节点不为null，就去判断hash和key是否相同，如果存在相同，就直接中断轮训
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 如果通过hash计算后，找到了对应节点
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // 是否覆盖原有值，或原有值为null
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);// 这是个空方法
            return oldValue;// 返回之前的老值
        }
    }
    ++modCount;
    // 比较当前存放数量是否大于阈值，如果大于，就扩容
    if (++size > threshold)
        resize();// 扩容方法
    afterNodeInsertion(evict);// 空方法
    return null;
}

数组的构造方法：

Node(int hash, K key, V value, Node<K,V> next) {
    this.hash = hash;
    this.key = key;
    this.value = value;
    this.next = next;
}

resize扩容

final Node<K,V>[] resize() {
    // 计算新数组容量和阈值
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 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];
    table = newTab;
    // 下面的方法才是扩容的核心方法
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {// 遍历的次数等于老数组的容量
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {// 获取老数组的第j位
                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
                    // 执行到这里，就肯定是个链表
                    // loHead: 低位头	loTail：低位尾
                    // hiHead: 高位头	hiTail：高位尾
                    // 下面的处理方式就是把一个链表拆分为高低位两个链表
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 特别注意的点，这里直接用的老的容量oldCap，
                        // 以oldCap= 16举例，之前就算存放位置都是oldCap - 1，结果肯定是1111
                        // 现在用的是oldCap，结果就是10000
                        // 10000 & 01010 如果等于1，说明是高位，如果等于0说明是低位
                        // 10000 & 11010
                        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);
                    // 如果低位尾不为空，说明低位有值，将loHead链表放置到j的位置
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 如果高位尾不为空，说明高位有值，将hiHead链表放置到j+oldCap的位置
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}