Java set接口之HashSet集合原理讲解

Set接口

java.util.set接口继承自Collection接口,它与Collection接口中的方法基本一致,
并没有对 Collection接口进行功能上的扩充,只是比collection接口更加严格了。
set接口中元素是无序的,并且都会以某种规则保证存入的元素不出现重复。

简述其特点就是:

  1. 不允许存储重复的元素
  2. 没有索引,也没有带索引的方法,不能使用普通的for循环遍历

Set接口有多个实现类,java.util.HashSet是其常用的子类

下面介绍一下set接口的实现类HashSet

 

HashSet集合的介绍

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

  2. java.util.HashSet底层的实现其实是一个java.util.HashMap支持

  3. HashSet是根据对象的哈希值来确定元素在集合中的存储位置的,因此具有良好的存取和查找性能。

  4. 保证元素唯一性的方式依赖于:hashCode与 equals方法。

代码简单理解

import java.util.HashSet;
import java.util.Iterator;

public class DemoHashSet {
    public static void main(String[] args) {
        // 创建set集合(HashSet)
        HashSet hashSet = new HashSet<>();

        // 使用add方法想HashSet集合中添加元素
        hashSet.add("A");
        hashSet.add("B");
        hashSet.add("C");
        hashSet.add("D");
        hashSet.add("A");
        System.out.println("集合中的元素:" + hashSet);
        System.out.println("==============================");

        // 使用迭代器遍历集合
        Iterator ite = hashSet.iterator();
        while (ite.hasNext()) {
            System.out.println(ite.next());
        }
        System.out.println("==============================");
        // 使用增强for循环遍历集合(不能使用普通的for循环,对HashSet集合进行遍历)
        for (String s: hashSet) {
            System.out.println(s);
        }
    }
}
输出结果:
集合中的元素:[A, B, C, D]
==============================
A
B
C
D
==============================
A
B
C
D

注意:普通for循环不能遍历HashSet集合,HashSet集合中没有重复的元素,元素的存储顺序不一致

 

HashSet集合存储数据的结构(哈希表)

什么是哈希表

哈希表(又称散列表),它是根据关键码值(Key - Value)而直接进行访问的数据结构。

也就是说,哈希表是通过把关键码值(Key)映射到表中一个位置来访问记录(Value),以加快查找的速度。这个映射函数叫做哈希函数(散列函数),存放记录的数组叫做哈希表。

/**
 * 在JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同hash值的链表都存储在一个链表里。
 * 但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。
 * 而JDK1.8中,哈希表存储采用数组+链表+或数组+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。
 */

 

什么是链表

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。

 

什么是红黑树

红黑树(又称对称二叉B树),是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关联数组

 

什么是关联数组

是一种具有特殊索引方式的数组。不仅可以通过整数来索引它,还可以使用字符串或者其他类型的值(除了NULL)来索引它。

 

哈希值

了解了什么是哈希表后,简单理解一下什么是哈希值

什么哈希值

是通过一定的哈希算法,将一段较长的数据映射为较短小的二进制数据,这段小数据就是大数据的哈希值。

 

特点

他是唯一的,一旦大数据发生了变化,哪怕是一个微小的变化,他的哈希值也会发生变化。

 

作用

主要用途是用于文件校验或签名。

 

在Java程序中的哈希值

/**
 * 在Java中哈希值:是一个十进制的整数,由系统随机给出的二进制数经过换算得到的
* 其实它就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,并不是数据实际存储的物理地址
* * 在Object类有一个方法,可以获取对象的哈希值: * int hashCode() 返回对象的哈希码值
* hashCode()方法源码:
*            public native int hashCode();
*            native:代表该方法是调用本地操作系统的方法
*/
// 随便创建一个类
public class Person extends Object{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
// 用这个类创建对象,查看对象的哈希值
public class DemoHashCode {
    public static void main(String[] args) {
        // 创建一个p1对象,查看其哈希值
        Person p1 = new Person("LeeHua", 21);
        // 调用Object的hashCode方法,获取哈希值,p1的哈希值是不变的
        int h1 = p1.hashCode();
        System.out.println(h1);

        // 创建一个p2对象,查看其哈希值
        Person p2 = new Person("WanTao", 20);
        // 调用Object的hashCode方法,获取哈希值,p2的哈希值也是不变的
        int h2 = p2.hashCode();
        System.out.println(h2);

        // 查看p1、p2的地址值
        System.out.println(p1);
        System.out.println(p2);
    }
}
输出结果:
1639705018
1627674070
view.study.demo18.Person@61bbe9ba
view.study.demo18.Person@610455d6

 

假如覆盖重写hashCode方法,所创建的对象的哈希值就会被影响

如:

public class Person1 extends Object{

    /**
     * 重写hashCode方法
     * @return 哈希值
     */
    @Override
    public int hashCode() {
        return 666;
    }
}
public class DemoHashCode1 {
    public static void main(String[] args) {
        // 创建一个p1对象,查看其哈希值
        Person1 p1 = new Person1();
        // 调用Object的hashCode方法,获取哈希值,p1的哈希值是不变的
        int h1 = p1.hashCode();
        System.out.println(h1);

        // 查看p1、p2的地址值
        System.out.println(p1);
    }
}
输出结果:
666
view.study.demo18.Person1@29a

 

如:我们常用的String类,它也覆盖重写了hashCode方法

public class DemoStringHashCode {
    public static void main(String[] args) {
        /*
        String类的哈希值
        (String类重写了Object类的hashCode方法)
         */
        String s1 = new String("LeeHua");
        String s2 = new String("WanTao");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}
输出结果:
-2022794392
-1711288770

 

图形理解

Java set接口之HashSet集合原理讲解_第1张图片

 

可以看到,数组的每个位置放到一定的值,每部分值都对应一个哈希值。

当值的个数超过8个的时候,采用数组+红黑树;当值的个数不到8个的时候,采用数组+链表

如:

值1、2、3、4的哈希值都是11

值13、14、15的哈希值都是15

值a、b、c、d、e、f、g的哈希值都是89

 

Set集合存储元素不重复原理

原理

set集合在调用add()方法的时候,add()方法会调用元素的hashCode()方法和 equals()方法判断元素是否重复

 

代码举例

import java.util.HashSet;

public class DemoStringHashCode1 {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet<>();

        String s1 = new String("abc");
        String s2 = new String("abc");

        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add("一号");
        hashSet.add("二号");

        System.out.println("s1的哈希值:" + s1.hashCode());
        System.out.println("s2的哈希值:" + s2.hashCode());
        System.out.println("一号的哈希值:" + "一号".hashCode());
        System.out.println("二号的哈希值:" + "二号".hashCode());
        System.out.println("HashSet集合:" + hashSet);
    }
}
输出结果:
s1的哈希值:96354
s2的哈希值:96354
一号的哈希值:640503
二号的哈希值:644843
HashSet集合:[二号, abc, 一号]

 

代码讲解

最初,hashSet集合是空的

hashSet.add(s1)的时候,

第一步:add()方法首先会调用s1的hashCode()方法,计算字符串"abc"的哈希值,其哈希值是96354

第二步:查找集合中哈希值是96354中的元素,没有发现哈希值是96354的key

第三步:将s1存储到集合hashSet中(于是集合hashSet中存在哈希值96354,且对应这数据s1)

 

hashSet.add(s2)的时候

第一步:add()方法首先会调用s2的hashCode()方法,计算字符串"abc"的哈希值,其哈希值是96354

第二步:查找集合hashSet中是否存在哈希值是96354,即哈希值96354冲突,

第三步:s2调用equals()方法,和集合中哈希值是96354对应的元素进行比较

第四步:s2.equals(s1)返回true,即哈希值是96354对应的元素已经存在,所以就不添加s2进集合了(其中:s1 = "abc",s2 = "abc")

 

hashSet.add("一号")的时候

第一步:调用 "一号" 的hashCode()方法,计算字符串 "一号" 的哈希值,其哈希值是640503

第二步:查找集合中哈希值是640503中的元素,没有发现哈希值是640503的key,

第三步:将 "一号" 存储到集合hashSet中(于是集合hashSet中存在哈希值640503,且对应这数据 "一号")

 

hashSet.add("二号")的时候

第一步:调用 "二号" 的hashCode()方法,计算字符串 "二号" 的哈希值,其哈希值是644843

第二步:查找集合中哈希值是644843中的元素,没有发现哈希值是644843的key,

第三步:将 "二号" 存储到集合hashSet中(于是集合hashSet中存在哈希值644843,且对应这数据 "二号")

添加完成,集合hashSet = [abc, 一号, 二号]

 HashSet存储自定义类型元素

hashSet存储自定义类型元素,那么自定义的类必须重写hashCode()方法和equals()方法,否则添加的元素可以出现重复,我们平时使用的类型,它们都重写类hashCode()方法和equals()方法。

假如不重写hashCode()方法和equals()方法

例子:

// 随便创建一个类,作为HashSet存入数据的类型
public class Person{
    private String name;
    private int age;

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

 

阿里巴巴Java Code规范会抛出警告

Java set接口之HashSet集合原理讲解_第2张图片

 

 

测试一下会出现什么情况

import java.util.HashSet;

public class Demo01PersonHashSet {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet<>();

        Person p1 = new Person("小明", 20);
        Person p2 = new Person("小明", 20);
        Person p3 = new Person("小红", 20);

        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        System.out.println(hashSet);
    }
}
输出结果:
[Person{name='小明', age=20}, Person{name='小明', age=20}, Person{name='小红', age=20}]

可以看到,hashSet集合里面可以存在重复的元素

 

重写hashCode()方法和equals()方法

还是上面这个例子:

在Person类里面添加要重写hashCode()、equals()方法的代码即可,要添加的代码如下

public class Person{
    @Override
    public boolean equals(Object o) {
        // 参数 == 对象
        if (this == o) {
            return true;
        }
        // 传入参数为空,或者对象与参数的hashCode不相等
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        // 向下转型,把Object类型转型为Person类型
        Person person = (Person) o;
        // 返回 age,name
        return age == person.age &&
                Objects.equals(name, person.name);
    }

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

再次用上面的代码测试一下Person类型的数据添加是否会出现重复

输出结果:
[Person{name='小明', age=20}, Person{name='小红', age=20}]

可以看到,输出结果中,hashSet集合的元素并没有重复,因此,如果我们想要用HashSet集合存储自定义类型的数据,一定要记得覆盖重写hashCode()方法和equals()方法

你可能感兴趣的