我就不信你还不懂HashSet/HashMap的底层原理

Posted 緑水長流*z

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我就不信你还不懂HashSet/HashMap的底层原理相关的知识,希望对你有一定的参考价值。

💥注💥


💗阅读本博客需备的前置知识如下💗

⭐️本博客知识点收录于⭐️👉🚀《JavaSE系列教程》:🚀—>🚗11【泛型、Map、异常】🚗

文章目录

二、Set集合

2.1 Set集合概述

Set接口和List接口一样,继承与Collection接口,也是一个单列集合;Set集合中的方法和Collection基本一致;并没有对Collection接口进行功能上的扩充,只是底层实现的方式不同了(采用的数据结构不一样);

  • Set集合体系结构:

2.2 HashSet 集合

2.2.1 HashSet数据结构

1)HashSet简介

HashSet是Set接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致)。

HashSet底层数据结构在JDK8做了一次重大升级,JDK8之前采用的是Hash表,也就是数组+链表来实现;到了JDK8之后采用数组+链表+红黑树来实现;

Tips:关于红黑树我们暂时理解为红黑树就是一颗平衡的二叉树(即使他不是绝对平衡);

  • HashSet简单使用:
package com.dfbz.demo01;

import java.util.HashSet;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 
    public static void main(String[] args) 
        //创建 Set集合
        HashSet set = new HashSet<String>();

        //添加元素
        set.add("湖北");
        set.add("河北");
        set.add("河北");          // HashSet带有去重特点,"河北"已经存储过了,不会再存储

        System.out.println(set);            // [河北, 湖北]
    

HashSet判断两个元素是否重复的依据是什么呢?下面案例代码HashSet将会存储几个元素呢?

  • 示例代码:
package com.dfbz.demo01;

import java.util.HashSet;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 
    public static void main(String[] args) 
        //创建 Set集合
        HashSet<String> set = new HashSet();

        //添加元素
        set.add(new String("河北"));
        set.add("湖北");
        set.add("河北");
        set.add("湖北");

        System.out.println(set.size());                // ?

        System.out.println("--------------------");

        HashSet<A> set2 =new HashSet<>();
        set2.add(new A());
        set2.add(new A());

        System.out.println(set2.size());                 // ?
    


class A

要探究HashSet的去重原理我们需要继续往下看!

2)Hash冲突1

我们知道hash表数据结构的特点是:根据元素的hash值来对数组的长度取余,最终计算出元素所要存储的位置;Object类中有一个特殊的方法hashCode(),该方法被native关键字修饰(不是采用Java语言实现);

  • public native int hashCode():获取该对象的hash值,默认情况下根据该对象的内存地址值来计算;

默认情况下,对象的hash值是根据对象的内存地址值来计算;但是这种hash算法并不是特别完美,有时候不同的两个对象(内存地址值不一致)计算出来的hash值可能会一样,我们把这种情况称为hash冲突。尽管这种情况非常少,但依旧存在;

  • 下面是String类对hashCode代码的实现:
public int hashCode() 
    int h = hash;
    if (h == 0 && value.length > 0) 
        char val[] = value;

        for (int i = 0; i < value.length; i++) 
            h = 31 * h + val[i];
        
        hash = h;
    
    return h;

String默认情况下是获取每一个字符的ASCII码来参与hashCode的计算,在上面算法中,ABBA得出的hashCode是不一致的;有效的解决了一定情况下的hash冲突问题,但是hash算法不能保证在所有情况下hash都能唯一

例如AaBB的hashCode却是一样的,这种造成了Hash冲突问题;

Aa:
h = 31*0+65
h = 31*65+97
h = 2112
BB:
h = 31*0+66
H = 31*66+66
h = 2112
  • 示例代码:
package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 
    public static void main(String[] args) 

        System.out.println("Aa".hashCode()); // 2112
        System.out.println("BB".hashCode()); // 2112
    

通过String类对hashCode的实现可以看出来:hash算法并不能绝对的保证两个不同的对象算出来的hash值不一样,当hash冲突时,HashSet将会调用当前对象的equlas方法来比较两个对象是否一致,如果一致则不存储该元素;

3)Hash冲突2

假设数组的长度为9,当元素1的hash值为6,元素2的hash值为15,计算的数组槽位都是6,同样的,那么这个时候也会触发hash冲突问题;

  • Integer对hashCode的实现:
@Override
public int hashCode() 
    return Integer.hashCode(value);

  • Integer.hashCode():
public static int hashCode(int value) 
    // 就是返回元素本身
    return value;

  • 示例代码:
package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo10 
    public static void main(String[] args) 
        System.out.println(new Integer(15).hashCode());         // 15
        System.out.println(new Integer(6).hashCode());          // 6
    

Tips:Integer的hashCode就是本身数值;

HashSet存储时的Hash冲突情况(假设散列表中的数组长度为9):

发生上面这种Hash冲突时HashSet采用拉链法,将新增的元素添加到上一个元素之后形成链表;

需要注意的是:

  • 1)hashCode一致的两个对象不能说明两个对象一定相同,因为可能会造成hash冲突(例如上面的Aa和BB)
  • 2)但是如果hashCode不同,则一定能说明这两个对象肯定不同,因为同一个对象计算的hashCode永远一样;

因此在hash冲突的第二种情况下,并不需要调用equals来去重;而是采用拉链法直接将新添加的元素链在后面形成链表;

4)HashSet底层存储原理

我们前面了解过HashSet底层采用的是散列表这种数据结构(数组+链表),并且在JDK1.8对传统的散列表进行了优化,增加了红黑树来优化链表查询慢的情况;在默认情况下,HashSet中散列表的数组长度为16,并通过负载因子来控制数组的长度;HashSet中负载因子默认为0.75;

负载因子=HashSet中存储的元素/数组的长度

由此可以得出当HashSet中的元素个数为12个时(16*0.75=12),将进行数组的扩容,默认情况下将会扩容到原来的2倍;数组长度将会变为32,由公式可以推算出,下一次HashSet数组扩容时元素个数将为32*0.75=24,以此类推…

负载因子是控制数组扩容的一个重要参数;并且HashSet允许我们在创建时指定负载因子和数值的默认容量大小;

HashSet底层存储如图所示:

上述图中是一个hash表数据结构(数组+链表),也是JDK8之前的HashSet底层存储结构或者说还未达到阈值转换为红黑树的时候

当存储的元素越来越多,hash也越来越多时,势必造成链表长度非常长,查找元素时性能会变得很低;在JDK8中当链表长度到达指定阈值8,并且数组容量达到了64时,将链表转换为红黑树,这样大大降低了查询的时间;

如图所示:

5)HashSet特点总结

  • 1)存取无序,元素唯一,先比较hashCode,
    • 1)Hash冲突情况1:hash值直接冲突了,当hash冲突时再比较equals,equals返回true则不存;
    • 2)Hash冲突情况2:hash值没有冲突,但是%数组的长度得到槽位冲突了,使用拉链法形成链表
  • 2)底层采用Hash表数据结构,当数组长度大于等于64并且链表长度大于等于8时,链表将会转换为红黑树,当长度降到6时将会重新转换为链表;
  • 3)HashSet默认数组长度为16,默认的负载因子为0.75;
  • 4)每次数组扩容时,默认扩容到原来的2倍;

2.2.2 HashSet去重原理

前面在分析hash冲突时就得出了结论:HashSet保证元素唯一性的方式依赖于:hashCodeequals方法。

来解释我们之前的问题:

package com.dfbz.demo01;

import java.util.HashSet;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 
    public static void main(String[] args) 
        //创建 Set集合
        HashSet<String> set = new HashSet();

        //添加元素
        set.add(new String("河北"));
        set.add("河北");

        System.out.println(set.size());                 // ?
    

  • 分析:

HashSet在存储元素时,都会调用对象的hashCode()方法计算该对象的hash值,如果hash值与集合中的其他元素一样,则调用equals方法对冲突的元素进行对比,如果equals方法返回true,说明两个对象是一致的,HashSet并不会存储该对象,反之则存储该元素;

一般情况下,不同对象的hash值计算出来的结果是不一样的,但还是有某些情况下,不同一个对象的hash值计算成了同一个,这种情况我们称为hash冲突;当hash冲突时,HashSet会调用equals方法进行对比,默认情况下equals方法对比的是对象内存地址值,因此如果对象不是同一个,equals返回的都是false;

另外,Java中的HashSet还进行了优化,如果两个字符串都是存储在常量池,那么直接在常量池中进行判断,不需要调用equals来判断是否重复

  • 示例代码:
package com.dfbz.demo01;

import java.util.HashSet;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 
    public static void main(String[] args) 
        //创建 Set集合
        HashSet<String> set = new HashSet();

        set.add("河北");
        
        /*
         存储第二个"河北"时,hashSet发现两个hashCode一致
         并且都是存储在常量池,因此都不需要调用equals来判断这个元素是否存在hashSet
         */
        set.add("河北");

        System.out.println(set.size());                 // 2
    

2.2.3 HashSet存储测试

1)hash冲突情况1

HashSet的去重原理是依靠对象的hashCode和equals方法来决定是否要存储这个对象的;如果不同的两个对象其hashCode是不同的,即使hash冲突了,equals也不可能相同(默认情况下,Object中的equals比较是两个对象的内存地址值);

但是在实际开发中,地址值并不是我们用来判断两个对象是否相等的依据,我们的习惯是,对象中的属性相等即判断两个对象是同一个对象;

  • 定义一个Person类:
package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Person 

    private String name;
    private Integer age;

    @Override
    public String toString() 
        return "Person" +
                "name='" + name + '\\'' +
                ", age=" + age +
                '';
    

    public Person() 
    

    public Person(String name, Integer age) 
        this.name = name;
        this.age = age;
    

    public String getName() 
        return name;
    

    public void setName(String name) 
        this.name = name;
    

    public Integer getAge() 
        return age;
    

    public void setAge(Integer age) 
        this.age = age;
    

  • 测试类:
package com.dfbz.demo01;

import java.util.HashSet;
import java.util.Set;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 
    public static void main(String[] args) 
        Set persons = new HashSet<>();

        persons.add(new Person("小灰", 20));
        persons.add(new Person("小灰", 20));

        System.out.println(persons.size());         // 2
    

默认情况下,hashCode的值是根据对象的内存地址值计算的,hashCode应该不一样,即使hashCode一样(hash冲突)调用equals返回值也是false,因为equlas默认的比较规则是比较两个对象的内存地址值

但是我们在实际开发中,即使new了两个对象,如果里面的属性是完全一样的,我们就认为两个对象是同一个对象,HashSet应该帮我们去除这样的重复对象;

我们可以重写hashCode和equals方法:

@Override
public boolean equals(Object o) 

    System.out.println("equals执行了...");
    // 为了测试,这样固定死是毫无意义的
    return false;


@Override
public int hashCode() 
    
    System.out.println("hashCode执行了...");
    // 为了测试,这样固定死是毫无意义的
    return 1;

测试代码:

package com.dfbz.demo01;

import java.util.HashSet;
import java.util.Set;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 
    public static void main(String[] args) 

        Set persons = new HashSet<>();

        persons.add(new Person("小灰", 20));
        persons.add(new Person("小蓝", 18));

        System.out.println(persons.size());         // 1
    

运行结果:

分析:

1)存储第一个Person对象时,调用这个Person对象的hashCode方法得出:1,并将其存储起来

2)存储第二个Person对象时,调用这个Person对象的hashCode方法得出:1,发现集合中已经有了hashCode为1的对象,因此调用Person对象的equals方法,将冲突了的Person对象传入(第一次添加的那个Person对象),然后equals方法返回的是true,因此不存这个Person对象(第二个Person对象),最终persons.size()为1;

真正的hashCode与equals的方法内部逻辑应该是:相同属性的对象的hashCode应该是一样的,也就是说hashCode应该根据对象属性来计算,并且equals对比的应该是对象属性的值;

使用idea快捷键:alt+insert

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3WT8GGut-1677985759628)(media/96.png)]

一直回车,生成hashCode和equals方法:

@Override
public boolean equals(Object o) 
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return Objects.equals(name, person.name) &&
            Objects.equals(age, person.age);


@Override
public int hashCode() 
    return Objects.hash(name, age);

此时再执行测试类:

将Person属性都改为一样的:

2)hash冲突情况2

当hashCode不一样,但是%数组的长度得到的槽位是一样时,也会产生hash冲突,但是这种hash冲突并不需要调用equals来判断,而是直接使用拉链法拼接在上一个元素的后面形成链表;

  • 示例代码:
package com.dfbz.demo01;

import java.util.HashSet;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 
    public static void main(String[] args) 
        HashSet<A> set = new HashSet();

        set.add(new A(1));              // 1 % 16 = 1
        set.add(new A(17));             // 17 % 16 = 1

        System.out.println(set);
    


class A 

    private Integer num;

    @Override
    public boolean equals(Object o) 
        System.out.println("equals调用了...");
        return false;
    

    @Override
    public int hashCode() 
        return this.num;
    

    public A(Integer num) 
        this.num = num;
    

运行程序,发现并没有调用equals:

以上是关于我就不信你还不懂HashSet/HashMap的底层原理的主要内容,如果未能解决你的问题,请参考以下文章

40张图文详解,我就不信你还参透不了并发编程!好文推荐

分享一点面试小经验,我就不信你还听不明白了!

java对象的引用地址,我就不信你还听不明白了!

java分布式系统书籍,我就不信你还听不明白了!

java分布式系统书籍,我就不信你还听不明白了!

mysql1130错误本地无法连接,我就不信你还听不明白了!