4、Set集合——HashSet、TreeSet（Comparable、Comparator）

最新推荐文章于 2024-07-09 23:43:07 发布
最新推荐文章于 2024-07-09 23:43:07 发布
阅读量481 收藏 2
点赞数
分类专栏： # List、Set、Map集合 文章标签： leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44531966/article/details/109642017
版权

文章目录

1. Set集合特点

  • 不包含重复元素的集合
  • 没有带索引的方法，所以不能使用普通for循环遍历
1.1 Set集合练习：存储字符串并遍历
import java.util.HashSet;
import java.util.Set;

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

    }
}

2. 什么是哈希值

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

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

  • public int hashCode​()：返回对象的哈希码值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的

  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

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

    Object类中有一个方法可以获取对象的哈希值
        public int hashCode()：返回对象的哈希码值
 */
public class HashDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("林青霞",30);

        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode()); //1060830840
        System.out.println(s1.hashCode()); //1060830840
        System.out.println("--------");

        Student s2 = new Student("林青霞",30);

        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        System.out.println(s2.hashCode()); //2137211482
        System.out.println("--------");

        System.out.println("hello".hashCode()); //99162322
        System.out.println("world".hashCode()); //113318802
        System.out.println("java".hashCode()); //3254818

        System.out.println("world".hashCode()); //113318802
        System.out.println("--------");

        System.out.println("重地".hashCode()); //1179395
        System.out.println("通话".hashCode()); //1179395


    }
}

3. HashSet集合概述和特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素的集合
3.1 应用案例1：HashSet集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求：学生对象的成员变量值相同，我们就认为是同一个对象
思路：

  1. 定义学生类
  2. 创建HashSet集合对象
  3. 创建学生对象
  4. 把学生添加到集合
  5. 遍历集合(增强for)
  6. 在学生类中重写两个方法：hashCode()和equals() ，自动生成即可

学生类：

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

测试类：

import java.util.HashSet;

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

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);

        Student s4 = new Student("王祖贤", 33);

        //把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

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

    }
}

4. TreeSet集合概述和特点

  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
    TreeSet​()：根据其元素的自然排序进行排序 TreeSet​(Comparator
    comparator)：根据指定的比较器进行排序

  • 没有带索引的方法，所以不能使用普通for循环遍历

  • 由于是Set集合，所以不包含重复元素的集合

4.1 TreeSet集合练习：存储整数并遍历
import java.util.TreeSet;

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

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}
4.2 自然排序Comparable的使用

  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

  • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo​(T o)方法

  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

Comparable的练习：

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法

  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

学生类：重写compareTo​(T o)方法

public class Student implements Comparable<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 int compareTo(Student s) {
//        return 0;
//        return 1;
//        return -1;
        //按照年龄从小到大排序
       int num = this.age - s.age;
//        int num = s.age - this.age;
        //年龄相同时，按照姓名的字母顺序排序
       int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

测试类：

import java.util.TreeSet;

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

        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}
4.3 比较器排序Comparator的使用

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的

  • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare​(T o1,T o2)方法

  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

Comparable的练习：

  • 存储学生对象并遍历，创建TreeSet集合使用带参构造方法

  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

学生类：

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

测试类：重写compare​(T o1,T o2)方法

import java.util.Comparator;
import java.util.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("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);

        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);

        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}
4.4 应用案例2：成绩排序（通过比较器排序进行排序）

需求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合
要求：按照总分从高到低出现
思路：

  1. 定义学生类
  2. 创建TreeSet集合对象，通过比较器排序进行排序
  3. 创建学生对象
  4. 把学生对象添加到集合
  5. 遍历集合

学生类：

public class Student {
    private String name;
    private int chinese;
    private int math;

    public Student() {
    }

    public Student(String name, int chinese, int math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum() {
        return this.chinese + this.math;
    }
}

测试类：

import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合对象，通过比较器排序进行排序
        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("林青霞", 98, 100);
        Student s2 = new Student("张曼玉", 95, 95);
        Student s3 = new Student("王祖贤", 100, 93);
        Student s4 = new Student("柳岩", 100, 97);
        Student s5 = new Student("风清扬", 98, 98);

        Student s6 = new Student("左冷禅", 97, 99);
//        Student s7 = new Student("左冷禅", 97, 99);
        Student s7 = new Student("赵云", 97, 99);

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

        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum());
        }
    }
}
来lai
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关于HashSet、LinkedHashSet和TreeSet以及Comparable和Comparator
dn1998dj的博客
03-31 789
一、HashSet和LinkedHashSet基础1 . Set中的元素在底层存储的位置是无序的； 2 . Set中的元素是不可重复的； String str1 = new String("abc"); String str2 = new String("abc"); //要求对象各属性值均不同。即使是new的对象，只要属性值相同，也视为重复的。如str1和str2 //因为String
集合（Set）---HashSet和TreeSet
qq_38424588的博客
06-29 189
一、Set接口： ①无序 ②不包含重复元素 ③没有索引，不能使用for循环遍历元素 ④最多只包含一个null元素 二、HashSet：:此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。 1.构造方法： 2.HashSet是如何保证元素唯一性： 所以主要依赖于hashcode（）和equals（）方法来实现，...
Set集合接口、HashSet、TreeSet、Comparable接口、Comparator接口
meng_lemon的博客
03-21 280
  Set接口与List接口最大的不同在于Set接口中的内容是不允许重复的。Set接口并没有对Collection接口继续宁扩充，而List接口对Collection进行了扩充。因此，在Set接口中没有get()和set()方法。   有借口就有相应的实现类，在Set接口中有常用的两个子类：HashSet（无序存储）、TreeSet（有序存储）。 1. Set接口的常用子类与使用 举例： Has...
Java基础 - HashSet，LinkedHashSet，TreeSet，Comparable，Comparator
2401_83916241的博客
04-09 904
A:LinkedHashSet的特点(Linked保证有序(存取一致)，HashSet保证元素唯一)B:案例演示LinkedHashSet的特点可以保证怎么存就怎么取底层数据结构是链表和哈希表实现的，是Set集合中唯一一个能保证怎么存就怎么取的集合对象而其又是HashSet的子类。
day 17 HashSet、TreeSet、comparable接口、comparator比较器
tpszhao的博客
12-15 765
1.ArrayList嵌套 1.1 在集合中存放集合，和二维数组类似 ArrayList<ArrayList> arraylList=new ArrayList<>(); 2.Set集合 2.1 定义 set集合存放的元素是无序的，不能存放重复元素 2.2 应用场景 1.当集合中不想有重复元素时，可以使用set集合 2.当需要排除集合中的重复元素时，可以使用set集合 3.HashSet集合 3.1 定义 1.HashSet集合中的元素通过hash值来比较，通过集合元素hashCod
Java集合排序方法comparable和comparator的总结
热门推荐
wenzhi的博客
09-10 1万+
本文对java集合实现类的排序做了比较详细的总结，也有很详细的代码讲解。
TreeSet集合两种比较器排序Comparable、Comparator
qq_42541819的博客
11-05 763
1.自然排序Comparable的使用 案例需求 存储学生对象并遍历，创建TreeSet集合使用无参构造方法 要求：按照年龄从小到大排序 提示: //o - 要比较的对象 //将此对象与指定的对象进行比较以进行排序。 返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象 public int compareTo(T o); 实现步骤 1.使用空参构造创建TreeSet集合 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的 2.自定义
详解Java中HashSet和TreeSet的区别
08-30
HashSet 和 TreeSet 是 Java 中两个常用的集合类，它们都实现了 Set 接口，但它们之间有很大的区别。本文将详细介绍 HashSet 和 TreeSet 的区别，帮助大家更好地理解和使用这些集合类。 HashSet HashSet 是一个...
HashSet和TreeSet使用方法的区别解析
08-28
HashSet和TreeSet都是Java集合框架中的Set接口实现，用于存储不重复的元素。但是，它们在使用方法和实现机理上有很大的区别。 首先，从使用方法上讲，HashSet和TreeSet都可以用于存储不重复的元素，但是它们在元素...
Java—Set集合详解（HashSet/LinkedHashSet/TreeSet/EnumSet）
12-21
默认情况下，元素需要实现Comparable接口，或者在创建TreeSet时提供Comparator。 **EnumSet类** 是专门为枚举类型设计的Set实现，它提供了非常高效的性能，因为枚举类型的数量有限且已知。EnumSet的每个实例对应于...
浅析Java中的set集合类型及其接口的用法
09-02
Java中的Set集合是一种...总之，Java中的Set集合类型提供了存储不重复元素的功能，其中HashSet强调性能，而TreeSet强调有序性。了解它们的工作原理以及如何正确使用它们，对于编写高效且功能完善的Java程序至关重要。
HashSet和TreeSet.doc
08-25
HashSet 和 TreeSet 是 Java 中两种常用的 Set 集合实现，它们都继承自 Set 接口，但实现方式和特性上存在显著差异。 首先，HashSet 是基于哈希表（HashMap 实例）来存储元素的，因此它提供了快速的插入、删除和...
Java基础知识——HashSet_TreeSet_Comparator
小冰块儿
06-14 926
一、Set （一）set概述（摘自API文档）   public interface Set extends Collection set是一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.e
set集合 HashSet: TreeSet实现Comparable接口，覆盖compareTo方法。 类实现Comparator接口，覆盖compare方法。
逍遥单机君
10-15 5413
Set：元素是无序的（存入和取出的顺序不一定一致），   |--   |--   |--
JAVA之旅（二十）—HashSet，自定义存储对象,TreeSet，二叉树，实现Comparator方式排序，TreeSet小练习...
weixin_34236869的博客
06-25 152
JAVA之旅（二十）—HashSet，自定义存储对象,TreeSet，二叉树，实现Comparator方式排序，TreeSet小练习 我们继续说一下集合框架 Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复 Set集合的功能和Collection是一致的 我们重点关注的是子类对象 ...
黑马程序员-Set-HashSet-TreeSet-Comparator-Comparable
liuxiaohui_dh的专栏
01-15 1157
l Set 特点： 1. 无序（存储和查询的顺序不同，因为是按照对象的地址值存储进去的）。 2. 不可重复。   通过查看API，Set的功能与Collection是一样的。   常用子类 1. HashSet 2. TreeSet   l HashSet HashSet如何保证元素的唯一性？ 原理：将对象存储在HashTable中，HashTable是通过该对象自己的H
TreeSet（Comparable和Comparator）和HashSet
sophia__yu的博客
01-19 431
TreeSet----底层基于红黑树 有序存储 不允许元素重复，并且按照元素升序排序，不允许存放null 自定义类要想保存到TreeSet中， 要么实现Comparable接口，要么向TreeSet传入比较器(Compartor接口) 实现了Comparable接口的类可以直接存放在TreeSet或TreeMap中。 public int compareTo(T o); 返回值三种情况： 返回...
Java集合归类（List、set、Map）及Comparator排序
weixin_42271651的博客
05-08 1028
集合: List集合 import java.util.ArrayList; import java.util.Iterator; import java.util.List; //Java集合类 public class ListDemo { public static void main(String[] args) { List<String&g...
leetcode--从中序与后序遍历序列构造二叉树
最新发布
liulanba的博客
07-09 620
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
hashset集合怎么转换为treeset集合
06-03
注意，如果 HashSet 中的元素没有实现 Comparable 接口，那么转换为 TreeSet 时会抛出 ClassCastException 异常。因此，如果需要自定义排序方式，可以实现 Comparator 接口，并在 TreeSet 的构造函数中传递 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

来lai

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值