0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看技术视频
  • 写文章/发帖/加入社区
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

一个重量级集合工具:HashMap

科技绿洲 来源:Java技术指北 作者:Java技术指北 2023-10-09 11:09 次阅读

1、哈希表

Hash表也称为散列表,也有直接译作哈希表,Hash表是一种根据关键字值(key - value)而直接进行访问的数据结构。也就是说它通过把关键码值映射到表中的一个位置来访问记录,以此来加快查找的速度。在链表、数组等数据结构中,查找某个关键字,通常要遍历整个数据结构,也就是O(N)的时间级,但是对于哈希表来说,只是O(1)的时间级。

比如对于前面我们讲解的 ArrayList 集合和 LinkedList ,如果我们要查找这两个集合中的某个元素,通常是通过遍历整个集合,需要O(N)的时间级。

图片

如果是哈希表,它是通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表,只需要O(1)的时间级。

图片

①、存放在哈希表中的数据是key-value 键值对,比如存放哈希表的数据为:

{Key1-Value1,Key2-Value2,Key3-Value3,Key4-Value4,Key5-Value5,Key6-Value6}

如果我们想查找是否存在键值对 Key3-Value3,首先通过 Key3 经过散列函数,得到值 k3,然后通过 k3 和散列表对应的值找到是 Value3。

②、当然也有可能存放哈希表的值只是 Value1,Value2,Value3这种类型:

{Value1,Value2,Value3,Value4,Value5,Value6}

这时候我们可以假设 Value1 是等于 Key1的,也就是{Value1-Value1,Value2-Value2,Value3-Value3,Value4-Value4,Value5-Value5,Value6-Value6}可以将 Value1经过散列函数转换成与散列表对应的值。

大家都用过汉语字典吧,汉语字典的优点是我们可以通过前面的拼音目录快速定位到所要查找的汉字。当给定我们某个汉字时,大脑会自动将汉字转换成拼音(如果我们认识,不认识可以通过偏旁部首),这个转换的过程我们可以看成是一个散列函数,之后在根据转换得到的拼音找到该字所在的页码,从而找到该汉字。

汉语字典是哈希表的典型实现,但是我们仔细思考,会发现这样几个问题?

①、为什么要有散列函数?

②、多个 key 通过散列函数会得到相同的值,这时候怎么办?

对于第一个问题,散列函数的存在能够帮助我们更快的确定key和value的映射关系,试想一下,如果没有汉字和拼音的转换规则(或者汉字和偏旁部首的),给你一个汉字,你该如何从字典中找到该汉字?我想除了遍历整部字典,你没有什么更好的办法。

对于第二个问题,多个 key 通过散列函数得到相同的值,这其实也是哈希表最大的问题——冲突。比如同音字汉字,我们得到的拼音就会是相同的,那么我们该如何在字典中存放同音字汉字呢?有两种做法:

第一种是开放地址法,当我们遇到冲突了,这时候通过另一种函数再计算一遍,得到相应的映射关系。比如对于汉语字典,一个字 “余”,拼音是“yu”,我们将其放在页码为567(假设在该位置),这时候又来了一个汉字“于”,拼音也是“yu”,那么这时候我们要是按照转换规则,也得将其放在页码为567的位置,但是我们发现这个页码已经被占用了,这时候怎么办?我们可以在通过另一种函数,得到的值加1。那么汉字"于"就会被放在576+1=577的位置。

第二种是链地址法,我们可以将字典的每一页都看成是一个子数组或者子链表,当遇到冲突了,直接往当前页码的子数组或者子链表里面填充即可。那么我们进行同音字查找的时候,可能需要遍历其子数组或者子链表。如下图所示:

图片

对于开放地址法,可能会遇到二次冲突,三次冲突,所以需要良好的散列函数,分布的越均匀越好。对于链地址法,虽然不会造成二次冲突,但是如果一次冲突很多,那么会造成子数组或者子链表很长,那么我们查找所需遍历的时间也会很长。

2、什么是 HashMap?

听名字就知道,HashMap 是一个利用哈希表原理来存储元素的集合。遇到冲突时,HashMap 是采用的链地址法来解决,在 JDK1.7 中,HashMap 是由 数组+链表构成的。但是在 JDK1.8 中,HashMap 是由 数组+链表+红黑树构成,新增了红黑树作为底层数据结构,结构变得复杂了,但是效率也变的更高效。下面我们来具体介绍在 JDK1.8 中 HashMap 是如何实现的。

图片

3、HashMap定义

HashMap 是一个散列表,它存储的内容是键值对(key-value)映射,而且 key 和 value 都可以为 null。

public class HashMap< K,V > extends AbstractMap< K,V >
     implements Map< K,V >, Cloneable, Serializable {

图片

首先该类实现了一个 Map 接口,该接口定义了一组键值对映射通用的操作。储存一组成对的键-值对象,提供key(键)到value(值)的映射,Map中的key不要求有序,不允许重复。value同样不要求有序,但可以重复。但是我们发现该接口方法有很多,我们设计某个键值对的集合有时候并不像实现那么多方法,那该怎么办?

JDK 还为我们提供了一个抽象类 AbstractMap ,该抽象类继承 Map 接口,所以如果我们不想实现所有的 Map 接口方法,就可以选择继承抽象类 AbstractMap 。

但是我们发现 HashMap 类即继承了 AbstractMap 接口,也实现了 Map 接口,这样做难道不是多此一举?后面我们会讲的 LinkedHashSet 集合也有这样的写法。

毕竟 JDK 经过这么多年的发展维护,博主起初也是认为这样是有具体的作用的,后来找了很多资料,发现这其实完全没有任何作用

java 集合框架的创始人Josh Bloch描述,这样的写法是一个失误。在java集合框架中,类似这样的写法很多,最开始写java集合框架的时候,他认为这样写,在某些地方可能是有价值的,直到他意识到错了。显然的,JDK的维护者,后来不认为这个小小的失误值得去修改,所以就这样存在下来了。
HashMap 集合还实现了 Cloneable 接口以及 Serializable 接口,分别用来进行对象克隆以及将对象进行序列化。

4、字段属性

//序列化和反序列化时,通过该字段进行版本一致性验证
    private static final long serialVersionUID = 362498820763181265L;
    //默认 HashMap 集合初始容量为16(必须是 2 的倍数)
    static final int DEFAULT_INITIAL_CAPACITY = 1 < < 4; // aka 16
    //集合的最大容量,如果通过带参构造指定的最大容量超过此数,默认还是使用此数
    static final int MAXIMUM_CAPACITY = 1 < < 30;
    //默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
    static final int TREEIFY_THRESHOLD = 8;
    //当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
    static final int UNTREEIFY_THRESHOLD = 6;
    /**(JDK1.8新增)
     * 当集合中的容量大于这个值时,表中的桶才能进行树形化 ,否则桶内元素太多时会扩容,
     * 而不是树形化 为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

注意 :后面三个字段是 JDK1.8 新增的,主要是用来进行红黑树和链表的互相转换。

/**
     * 初始化使用,长度总是 2的幂
     */
    transient Node< K,V >[] table;

    /**
     * 保存缓存的entrySet()
     */
    transient Set< Map.Entry< K,V >> entrySet;

    /**
     * 此映射中包含的键值映射的数量。(集合存储键值对的数量)
     */
    transient int size;

    /**
     * 跟前面ArrayList和LinkedList集合中的字段modCount一样,记录集合被修改的次数
     * 主要用于迭代器中的快速失败
     */
    transient int modCount;

    /**
     * 调整大小的下一个大小值(容量*加载因子)。capacity * load factor
     */
    int threshold;

    /**
     * 散列表的加载因子。
     */
    final float loadFactor;

下面我们重点介绍上面几个字段:

①、Node[] table

我们说 HashMap 是由数组+链表+红黑树组成,这里的数组就是 table 字段。后面对其进行初始化长度默认是 DEFAULT_INITIAL_CAPACITY= 16。而且 JDK 声明数组的长度总是 2的n次方(一定是合数),为什么这里要求是合数,一般我们知道哈希算法为了避免冲突都要求长度是质数,这里要求是合数,下面在介绍 HashMap 的hashCode() 方法(散列函数),我们再进行讲解。

②、size

集合中存放key-value 的实时对数。

③、loadFactor

装载因子,是用来衡量 HashMap 满的程度,计算HashMap的实时装载因子的方法为:size/capacity,而不是占用桶的数量去除以capacity。capacity 是桶的数量,也就是 table 的长度length。

默认的负载因子0.75 是对空间和时间效率的一个平衡选择,建议大家不要修改,除非在时间和空间比较特殊的情况下,如果内存空间很多而又对时间效率要求很高,可以降低负载因子loadFactor 的值;相反,如果内存空间紧张而对时间效率要求不高,可以增加负载因子 loadFactor 的值,这个值可以大于1。

④、threshold

计算公式:capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容),扩容后的 HashMap 容量是之前容量的两倍

5、构造函数

①、默认无参构造函数

/**
     * 默认构造函数,初始化加载因子loadFactor = 0.75
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

无参构造器,初始化散列表的加载因子为0.75

②、指定初始容量的构造函数

/**
     * 
     * @param initialCapacity 指定初始化容量
     * @param loadFactor 加载因子 0.75
     */
    public HashMap(int initialCapacity, float loadFactor) {
        //初始化容量不能小于 0 ,否则抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //如果初始化容量大于2的30次方,则初始化容量都为2的30次方
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //如果加载因子小于0,或者加载因子是一个非数值,抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
    // 返回大于等于initialCapacity的最小的二次幂数值。
    // > >> 操作符表示无符号右移,高位取0。
    // | 按位或运算
    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;
    }

6、确定哈希桶数组索引位置

前面我们讲解哈希表的时候,我们知道是用散列函数来确定索引的位置。散列函数设计的越好,使得元素分布的越均匀。HashMap 是数组+链表+红黑树的组合,我们希望在有限个数组位置时,尽量每个位置的元素只有一个,那么当我们用散列函数求得索引位置的时候,我们能马上知道对应位置的元素是不是我们想要的,而不是要进行链表的遍历或者红黑树的遍历,这会大大优化我们的查询效率。我们看 HashMap 中的哈希算法:

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h > >> 16);
    }
    
    i = (table.length - 1) & hash;//这一步是在后面添加元素putVal()方法中进行位置的确定

主要分为三步:

①、取 hashCode 值:key.hashCode()

②、高位参与运算:h>>>16

③、取模运算:(n-1) & hash

这里获取 hashCode() 方法的值是变量,但是我们知道,对于任意给定的对象,只要它的 hashCode() 返回值相同,那么程序调用 hash(Object key) 所计算得到的 hash码 值总是相同的。

为了让数组元素分布均匀,我们首先想到的是把获得的 hash码对数组长度取模运算( hash%length),但是计算机都是二进制进行操作,取模运算相对开销还是很大的,那该如何优化呢?

HashMap 使用的方法很巧妙,它通过 hash & (table.length -1)来得到该对象的保存位,前面说过 HashMap 底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当 length 总是2的n次方时,hash & (length-1)运算等价于对 length 取模,也就是 hash%length,但是&比%具有更高的效率。比如 n % 32 = n & (32 -1)

这也解释了为什么要保证数组的长度总是2的n次方。

再就是在 JDK1.8 中还有个高位参与运算,hashCode() 得到的是一个32位 int 类型的值,通过hashCode()的高16位 异或 低16位实现的:(h = k.hashCode()) ^ (h >>> 16),主要是从速度、功效、质量来考虑的,这么做可以在数组table的length比较小的时候,也能保证考虑到高低Bit都参与到Hash的计算中,同时不会有太大的开销。

下面举例说明下,n为table的长度:

图片

7、添加元素

//hash(key)就是上面讲的hash方法,对其进行了第一步和第二步处理
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    /**
     * 
     * @param hash 索引的位置
     * @param key  键
     * @param value  值
     * @param onlyIfAbsent true 表示不要更改现有值
     * @param evict false表示table处于创建模式
     * @return
     */
    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为null或者长度为0,则进行初始化
         //resize()方法本来是用于扩容,由于初始化没有实际分配空间,这里用该方法进行空间分配,后面会详细讲解该方法
         if ((tab = table) == null || (n = tab.length) == 0)
             n = (tab = resize()).length;
         //注意:这里用到了前面讲解获得key的hash码的第三步,取模运算,下面的if-else分别是 tab[i] 为null和不为null
         if ((p = tab[i = (n - 1) & hash]) == null)
             tab[i] = newNode(hash, key, value, null);//tab[i] 为null,直接将新的key-value插入到计算的索引i位置
         else {//tab[i] 不为null,表示该位置已经有值了
             Node< K,V > e; K k;
             if (p.hash == hash &&
                 ((k = p.key) == key || (key != null && key.equals(k))))
                 e = p;//节点key已经有值了,直接用新值覆盖
             //该链是红黑树
             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;
                     }
                     //key已经存在直接覆盖value
                     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;
    }

①、判断键值对数组 table 是否为空或为null,否则执行resize()进行扩容;

②、根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向⑥,如果table[i]不为空,转向③;

③、判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向④,这里的相同指的是hashCode以及equals;

④、判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;

⑤、遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;

⑥、插入成功后,判断实际存在的键值对数量size是否超过了最大容量threshold,如果超过,进行扩容。

⑦、如果新插入的key不存在,则返回null,如果新插入的key存在,则返回原key对应的value值(注意新插入的value会覆盖原value值)

注意1:看第 58,59 行代码:

if (++size > threshold)//超过最大容量,进行扩容
    resize();

这里有个考点,我们知道 HashMap 是由数组+链表+红黑树(JDK1.8)组成,如果在添加元素时,发生冲突,会将冲突的数放在链表上,当链表长度超过8时,会自动转换成红黑树。

那么有如下问题:数组上有5个元素,而某个链表上有3个元素,问此HashMap的 size 是多大?

我们分析第58,59 行代码,很容易知道,只要是调用put() 方法添加元素,那么就会调用 ++size(这里有个例外是插入重复key的键值对,不会调用,但是重复key元素不会影响size),所以,上面的答案是 7。

注意2:看第 53 、 60 行代码:

afterNodeAccess(e);
 afterNodeInsertion(evict);

这里调用的该方法,其实是调用了如下实现方法:

void afterNodeAccess(Node< K,V > p) { }
void afterNodeInsertion(boolean evict) { }

这都是一个空的方法实现,我们在这里可以不用管,但是在后面介绍 LinkedHashMap 会用到,LinkedHashMap 是继承的 HashMap,并且重写了该方法,后面我们会详细介绍。

8、扩容机制

扩容(resize),我们知道集合是由数组+链表+红黑树构成,向 HashMap 中插入元素时,如果HashMap 集合的元素已经大于了最大承载容量threshold(capacity * loadFactor),这里的threshold不是数组的最大长度。那么必须扩大数组的长度,Java中数组是无法自动扩容的,我们采用的方法是用一个更大的数组代替这个小的数组,就好比以前是用小桶装水,现在小桶装不下了,我们使用一个更大的桶。

JDK1.8融入了红黑树的机制,比较复杂,这里我们先介绍 JDK1.7的扩容源码,便于理解,然后在介绍JDK1.8的源码。

//参数 newCapacity 为新数组的大小
    void resize(int newCapacity) {
        Entry[] oldTable = table;//引用扩容前的 Entry 数组
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//扩容前的数组大小如果已经达到最大(2^30)了
            threshold = Integer.MAX_VALUE;///修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//初始化一个新的Entry数组
        transfer(newTable, initHashSeedAsNeeded(newCapacity));//将数组元素转移到新数组里面
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//修改阈值
    }
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry< K,V > e : table) {//遍历数组
            while(null != e) {
                Entry< K,V > next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);//重新计算每个元素在数组中的索引位置
                e.next = newTable[i];//标记下一个元素,添加是链表头添加
                newTable[i] = e;//将元素放在链上
                e = next;//访问下一个 Entry 链上的元素
            }
        }
    }

通过方法我们可以看到,JDK1.7中首先是创建一个新的大容量数组,然后依次重新计算原集合所有元素的索引,然后重新赋值。如果数组某个位置发生了hash冲突,使用的是单链表的头插入方法,同一位置的新元素总是放在链表的头部,这样与原集合链表对比,扩容之后的可能就是倒序的链表了。

下面我们在看看JDK1.8的。

final Node< K,V >[] resize() {
        Node< K,V >[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null,则长度赋值0
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//如果原数组长度大于0
            if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30)
                threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
                return oldTab;
            }
            //原数组长度大于等于初始化长度16,并且原数组长度扩大1倍也小于2^30次方
            else if ((newCap = oldCap < < 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr < < 1; // 阀值扩大1倍
        }
        else if (oldThr > 0) //旧阀值大于0,则将新容量直接等于就阀值 
            newCap = oldThr;
        else {//阀值等于0,oldCap也等于0(集合未进行初始化)
            newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
        }
        //计算新的阀值上限
        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) {
            //把每个bucket都移动到新的buckets中
            for (int j = 0; j < oldCap; ++j) {
                Node< K,V > e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;//元数据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
                        Node< K,V > loHead = null, loTail = null;
                        Node< K,V > hiHead = null, hiTail = null;
                        Node< K,V > next;
                        do {
                            next = e.next;
                            //原索引
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //原索引+oldCap
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        //原索引放到bucket里
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //原索引+oldCap放到bucket里
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

该方法分为两部分,首先是计算新桶数组的容量 newCap 和新阈值 newThr,然后将原集合的元素重新映射到新集合中。

图片

相比于JDK1.7,1.8使用的是2次幂的扩展(指长度扩为原来2倍),所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”。

9、删除元素

HashMap 删除元素首先是要找到 桶的位置,然后如果是链表,则进行链表遍历,找到需要删除的元素后,进行删除;如果是红黑树,也是进行树的遍历,找到元素删除后,进行平衡调节,注意,当红黑树的节点数小于 6 时,会转化成链表。

public V remove(Object key) {
        Node< K,V > e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
    final Node< K,V > removeNode(int hash, Object key, Object value,
            boolean matchValue, boolean movable) {
        Node< K,V >[] tab; Node< K,V > p; int n, index;
        //(n - 1) & hash找到桶的位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node< K,V > node = null, e; K k; V v;
        //如果键的值与链表第一个节点相等,则将 node 指向该节点
        if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))
        node = p;
        //如果桶节点存在下一个节点
        else if ((e = p.next) != null) {
            //节点为红黑树
        if (p instanceof TreeNode)
         node = ((TreeNode< K,V >)p).getTreeNode(hash, key);//找到需要删除的红黑树节点
        else {
         do {//遍历链表,找到待删除的节点
             if (e.hash == hash &&
                 ((k = e.key) == key ||
                  (key != null && key.equals(k)))) {
                 node = e;
                 break;
             }
             p = e;
         } while ((e = e.next) != null);
        }
        }
        //删除节点,并进行调节红黑树平衡
        if (node != null && (!matchValue || (v = node.value) == value ||
                      (value != null && value.equals(v)))) {
        if (node instanceof TreeNode)
         ((TreeNode< K,V >)node).removeTreeNode(this, tab, movable);
        else if (node == p)
         tab[index] = node.next;
        else
         p.next = node.next;
        ++modCount;
        --size;
        afterNodeRemoval(node);
        return node;
        }
        }
        return null;
    }

注意第 46 行代码

afterNodeRemoval(node);

这也是为实现 LinkedHashMap 做准备的,在这里和上面一样,是一个空方法实现,可以不用管。而在 LinkedHashMap 中进行了重写,用来维护删除节点后,链表的前后关系。

10、查找元素

①、通过 key 查找 value

首先通过 key 找到计算索引,找到桶位置,先检查第一个节点,如果是则返回,如果不是,则遍历其后面的链表或者红黑树。其余情况全部返回 null。

public V get(Object key) {
        Node< K,V > e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    
    final Node< K,V > getNode(int hash, Object key) {
        Node< K,V >[] tab; Node< K,V > first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //根据key计算的索引检查第一个索引
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //不是第一个节点
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)//遍历树查找元素
                    return ((TreeNode< K,V >)first).getTreeNode(hash, key);
                do {
                    //遍历链表查找元素
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

②、判断是否存在给定的 key 或者 value

public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }
    public boolean containsValue(Object value) {
        Node< K,V >[] tab; V v;
        if ((tab = table) != null && size > 0) {
            //遍历桶
            for (int i = 0; i < tab.length; ++i) {
                //遍历桶中的每个节点元素
                for (Node< K,V > e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

11、遍历元素

首先构造一个 HashMap 集合:

HashMap< String,Object > map = new HashMap<  >();
 map.put("A","1");
 map.put("B","2");
 map.put("C","3");

①、分别获取 key 集合和 value 集合。

//1、分别获取key和value的集合
for(String key : map.keySet()){
    System.out.println(key);
}
for(Object value : map.values()){
    System.out.println(value);
}

②、获取 key 集合,然后遍历key集合,根据key分别得到相应value

//2、获取key集合,然后遍历key,根据key得到 value
 Set< String > keySet = map.keySet();
 for(String str : keySet){
     System.out.println(str+"-"+map.get(str));
 }

③、得到 Entry 集合,然后遍历 Entry

//3、得到 Entry 集合,然后遍历 Entry
 Set< Map.Entry< String,Object >> entrySet = map.entrySet();
 for(Map.Entry< String,Object > entry : entrySet){
     System.out.println(entry.getKey()+"-"+entry.getValue());
 }

④、迭代

//4、迭代
Iterator< Map.Entry< String,Object >> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
    Map.Entry< String,Object > mapEntry = iterator.next();
    System.out.println(mapEntry.getKey()+"-"+mapEntry.getValue());
}

基本上使用第三种方法是性能最好的,

第一种遍历方法在我们只需要 key 集合或者只需要 value 集合时使用;

第二种方法效率很低,不推荐使用;

第四种方法效率也挺好,关键是在遍历的过程中我们可以对集合中的元素进行删除。

12、总结

①、基于JDK1.8的HashMap是由数组+链表+红黑树组成,当链表长度超过 8 时会自动转换成红黑树,当红黑树节点个数小于 6 时,又会转化成链表。相对于早期版本的 JDK HashMap 实现,新增了红黑树作为底层数据结构,在数据量较大且哈希碰撞较多时,能够极大的增加检索的效率。

②、允许 key 和 value 都为 null。key 重复会被覆盖,value 允许重复。

③、非线程安全

④、无序(遍历HashMap得到元素的顺序不是按照插入的顺序)

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 函数
    +关注

    关注

    3

    文章

    3911

    浏览量

    61341
  • 页码
    +关注

    关注

    0

    文章

    2

    浏览量

    1958
  • 哈希表
    +关注

    关注

    0

    文章

    9

    浏览量

    4705
  • hashmap
    +关注

    关注

    0

    文章

    12

    浏览量

    2248
收藏 人收藏

    评论

    相关推荐

    谁有哈尔滨理工大学的重量级STM32教程

    谁有哈尔滨理工大学的(重量级STM32教程)啊,带有源程序的?????急用啊
    发表于 09-01 16:16

    java集合干货系列

    分别返回key值集合、value值集合以及Entry(键值对)集合的方法  Map支持泛型,形式如:Map  HashMap类  HashMap
    发表于 12-14 15:11

    2019 XDF重量级嘉宾阵容公布

    ,与多位图灵奖得主合作。他也是横扫了自然语言处理(NLP)各项榜单的XLNet的作者——在超过30不同数据上,他的研究都比现有结果有明显提升。更多重量级嘉宾名单详见活动议程:http
    发表于 11-18 15:21

    让你感受下OPPOR11这次发布会有多洋气,数十位重量级大咖力推!

    今天晚上OPPO将在浙江卫视举行新品发布会,发布自家全新旗舰OPPO R11,值得注意的是这是手机企业首次在电视台发布会新品,而且更为高潮的是发布会上将会有很多重量级明星大咔汇聚,OPPO新代言人周杰伦将会到场。
    发表于 06-10 21:12 1183次阅读

    SUV竞争剧烈的当下,看看这款本田最重量级的新车

    7月10日报道 北京和成都两地的大雨让我们和全新一代CR-V的见面多了一些迂回,中国文化中“水是运、雨是财”或答应以成为与CR-V邂逅的注脚。好在我们与它依然如期而遇,雨水也没有浇灭探究这款车的热情,有时机向各位分享这款本田最重量级的新车。
    发表于 07-12 11:49 649次阅读

    华工科技公司的传感器业务斩获了重量级客户—新能源汽车巨头特斯拉

    华工科技披露公司的传感器业务斩获了重量级客户——新能源汽车巨头特斯拉。
    的头像 发表于 02-01 14:10 7149次阅读

    Rokid,发布三款重量级新品:智能音箱,AI语音专用芯片AR眼镜

    6月26日,国内知名的人工智能公司Rokid在杭州举办2018 Rokid Jungle发布会。这是Rokid成立4年以来的首场大型公开活动,创始人兼CEO Misa(祝铭明)在会上发布了三款重量级
    发表于 06-27 10:40 837次阅读

    视源股份推出重量级新品牌高效的会议平台MAXHUBUB 夺得企业级会议市场先机

    3月28日,视源股份(股票代码:002841)在北京国家会议中心召开2017年发布会,推出了重量级新品牌高效的会议平台MAXHUB。
    发表于 05-24 02:31 1457次阅读

    重量级推手加入 腾讯加入LoRa联盟

    7月31日,腾讯云宣布以发起成员身份加入LoRa联盟,成为该联盟又一名重量级推手。
    的头像 发表于 08-05 09:01 2989次阅读

    豆浆早餐会的谈话 七个产业界的重量级人物

    台北南阳街一家叫做“小欣欣豆浆店”的早餐店里,七个男人围坐在餐桌前,正在谈论电子表的芯片。提问的是台湾地区早期科技政策规划者孙运璿,回答问题的是美国RCA公司研究室主任潘文渊。其他几位亦是产业界的重量级人物。
    的头像 发表于 07-08 15:17 4033次阅读

    特斯拉明年有什么重量级更新和产品推出?

    2019年对于特斯拉来说无疑是攻坚爬坡、节节胜利的一年,该品牌的Model 3电动汽车在这一年里成为了全世界最畅销的车型,在中国市场的销量也是成倍数增长,2020年,特斯拉将在此基础上继续创新之路,下面我们来看看特斯拉明年将会有那些重量级更新和产品推出。
    的头像 发表于 12-31 10:53 2392次阅读

    5nm芯片将再添一重量级成员,6天后就正式发布

    目前,在手机市场中,5nm芯片的机型只有华为和苹果,这两家独占鳌头。而华为又货源不足,所以算下来只有苹果一家可以自由购入体验。这一定让大家颇为无奈吧?不过,好消息是5nm芯片将再添一重量级成员,6天后就正式发布,正式进入5nm芯片市场!
    的头像 发表于 12-23 09:23 1510次阅读

    汇顶科技首款eSE安全芯片GSEA0通过一系列重量级认证

    汇顶科技首款eSE安全芯片GSEA0已通过CCEAL5+、EMVCo、NFTC等一系列重量级认证,安全水平达到全球一流水准。本次研讨会上,这款高端安全芯片的发布成为现场瞩目的焦点。
    的头像 发表于 05-20 16:46 3128次阅读

    AMD重量级芯片是否会选择三星代工?

    AMD重量级芯片是否会选择三星代工?目前情况扑朔迷离。
    的头像 发表于 07-24 15:35 686次阅读

    Linux轻量级工具集合Busybox的特点和使用

    Busybox是一个开源的、轻量级的软件工具集合,旨在提供一个精简的Unix工具集,适用于嵌入式系统和资源受限的环境。它将许多常用的Unix工具
    的头像 发表于 11-10 09:50 571次阅读