hashmap

1.HashMap构造函数:
//无参的构造函数

public HashMap() {
    //加载负载因子;
    //注意 这里并没有初始化shreshold,默认还是为0
	this.loadFactor = DEFAULT_LOAD_FACTOR;  
}

//传入容量参数的构造函数

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

//传入一个Map,核心是使用了putAll方法

public HashMap(Map<? extends K, ? extends V> m) {
	this.loadFactor = DEFAULT_LOAD_FACTOR;
	putMapEntries(m, false);
}

用户在构造HashMap时,不管有没有传入容量参数,HashMap在初始化的时候其容量都是为0;

因为HashMap使用的懒加载机制,只有你第一次向HashMap中添加元素(put)时,才进行第一次的容量设置

1.如果用户没有传入容量参数,那么调用的是无参的构造函数进行初始化,此时容量为0;

2.如果用户传入了容量参数,那么也只是将容量参数initialCapacity通过tableSizeFor方法找出距离该initialCapacity最近的2的幂次方数值,然后将该数值赋给了扩容阀值threshold;

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.HashMap开始put元素:
1.1 首先调用Val函数
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
1.2 putVal函数:
1.如果链表数组table为空,则直接进行扩容

2.用hash%n(等于(n-1) & hash),计算出要插入的元素A存放在table数组的哪个位置

如果该位置为空,则生成一个链表节点放入

3.如果该位置已经存在节点元素p

    3.1 如果p节点的key与要插入的元素A的key相同,则重新将p的value置为A的value

    3.2 如果不同,并且p节点为红黑树的子节点,则插入到红黑树中

    3.3 如果不同,且p元素为链表节点,则遍历该链表,如果出现3.1情况,直接break,没有的话          就插入到链表尾部

    3.4 如果链表长度大于等于8,调用treeifyBin函数尝试扩容,如果数组长度小于64则扩容,如          果大于64,则该链表转为红黑树
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未初始化或者长度为0,进行扩容
    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);
    // 桶中已经存在元素(处理hash冲突)
    else {
        Node<K,V> e; K k;
        // 判断table[i]中的元素是否与插入的key一样,若相同那就直接使用插入的值p替换掉旧的值e。
        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) {
                // 到达链表的尾部
                if ((e = p.next) == null) {
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    // 结点数量达到阈值(默认为 8 ),执行 treeifyBin 方法
                    // 这个方法会根据 HashMap 数组来决定是否转换为红黑树。
                    // 只有当数组长度大于或者等于 64 的情况下,才会执行转换红黑树操作,以减少搜索时间。否则,就是只是对数组扩容。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等,跳出循环
                    break;
                // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) {
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 修改的次数
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

1.3 插入元素后,可能会调用resize函数进行扩容:
1.如果数组table不为空,也就是oldCap>0,则说明已经被初始化过

    1.1 如果原来的容量大于2^31,则容量已经达到最大,无法扩容,直接返回

    1.2 如果扩容到两倍之后大于等于16且小于2^31(最大容量),则扩容到两倍

2.如果threshold>0

说明是通过传入容量参数(initialCapacity)的构造函数进行初始化的,newCap的值变为threshold,

在后面的判断中,threshold的默认值变为initialCapacity0.75,则newThr值为initialCapacity0.75

3.如果threshold=0,是调用的无参构造函数 ,threshold默认为0,则扩容到16,且决定是否扩容的newThr变量为默认容量*填充因子

4.如果newThr == 0,说明是走到2这个步骤的,也就是通过传入容量参数进行初始化的,则计算新的newThr

5.算出新的threshold(决定是否扩容,超过该值,则扩容)和newCap(数组容量),则开始新建一个扩容后的Node数组newTab,将oldTab的值移动到newTab中

遍历oldTab元素e,如果e不为空,则开始移动这一整个链表/红黑树的节点到newTab中。
如果当前元素e只有一个元素,则计算出放在newTab中的位置,也就是e.hash%newCap = e.hash&(newCap-1),再放入到newTab中。
如果当前元素e是红黑树节点,则调用split方法(在后面解释)
到这里,只可能是当前元素e有多个后继节点:
由于数组扩容了两倍,但是e.hash没有改变,会导致下标大于oldCap的位置是空着的,所以需要将e.hash小于oldCap的数组元素放入到原来的下标j中,将e.hash大于oldCap的元素放入到新的下标j+oldCap中
为什么这样,举个例子:e.hash=6,oldCap=5,则j=6%5=1,扩容后的数组长度为10,则 j=6%10=6,刚好等于j+oldCap。
将e.hash小于oldCap的数组元素,也就是低位的元素,通过loTail进行遍历,头节点 放入到loHead中, 同理,将e.hash大于oldCap的数组元素,也就是高位的元素,通 过HiTail进行遍历,头节点放入到HiHead中。
最后,将数组i中的各个链表元素一分为二,低位的去j,高位的去j + oldCap,返回 newTab数组

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) {
            // MAXIMUM_CAPACITY: 如果原来的容量大于2^31,则无法扩容,直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 如果扩容2倍之后大于等于16且小于2^31,则扩容一倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        // 如果threshold,table容量*(loadFactor=0.75)>0,说明初始的容量放在threshold中
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 如果原来的表还没有被初始化,threshold默认为0,则扩容到16
        // 且决定是否扩容的newThr变量为默认容量*填充因子  
        else {  // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算新的threshold(决定是否扩容的变量,新容量>table容量*(loadFactor=0.75),则扩                
        // 容)
        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;
                // 如果当前数组i元素有值
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 如果当前数组i元素只有这一个值,塞到新数组中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果当前数组i元素是红黑树的结点
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 如果当前数组i元素的链表有多个值
                    // 注意 数组扩容了两倍
                    // 但是e.hash不变,元素数组下标又需要改变
                // 所以需要将e.hash小于oldCap容量的放置在原来的下标j中,
                    // 将e.hash大于oldCap的放置在新的下标(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;
                            // 如果e.hash小于oldCap
                            // loTail类似于cur指针
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            // 如果e.hash大于等于oldCap
                            // hiTail类似于cur指针
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 将数组i中的各个链表元素一分为二,低位的去j,高位的去j + oldCap
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

((TreeNode<K,V>)e).split(this, newTab, j, oldCap)方法:

 final void split(HashMap<K,V> map, HashMap.Node<K,V>[] tab, int index, int bit)
    {
        HashMap.TreeNode<K,V> b = this;
        // Relink into lo and hi lists, preserving order
        HashMap.TreeNode<K,V> loHead = null, loTail = null;
        HashMap.TreeNode<K,V> hiHead = null, hiTail = null;
        int lc = 0, hc = 0;
        // 数组[i]的各个链表节点的值,低位转到数组[i]中,高位转换到数组[i+bit]中,
        // 有可能低位或者高位也要转换为红黑树
        for (HashMap.TreeNode<K,V> e = b, next; e != null; e = next)
        {
            next = (HashMap.TreeNode<K,V>)e.next;
            e.next = null;
            //  与resize函数类似++lc和++hc统计低位链表和高位链表的值
            if ((e.hash & bit) == 0) {
                if ((e.prev = loTail) == null)
                    loHead = e;
                else
                    loTail.next = e;
                loTail = e;
                ++lc;
            }
            else {
                if ((e.prev = hiTail) == null)
                    hiHead = e;
                else
                    hiTail.next = e;
                hiTail = e;
                ++hc;
            }
        }
 
        if (loHead != null) {
            // 如果低位的头不为空,且链表里面的个数小于等于6,把treeNode类型转换为Node类型,又将红黑树转为链表
            if (lc <= UNTREEIFY_THRESHOLD)
                tab[index] = loHead.untreeify(map);
            // 如果低位的头不为空,且链表里面的个数大于6,则重新生成红黑树
            else {
                tab[index] = loHead;
                // 如果低位的头不为空,且链表里面的个数大于6,高位为空的话,就把不用多此一举了,就让它全部在低位就行了
                if (hiHead != null) // (else is already treeified)
                    loHead.treeify(tab);
            }
        }
        if (hiHead != null) {
            if (hc <= UNTREEIFY_THRESHOLD)
                tab[index + bit] = hiHead.untreeify(map);
            else {
                tab[index + bit] = hiHead;
                if (loHead != null)
                    hiHead.treeify(tab);
            }
        }
    }
  • 21
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值