Java之HashMap源码分析(第二篇:添加元素)

(注意:本文基于JDK1.8)(文章版本:v1.0)

前言

    在第一篇文章中,我着手分析了HashMap对象的创建,创建HashMap对象是为了使用它提供的功能,这篇一起学习HashMap添加元素的功能是如何实现的?

    假设你有一个Person对象需要保存到HashMap容器中,此时你需要先准备一个Key对象,存储的Person对象则作为Value对象,以后你只需要使用Key对象就可以从HashMap对象中查找到存储的Person对象,那么这个Person对象是如何添加到HashMap中的呢?我们继续深入到HashMap的代码中一探究竟

    先罗列一下HashMap添加元素的方法有哪些?

    上图2个红圈为HashMap添加元素的方法,我们经常使用的是以put开头的方法,所以本篇文章主要分析put开头的方法,compute开头的方法将在单独的文章中进行分析,简单描述下每个put方法的特点(功能)

1、put()方法:添加单个元素的方法,每当传入的Key对象在HashMap对象中不存在,会新增一个Key-Value到HashMap中,如果Key对象已经存在于HashMap中,则会覆盖Key对象对应的Value值,每当新增一个Key-Value时,put()方法的返回值为null,若覆盖了原有的key-value中的Value值,则put()方法返回的是旧的Value对象(注意:可以利用返回值做业务逻辑的判断,比如==null代表新添加元素,不为null则为覆盖元素)

2、putAll()方法:添加多个元素的方法,将另一个Map中的所有元素都添加到当前HashMap对象中,这个方法没有返回值

3、putIfAbsent():添加单个元素的方法,不过它有要求。当Key对象不存在HashMap中时,会添加Key-Value到HashMap对象中,如果Key对象已经存在且对应的Value对象为null,也会将新的Value对象覆盖掉旧的Value值null。如果Key对象已经存在于HashMap中,且Value不是null,则不会进行覆盖Value的操作,只会返回旧的Value对象(注意:根据putIfAbsent()方法的特点,在需求中使用即可)

    接下来分析put开头的所有方法,先从put()方法开始分析,put()方法用于添加一个元素……

put()方法分析

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

    用于添加单个元素的方法,传入的第一个参数是参数类型为K的Key对象,传入的第二个参数为参数类型是V的Value对象(备注:类型参数与HashMap对象创建时,指定的泛型有关),看下方法体的执行逻辑

1、首先二次计算出一个新的hashCode值

将传入的Key对象再传入到一个静态方法hash()中(见本文下方),静态方法hash()将二次计算出一个新的hashCode值,这个新的值会传入到putVal()方法中

2、调用pulVal()方法添加元素

putVal()方法需传入5个参数,第一个参数表示hashCode值(此处传入的正是静态方法hash()的返回值),第二个参数为Key对象本身,第三个为Value对象本身,第四个参数为一个标志位,第五个参数也为一个标志位,后面详细分析pulVal()方法的实现,这里暂时不表

3、向调用者返回添加元素的结果

putVal()方法的返回值,表示添加元素的结果,return 语句会将结果返回给调用者,当返回值为null,说明是新增元素,返回值不为null,说明是覆盖元素(修改元素)

接下来我们先认真学习静态方法hash(),它的方法体中对传入的Key对象做了什么?为何要二次计算出一个新的hashCode值?

静态方法hash()分析

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

    用于计算出一个新的hashCode值的静态方法,传入的参数为Key对象,hash()方法使用static修饰,还有final修饰,表示此静态方法不允许被隐藏,它是如何计算出一个新的hashCode值的呢?(备注:Java中的每个类都是Object的子类,所以每个对象都可以调用hashCode()方法)

1、定义局部变量h,用于保存对象的hashCode值

首先创建一个称为h的临时局部变量,局部变量h用来存储传入的Key对象的hashCode()方法的返回值,这个hashCode()方法的返回值,平时都称为对象的哈希值(对的hashCode值)

2、分别处理Key对象为null与非null的业务逻辑(HashMap支持key为null)

在静态方法hash()的内部对于Key对象为null、或者Key对象为非null的两种情况分开处理,看下是如何处理的?

a、当Key对象为null时,静态方法hash()直接为调用者返回一个0……

b、当Key为非null时,做了3件事,最后返回一个整型值作为新的hashCode值,这个返回的整型值会作为pulVal()方法中接受的第一个参数(注意:静态方法hash()返回的整型值不是哈希地址,只有实际指向数组中存储位置的值才是哈希地址(下标值、桶值),此整型值是根据Key对象的hashCode()方法的返回值进行二次计算后一个整型值,我称它为新的hashCode值,或者新的哈希值),做了哪3件事呢?

第一:调用Key对象的hashCode()方法获得返回的hashCode值,这个hashCode()方法是每个对象都有的,它默认实现在Object类下,它会返回一个整型值,然后将返回的整型值赋值给局部变量h进行存储

第二:基于局部变量h存储的整型值(对象的hashCode值)进行无符号右移16位操作,再次得到一个无符号右移后的临时新值(>>>代表无符号右移,无论正数还是负数,高位通通补0)

第三:局部变量h存储的原值与上一步生成的临时值进行一个异或运算(异或:相同为0,不同为1)

3、向调用者返回值(两种情况)

第一种:当key对象为null时,返回0

第二种:将经过异或计算后的值返回(原值与右移16位的值进行异或运算)

    此处为何要构造一个对象的hashCode()返回值进行右移16位后的临时值呢?这个操作会将原有对象的hashCode()方法的值,所有高位值全部右移到低位(左侧移到右侧,高位在左,低位在右),然后再将局部变量h与h右移16位后的临时值执行一个异或运算。(对象的hashCode()方法返回值与右移16位的值进行异或运算,得到一个新的hashCode值)

    看来构造这个右移16位的临时值的目的是为了进行一个异或运算,那么为什么最后要对原对象的hashCode()值再和1个右移16位的值进行异或计算呢?

    答:因为异或运算后的值(二次计算后的hashCode值)可以帮助HashMap对象减少插入元素时,发生Hash碰撞(哈希冲突)的概率,有人做过实验,如果不使用静态方法hash()与使用静态方法hash()的之间会有30%的碰撞概率差,使用静态方法hash()处理后,哈希碰撞可以下降整整30%的概率,牛逼!(文章结尾见一个图表,是别人画的,不扰动前的值低位总是0)

    注意:静态方法的hash()被称为扰动函数或者二次扰动函数!

未加扰动函数hash(),去计算哈希地址的过程如下:(若看不明白,回头再来看)

原HashCode1954974080111 0100 1000 0110 1000 1001 1000 0000 (缺点:低位总是0)
2^4-1=15(length-1)数组容量-1的值15000 0000 0000 0000 0000 0000 0000 1111
&(位与)运算0000 0000 0000 0000 0000 0000 0000 0000(造成桶值总是0,冲突多)

加上“扰动函数hash()”后,计算哈希地址的过程如下:(若看不明白,回头再来看)

原HashCode1954974080111 0100 1000 0110 1000 1001 1000 0000
(>>>16)原HashCode值无符号右移16位后的值29830000 0000 0000 0000 0111 0100 1000 0110(无符号右移,高位统统补0)
^(异或)运算:原HashCode值与右移16位后的值进行异或运算1955003654111 0100 1000 0110 1111 1101 0000 0110
2^4-1=15(length-1) 数组容量-115000 0000 0000 0000 0000 0000 0000 1111
&(位与)运算:异或后的值与数组容量-1的值进行位于运算,计算出哈希地址(桶值 )6000 0000 0000 0000 0000 0000 0000 0110(桶值为6)

分析完用于减少哈希冲突的静态方法hash(),抓紧分析一下putVal()方法,putVal()方法实际实现了插入元素,话不多说,我们继续学习putVal()方法

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;
        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))))
                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);
                        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)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    putVal()方法用于实际插入元素,它接受5个参数,第一个int值表示Key对象对应的hashCode值,第二个是Key对象,第三个是Value对象,第四个是boolean标志位,最后一个也是个boolean标志位

第一个参数hash,传入的是静态方法hash()计算后返回的一个值,这个新值是根据Key对象的hashCode()返回值进行二次扰动后(一次右移16位、一次异或)的整型值(也称为二次扰动后的哈希值),并不是桶的地址(哈希地址)

第二个参数为传入的Key对象(通过Key对象可以查找到我们存储的元素对象)

第三个参数value为传入的Value对象(我们需要保存的元素对象)

第四个参数onlyIfAbsent,是个标志位,false代表若key对象存在,则仍然覆盖掉旧的Value对象

第五个参数evict也是一个标志位,一般它的传入值为true,这个参数只在afterNodeInsertion(evict)方法中使用了(这个方法是个空实现,如果为false,代表处于创建模式,以后LinkedHashMap会用得到……)

putVal()方法比较长,我将按照顺序逐步分析它的方法体,将每一部分代码拆分出来进行分析,这样阅读起来相对容易一些

  一、准备环境,创建需要用到的局部变量

        Node<K,V>[] tab; Node<K,V> p; int n, i;

1、定义局部变量tab,用于临时保存HashMap对象持有的底层数组对象table

2、定义局部变量p,用于存储在当前桶(数组下标)中取出来的Node对象

3、定义局部变量n,用于存储HashMap底层数组的长度

4、定义局部变量i,用于存储桶地址(数组下标,也称哈希地址)

  二、为新创建的HashMap对象,初始化持有的数组对象

        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

目的:第一次使用HashMap对象添加元素时,为HashMap对象持有的底层数组对象进行初始化

1、为局部变量tab赋值

HashMap对象持有的实例变量table会赋值给局部变量tab,此时tab指向HashMap对象持有的数组对象

2、接着检查tab的值是否已经初始化,这里使用tab==null进行判断

3、如果tab不为null的情况,继续检查数组对象的长度是否为0

先提取数组对象的长度,由局部变量n负责保存,接着比较数组的长度

4、没有创建数组对象或者数组长度为0时,执行扩容操作

若tab为null或者tab底层数组长度为0时,会立刻执行resize()方法进行数组扩容,resize()方法返回的新数组对象会赋值给tab存储上

5、接着又立刻取出新的数组对象tab的长度length,再赋值给局部变量n

注意:作者此处将初始化数组与扩容数组的代码放到了一起……好厉害……

  三、无冲突时,直接在桶中插入结点对象

目的:没有哈希冲突,直接插入元素

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

1、计算哈希地址,也称桶地址,并保存在局部变量i中

使用n-1的值(数组长度减去1为奇数值) 在与传入的局部变量hash表示Key对象的哈希值进行一个按位与运算,计算结果称为哈希地址(也称桶的下标),再将该值由局部变量i存储

2、从数组对象tab中取出保存的Node对象,并保存在局部变量p中

从数组tab[i]处取出对应的Node对象,并赋值给局部变量p保存

3、检查桶地址(数组下标)处是否持有元素对象

从桶中取出来的Node对象是否为null,代表是否存在元素,若 p == null为true,则说明底层数组的桶中没有持有Node对象,即没有存储任何元素,此时该下标处可直接插入元素

4、创建表示结点的Node对象

调用newNode()方法创建Node对象,newNode()方法传入4个参数,它会创建并返回一个Node对象,该Node对象持有传入的hash参数(Key对象二次扰动后的hashCode值)、持有传入的key对象、以及传入的value对象、传入的next对象,next用于指向下一个Node对象,此处会传为null,因为此处是第一次创建结点对象(next用于构建单链表),以下是newNode()方法的方法体

    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

5、将创建好的Node对象保存到哈希地址中(数组下标中)

将newNode()方法返回的Node对象赋值给底层数组对象对应的桶地址(局部变量i存储着这个桶地址),这就完成了一个插入元素的操作,可见数组对象实际存储的是Node对象,而Node对象又持有着Key对象与Value对象

            tab[i] = newNode(hash, key, value, null);

四、出现哈希冲突,插入新的元素或者覆盖旧的元素

目的:插入元素时,若数组对象对应的桶地址中(数组下标)已经存储着元素,此时局部变量p != null

        else {
            Node<K,V> e; K k;
            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);
                        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;
            }
        }

先重温一下桶的概念,在哈希表(HashMap)中,数组持有元素的位置(数组下标),称为桶。

举个例子:有一个数组容量为10,代表有10个桶,下标值从0-9,都是桶地址,也称数组下标。

1、定义局部变量,用于保存数据

局部变量e,用于保存桶地址中存在的Node对象

局部变量k,用于保存桶地址中某一个Node对象持有的key对象

局部变量p,用于保存当前桶地址中获取到的元素对象(Node对象)

备注:注意进行哈希冲突判断时,最先给局部变量p进行赋值,只有p != null时,代码才会走到这里!

2、对三种不同的哈希冲突情况分别进行处理,依次判断是哪种冲突情况

第一种情况:检查是否为同一个Key对象

if (p.hash == hash &&
    ((k = p.key) == key || (key != null && key.equals(k))))
    e = p;

    局部变量p指向的是当前从数组下标中获取到的Node,比较是否为同一个Key对象,用了如下方式 

先比较Key对象的hashCode值是否相同:将Node对象持有的hash字段值与传入hash字段值进行比较,如果相同则继续比较

然后比较Key对象是否为同一个:先用==判断key对象是否为同一个,p.key == key,如果key对象不是同一个,继续进行比较,继续比较的前提是key对象不是null(HashMap支持Key为null),再使用Key对象的equals()方法进行判断,若Key对象的equals()方法返回true,也可以证明key对象相等

上面两个条件满足的情况下,说明找到相同的Key对象,接着将局部变量p指向的Node对象赋值给局部变量e,此时e保存着已经存在的Node对象

(注意:key使用自定义对象,一定要保证两个Key对象的equals()方法相等时,hashCode()方法的返回值也一定相同,如果重写了equals()方法,则一定要重写hashCode()方法,否则Key对象将不能在HashMap中正常工作,跟这里判断Key对象是否为同一个有关)

(注意:key对象不一定非要重写equals方法与hashCode方法才能作为HashMap的key对象,Object自带的方法就可以作为HashMap中的key对象的要求,这是因为HashMap中key是否相同,先使用==进行了判断是否为同一个对象,而Object自带的equals方法与hashCode方法,一定会保证同一个对象equals方法判断相等(证明是同一个对象)时,hashCode值一定相等!!重写equals()方法时,往往是因为需求,比如,有两个对象,它们只要id一样,就代表同一个人,这样的需求出现时,就得重写equals()方法

第二种情况:桶地址保存的结构为红黑树

else if (p instanceof TreeNode)
    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

代码执行到这里,说明Key对象肯定不相同

  首先检查元素对象是否为红黑树结点对象,即TreeNode对象,如果是则证明当前桶地址中保存的结构是红黑树结构

  接着先将局部变量p强制转换为TreeNode对象

  然后将相关的参数,HashMap对象、数组对象tab、hash、key对象、value对象,共计5个参数一起传入到表示红黑树结构的TreeNode对象的putTreeVal()方法中

  最后putTreeVal()方法的返回值会赋值给局部变量e,局部变量e表示已经存在的结点对象

备注1:位于TreeNode类中的putTreeVal()方法内部产生两种逻辑,第一是插入的key对象不存在,则新增一个结点到红黑树中,此时putTreeVal()方法会返回null并赋值给局部变量e,第二是插入的key存在,则也会找到该Tree结点

备注2:代码中有一个类型转换,就是将p这个静态类型强行做了一个向下转型为TreeNode,因为TreeNode继承了Node,所以这里转型是可以的,目的就是为了调用putTreeVal()方法,putTreeVal()方法太复杂了,我要单独总结,红黑树是我的噩梦

第三种情况:桶地址保存的是单链表

else {
    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
                treeifyBin(tab, hash);
            break;
        }
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            break;
        p = e;
    }
}

代码执行到这里,说明桶地址中的Key对象既不相同、也不是红黑树结构,这里的情况属于单链表结构(单个元素的单链表也是可以的,所以还包括单个元素的情况)

定义for循环用于遍历单链表中每个元素,看下for循环中的代码逻辑

  首先定义局部变量binCount,用于记录遍历了几个元素,为后面进行单链表转红黑树结构做准备。

  接着从桶地址取出来的第一个当前Node对象p,再检查Node持有的next结点,并赋值给结点e

  然后判断e是否为==null,如果条件成立,说明已经到达单链表的最后一个结点(假设单链表就1个结点,那也算到达最后一个结点)

  单链表最后一个结点的情况下,先调用newNode()方法,方法返回Node结点对象,然后赋值给当前结点对象p持有的实例变量next,此时等同于将新的结点对象插入到单链表(尾插法

  检查是否需要将单链表转红黑树结构:先判断binCount的数量,若大于等于TREEIFY_THRESHOLD - 1,TREEIFY_THRESHOLD的值为8,这里为什么要减去1呢?假设遍历到了单链表的最后一个结点时binCount值为6(0-6,已经7个),那么加上这次已经添加的一个结点,刚好单链表的长度已经是8了,借此判断单链表的长度大于等于8时,尝试调用treeifyBin()方法将单链表结构转为红黑树结构,为什么说是尝试转换呢?treeifyBin()方法结束后

  由于已经达到单链表的最后一个结点,所以会通过调用break结束for循环(遍历单链表)

  若遍历到的结点不是单链表中的最后一个结点,会进行Key对象的判断,仍是先取出结点对象持有的hash值与传入的hash对比,若值相等,再继续用==判断、==如果还是不同,则再用equals判断key对象是否相同,只要有一个条件证明key对象相同,则说明持有的相同Key的结点对象已经存在单链表中,此时会调用break去终止for循环

  p = e,这行代码很孤独,只有在单链表中没有找到相同Key对象时,由于for循环遍历单链表的需要,将更新局部变量p指向桶地址中单链表中的下一个结点

出现Key对象相同,执行覆盖Value对象的行为

            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

3种冲突的情况都可能造成局部变量e不为null,局部变量e保存着与Key对象相同的Node对象,说明找到了Key对象已经存在的结点对象,此时执行覆盖Value

  首先取出现有Node对象中持有的value对象

  接着做两个判断

  检查onlyIfAbsent标志位、以及检查另外一个取出来的value对象是否指向null,有一个为真,则会覆盖Value的操作

  然后调用afterNodeAccess(e)方法,该方法是留给子类去实现的,HashMap中是一个空实现(模版方法设计模式)

  最后向调用者返回旧的Value对象(覆盖行为,将造成后续代码不会继续执行)

  备注:put()方法调动时,传入的是onlyIfAbsent == false,表示Key对象即使存在也覆盖Value对象

五、添加新的元素,检查是否需要扩容

只有新增一个元素后,才会执行到这里,覆盖value是不会走到这里的!

++modCount;
if (++size > threshold)
    resize();
afterNodeInsertion(evict);
return null;

1、防止多线程下使用添加元素

先是modCount增加1,防止并发下使用HashMap一边遍历,一边进行增、删操作的行为(fail-fast机制)

2、先更新HashMap对象持有的元素总数

size+1,代表HashMap中的元素数量增加1个

3、检查是否需要扩充数组对象的容量

判断新的元素总数是否大于扩容阈值threshold(注意:不包括等于),若大于该阈值,会调用resize()方法进行扩容

4、为LinkedHashMap做嫁衣

接着调用一个afterNodeInsertion()方法,它是一个空实现,留给子类去实现(LinkedHashMap)

5、向调用者返回结果

最后返回null,说明是新添加一个元素

注意:JDK1.8的HashMap是先增加新的元素,然后再去做检查数组容量是否需要扩容

单链表转红黑树的treeifyBin()方法(该方法在四个地方被调用,红黑树复杂,将单独总结)

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

treeifyBin()方法用于将单链表结构转为红黑树结构,但方法体中不会一定将单链表结构转为红黑树结构

两种情况如下

1、没有转红黑树,只进行数组容量的扩容,因为当前数组容量小于MIN_TREEIFY_CAPACITY(值是64)

2、确定转红黑树,当单链表的长度大于等于8时,并且当前数组容量大于等于64时,才会真的将一个超长的单链表转为红黑树结构(看来作者知道这里开销太大)

重要知识点回顾:计算桶地址(数组下标)

        if ((p = tab[i = (n - 1) & hash]) == null)

(n-1) & hash 用于计算桶的下标(桶地址,哈希地址),这里巧妙使用了按位与运算代替了取模运算,为什么这么做呢?这是因为按位与运算比取模运算的执行效率高,按位与运算直接操作的二进制位,而取模运算还要将10进制转换为二进制再进行计算,当然没有直接的按位与的运算效率高!

hash变量(hashCode值)的值范围是一个32位的int值(-2147483648~2147483647[-2^31~2^31-1] ,最高位代表符号位,0为正、1为负),显然HashMap对象持有的底层数组容量是有限的,不可能放下这么大值的下标,而且底层数组的默认容量是16,所以通过一个办法,把这个hash值转为有效范围(不超过数组容量)的下标

    假设数组容量是16、 此时用 hash % 16,那么可能得到的值的范围是0-15,那正好用取模运算就可以计算一个满足数组容量的下标值,比如 31 % 16,余数是15……,这个有缺点吗?我这个屌丝觉得也挺好的呀,但是对于大神来说,还是觉得效率不高!大神会想什么办法?

    答:HashMap对象持有的数组对象的容量永远是2的n次方,只有此时才能使用按位与运算代替上面说的取模运算,获取桶地址(hash & length - 1)

hash &(16 - 1) ==  hash % 16,这两个表达式最后的计算结果一摸一样,但是按位与运算的效率比取模运算的效率高

总结

1、HashMap对象在第一次添加元素时,会对持有的数组对象进行初始化工作,此时才创建数组对象

2、单链表转红黑树结构时,必须2个条件同时满足才会进行转换,第1个条件为扩容阈值必须大于等于8(单链表长度大于等于8),第二个条件为数组对象的容量必须大于等于64,若第2个条件不满足,则单链表转红黑树的treeifyBin()方法会先调用扩充数组容量的resize()方法,充分说明单链表转红黑树的代价是非常巨大的!

3、putAll()方法添加多个元素时,是一个一个的将元素添加到HashMap对象持有的底层数组对象中的……,可见添加效率真的一般

4、红黑树复杂,需单开文章总结…………我哭!

5、HashMap是先添加新的元素,再去检查是否需要扩充数组容量

6、HashMap支持添加的Key对象为null

7、如果是覆盖旧的元素,HashMap不会再去检查是否需要扩充数组容量

8、遵守HashMap的规则,Key对象的hashCode()方法、equals()方法必须按照要求开发,才能作为HashMap中的Key对象

9、建议添加元素的过程学无数遍!!!作者无敌了!

  • 4
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值