Java Set集合详解与实战-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43448363/article/details/119324561

本文详细介绍了Java中的Set集合，包括HashSet、LinkedHashSet和TreeSet的特点和使用。重点讨论了元素唯一性的实现原理，以及如何通过自然排序和比较器排序进行元素排序。通过案例展示了如何存储和遍历学生对象，以及如何生成不重复的随机数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

Set

1.1 Set集合概述和特点

Set集合特点：

不包含重复元素的集合
没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习

存储字符串并遍历

package com.fun01;

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

/**
 * @author 23389.
 * @date 2021/6/20.
 */

/*
Set集合特点：

- 不包含重复元素的集合
- 没有带索引的方法，所以不能使用普通for循环遍历

HashSet对集合的迭代顺序不做任何保证
 */

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

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素
        set.add("world");

        //遍历
        for(String s : set){
            System.out.println(s);
        }

         Iterator<String> it = set.iterator();
         while(it.hasNext()){
             String s = it.next();
             System.out.println(s);
         }
    }
}

1.2哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

public int hashCode(): 返回对象的哈希码值

对象的哈希值特点

同一个对象多次调用hashCode()方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的，而重写hashCode()方法，可以实现不同对象的哈希值相同

1.3HashSet集合概述和特点

HashSet集合特点：

底层数据集合是哈希表
对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素一致
没有带索引的方法，所以本使用普通for循环遍历
由于是set集合，所以不包含重复元素的集合

HashSet集合练习

存储字符串并遍历

package com.fun03;

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

/**
 * @author 23389.
 * @date 2021/6/21.
 */
public class HashSetDemo {
    public static void main(String[] args){
        
        //创建集合对象
        HashSet<String> hset = new HashSet<String>();

        //添加元素
        hset.add("hello");
        hset.add("world");
        hset.add("java");

        System.out.println(hset);

        //增强for循环遍历
        for(String s : hset){
            System.out.println(s);
        }

        //迭代器遍历
        Iterator<String> it = hset.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

1.4 HashSet集合保证元素唯一性源码分析

HashSet集合添加一个元素的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ry74RRyV-1627886013863)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210621143740111.png)]

1.5 常见数据结构之哈希表

哈希表

JDK8之前，底层采用数组+链表实现，可以说是一个元素链表的数组
JDK8以后，在长度比较长的时候，底层实现了优化

1.6 案例：HashSet集合存储学生对象并遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建HashSet集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(增强for循环方式)

⑥重写euqals()和hashSet()方法自动生成即可

package com.fun04;

/**
 * @author 23389.
 * @date 2021/6/22.
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

package com.fun04;

import java.util.HashSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */
public class HashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student> hs = new HashSet<Student>();

        //创建学生对象
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",21);
        Student s3 = new Student("王五",20);
        Student s4 = new Student("王五",20);

        //添加元素到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        //遍历
        for(Student s : hs){
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

1.7 LinkedHashSet集合概述和特点

LinkedhaseSet集合特点

哈希表和链表实现的Set接口，具有可预测的迭代次序
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
由哈希表保证元素唯一，也就是说重复的元素

LinkedHashSet集合练习

存储字符串遍历

package com.fun05;

import java.util.LinkedHashSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */
public class LinkedHashSetDemo {
    public static void main(String[] args){
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        linkedHashSet.add("happy");
        linkedHashSet.add("hello");

        for(String s : linkedHashSet){
            System.out.println(s);
        }
    }
}

1.8 TreeSet集合概述和特点

TreeSet集合特点

元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法

TreeSet():根据元素的自然排序进行排序

TreeSet(Comparator comparatot):根据指定的比较器进行排序
没有带索引的方法，所以不能使用普通for循环
由于是Set集合，所以不包含重复的元素

TreeSet存储整数并遍历

package com.fun06;


import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */
public class TreeSetDemo {
    public static void main(String[] args){

        //创建集合对象
        TreeSet<Integer>  ts = new TreeSet<Integer>();

        //添加元素
        ts.add(1);
        ts.add(5);
        ts.add(2);
        ts.add(5);

        //遍历

        for(int a : ts){
            System.out.println(a);
        }

    }
}

1.9 自然排序Comparable的使用

存储学生对象并遍历，创建TreeSet集合使用无参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论：

用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对集合进行排序的
自然排序，就是让元素所属的类实现CompareTo(T o)方法
重写方法时，一定要注意排序规则必须按照要求的主要和次要条件来写

1.10 比较器排序Comparator的使用

存储学生对象并遍历，创建TreeSet集合使用带参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

package com.fun07;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */

/*
- 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 */

public class TreeSetDemo {
    public static void main(String[] args){
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        Student s1 = new Student("shiqiaorui",21);
        Student s2 = new Student("wangzhongzhong",20);
        Student s3 = new Student("liuyuanhnang",19);
        Student s4 = new Student("liushuang",20);

        //添加学生对象到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        //遍历集合

        for(Student s : ts){
            System.out.println(s.getName() + "," + s.getAge());
        }



    }
}

结论：

用TreeSet集合存储自定义对象时，带参构造方法使用的是比较器排序对元素进行排序
比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o,T o2)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

1.11 案例：成绩排序

需求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合

要求：按照总分从高到低出现

①定义学生对象

②创建TreeSet集合对象，通过比较器排序进行排序

③创建学生对象

④把学生对象添加到集合

⑤遍历集合

package com.fun08;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */

/*
需求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合

          要求：按照总分从高到低出现

①定义学生对象

②创建TreeSet集合对象，通过比较器排序进行排序

③创建学生对象

④把学生对象添加到集合

⑤遍历集合
 */

public class TreeSetTest {
    public static void main(String[] args){
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
//                int num = (s2.getChinese() + s2.getMath() - s1.getChinese() - s1.getMath());
                int num = s2.getSum() - s1.getSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
                return num3;
            }
        });

        //创建学生对象
        
        Student s1 = new Student("张三",85,90);
        Student s2 = new Student("王五",90,90);
        Student s3 = new Student("李四",85,85);
        
        //Student s4 = new Student("李四",85,85);
        Student s4 = new Student("赵云",85,85);

//        添加元素到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        //遍历
        for(Student s : ts){
            System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath());
        }

    }
}

1.12 不重复的随机数

需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

思路：

①创建Set集合对象

②创建随机数对象

③判断集合的长度是不是小于10

是：产生一个随机数，添加到集合

回到③继续

④遍历集合

package com.fun09;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/22.
 */

/*
需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出



思路：

①创建Set集合对象

②创建随机数对象

③判断集合的长度是不是小于10

     是：产生一个随机数，添加到集合

     回到③继续

④遍历集合


 */

public class SetDemo {
    public static void main(String[] args){
        //创建集合对象
//        Set<Integer> set = new HashSet<Integer>();
        Set<Integer> set = new TreeSet<Integer>();
        //创建Random对象

        Random r = new Random();

        //判断集合的长度是不是小于10
        while(set.size() < 10){
            //产生一个随机数，添加到集合
            int a = r.nextInt(20) + 1;
            set.add(a);
        }

        //遍历集合
        for(Integer b : set){
            System.out.println(b);
        }


    }

}

TreeSet进行排序

HashSet无排序

 是：产生一个随机数，添加到集合