解析treeSet集合进行自定义类的排序

最新推荐文章于 2024-06-12 11:41:27 发布
最新推荐文章于 2024-06-12 11:41:27 发布
阅读量576 收藏 5
点赞数 4
分类专栏： java面向对象基础知识 文章标签： java treeSet集合 自定义类排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SSS4362/article/details/126147770
版权

解析treeSet集合进行自定义类的排序

1 底层

1.1 treeSet是对传入的数据进行排序了,排序使用的方法是compareTo方法,add的加入的那个数相当于调用者

在这里插入图片描述

Integer里面的compareTo源码如下所示

 public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
}
//传入的数据就相当于你之前在集合里面的数据,很显然是String类型的数据,你把一个String类型传给Integer类型的形参,肯定会出现类型转换异常啊
//这个是运行时异常,出现异常时会生成一个异常对象,并抛出,运行时异常在编译期间是无需要进行处理的

1.2 排序要求所传入的数据类型必须相等(泛型去约束),不然就会出现classCastException异常

用到了多态(是用大的范围去接收),你本质是用Integer对象的数据,因此调用的是Integer里面的compareTo方法,因此若你在实参部分传入一个字符串类型,必然是会出现类型转换异常的

1.3 所有源码里面需要比较大小的类都实现了java.lang.Comparable接口

Integer类

在这里插入图片描述

String类

在这里插入图片描述

2.实现方法

2.1 实现Comparable接口

2.1.1 核心思路
a 自定义类需要实现Comparable接口并且重写compareTo方法
b compareTo方法通过this(调用者)和传入的参数进行合理的逻辑判断

一般是返回this.属性减去传入参数.属性 代表升序,反过来就是降序

如果是小数类型的比较的话,需要单独对>0和<1以及>-1小于0这两个情况进行判断

前一种返回正数(前大于后),后一种返回负数(前小于后),无论升序还是降序都是这样的，只需要去改前面的减法表达式就行

注意:自定义类可以不用实现equals方法也可以比较成功,因为它底层并没有调用equals方法去进行内容的比较,而是把对应的类型进行拆分逐个比较了,但是我们需要重写equals方法是因为可能其他的方法也需要调用它,并不是比较方法需要用到它

它是通过compareTo进行比较添加的,如果比较的那个属性值相等,不能返回0,随便返回-1或者1都行,返回-1代表插入的该数会返回到之前就存在的数字的前面,如果为1就代表插入的数会在相同数字的后面

c 只对一个属性进行排序的示例代码
Student类
package Work03;

import java.util.Objects;

public class Student{
    private String name;
    private int age;
    private float degree;
    //分数

    public Student() {
    }

    public Student(String name, int age, float degree) {
        this.name = name;
        this.age = age;
        this.degree = degree;
    }

    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 float getDegree() {
        return degree;
    }

    public void setDegree(float degree) {
        this.degree = degree;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Float.compare(student.degree, degree) == 0 && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, degree);
    }
}
CompareDegree1类
package Work03;

import java.util.Comparator;

public class CompareDegree1 implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        //按照成绩去进行降序
        float temp=o2.getDegree()-o1.getDegree();
        //也可以写成>0返回正数,<=0返回负数,=0意味着插入的数字会在之前已经存在过的数据的上方
        if (temp==0){
            return 1;
        }
        if(temp>0&&temp<1){
            return 1;
        }else if(temp>-1&&temp<0){
            return -1;
        }
        return (int)temp;
    }
}
TestStudent02类
package Work03;

import java.util.Set;
import java.util.TreeSet;

public class TestStudent02 {
    public static void main(String[] args) {
        Set<Student> s=new TreeSet(new CompareDegree1());
        s.add(new Student("马超",20,88.6f));
        s.add(new Student("黄忠",22,77.7f));
        s.add(new Student("李典", 20, 77.7f));
        s.add(new Student("曹操",22,88.7f));
        for (Student temp:s
        ) {
            System.out.println(temp);
        }
    }
}
d 只对一个属性进行排序的示例代码代码运行截图

在这里插入图片描述

2.1.2 示例代码

Student类

package Work03;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private float degree;
    //分数

    public Student() {
    }

    public Student(String name, int age, float degree) {
        this.name = name;
        this.age = age;
        this.degree = degree;
    }

    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 float getDegree() {
        return degree;
    }

    public void setDegree(float degree) {
        this.degree = degree;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Float.compare(student.degree, degree) == 0 && Objects.equals(name, student.name);
    }

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

    @Override
    public int compareTo(Student o) {
        //得不到想要的结果,一般是compareTo里面的逻辑判断出了问题
        if(this.degree==o.degree){
            //如果成绩相同,则需要再根据年龄进行排序
            return this.age-o.age;
        }else{
            //降序需要倒过来,然后里面返回数值的正负和之前没关系
            float temp=o.degree-this.degree;
            if(temp>0&&temp<1){
                return 1;
            }
            if(temp>-1&&temp<0){
                return -1;
            }
            return (int)temp;
        }
    }

}

TestStudent02类

package Work03;

import java.util.Set;
import java.util.TreeSet;

public class TestStudent02 {
    public static void main(String[] args) {
        Set<Student> s=new TreeSet();
        s.add(new Student("马超",20,88.6f));
        s.add(new Student("黄忠",22,77.7f));
        s.add(new Student("李典", 20, 77.7f));
        s.add(new Student("曹操",22,88.9f));
        for (Student temp:s
        ) {
            System.out.println(temp);
        }
    }
}
2.1.3 示例代码运行截图

在这里插入图片描述

2.2 实现java.util.Comparator接口

2.2.1 核心思路
a 写一个自定义比较类实现java.util.Comparator接口
b 重写该接口里面的compare方法逻辑
c 然后在实例化treeSet对象的时候,丢入一个匿名自定义比较对象(里面含有排序规则)
d. 后面使用迭代器去进行遍历取出并打印里面的值即可
2.2.2 示例代码
Student类
package Work03;

import java.util.Objects;

public class Student{
    private String name;
    private int age;
    private float degree;
    //分数

    public Student() {
    }

    public Student(String name, int age, float degree) {
        this.name = name;
        this.age = age;
        this.degree = degree;
    }

    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 float getDegree() {
        return degree;
    }

    public void setDegree(float degree) {
        this.degree = degree;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Float.compare(student.degree, degree) == 0 && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, degree);
    }
}
CompareDegree类
package Work03;

import java.util.Comparator;
public class CompareDegree implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if(o1.getDegree()==o2.getDegree()){
            //如果成绩一样,需要对年龄进行升序排序
            return o1.getAge()-o2.getAge();
        }else{
            //返回值为int类型,但是可能需要强转,所以需要考虑减出来的结果是的绝对值结果是小数的情况
            float temp=o2.getDegree()-o1.getDegree();
            if(temp>0&&temp<1){
                return 1;
            }
            if(temp>-1&&temp<0){
                return -1;
            }
            return (int)temp;
        }
    }
}
TestDegree02类
package Work03;

import java.util.Set;
import java.util.TreeSet;

public class TestStudent02 {
    public static void main(String[] args) {
        Set<Student> s=new TreeSet(new CompareDegree());
        s.add(new Student("马超",20,88.6f));
        s.add(new Student("黄忠",22,77.7f));
        s.add(new Student("李典", 24, 77.7f));
        s.add(new Student("曹操",22,88.9f));
        for (Student temp:s
        ) {
            System.out.println(temp);
        }
    }
}
2.2.3 示例代码运行截图

在这里插入图片描述

2.3 用匿名内部类实现java.util.Comparator接口

2.3.1 核心思路
a 使用匿名内部类(这个类没有名字)去实现java.util.Comparator接口,（仅限于该对象去使用)
b.通过foreach循环取出并打印里面的每一个元素
2.3.2 示例代码
Student类
package Work03;

import java.util.Objects;

public class Student{
    private String name;
    private int age;
    private float degree;
    //分数

    public Student() {
    }

    public Student(String name, int age, float degree) {
        this.name = name;
        this.age = age;
        this.degree = degree;
    }

    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 float getDegree() {
        return degree;
    }

    public void setDegree(float degree) {
        this.degree = degree;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Float.compare(student.degree, degree) == 0 && Objects.equals(name, student.name);
    }

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


}
TestDegree02类
package Work03;

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

public class TestStudent02 {
    public static void main(String[] args) {
        Set<Student> s=new TreeSet(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //前面减去后面,升序,后面减去前面是降序,这里来个升序
                float temp=o1.getDegree()-o2.getDegree();
                if(temp==0){
                    //如果成绩相等就去比较年龄,按照年龄的升序去进行排列
                    //前减去后就是升序
                    return o1.getAge()-o2.getAge();
                }
                //大于0返回正数,小于0就返回负数,这个规则可以记一下
                return temp>0?1:-1;
            }
        });
        s.add(new Student("马超",20,88.6f));
        s.add(new Student("黄忠",22,77.7f));
        s.add(new Student("李典", 24, 77.7f));
        s.add(new Student("曹操",22,88.9f));
        for (Student temp:s
        ) {
            System.out.println(temp);
        }
    }
}
2.3.3 示例代码运行截图

在这里插入图片描述

3.总结

3.1 尽量采用2.2这种采用类去实现Comparator接口这种方式。

3.1.1 理由

例如商品类里面有时需要根据价格排序,有时需要对销量进行排序,用另外两种每次都得改大量的代码,而采用类1实现价格排序,类2实现销量排序,new treeSet对象的时候根据需求去放入合适的类,这样无需进行代码的改动

3.2 虽然用非匿名内部类去实现Comparator接口(util包下面的)的方式比较多,但是另外两种也是要会的,

3.2.1 理由

a 方便看懂他人的代码

b 另外会了三种就可以根据实际情况去选择合适的方法,而不是所有情况都用那么一种

SSS4362
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
TreeSet 自定义排序
JALFJAKJF的博客
07-19 956
TreeSet 自定义排序
黑马程序员--07.集合框架--07.【TreeSet】【TreeSet底层的二叉树】
歆明正航的专栏
07-25 2554
集合框架--7       TreeSet概述 TreeSet底层的二叉树 ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.    TreeSet概述 (1). Set常用子类的回顾 [1]. Set集合具有无序性和唯一性 [2]. HashSet 底层数据结构是哈希表，线程非同步。 保证元素唯一性的办法
Java集合详解——TreeSet集合的介绍及其排序
Best_Basic的博客
08-18 7562
放到TreeS儿童集合中的元素：无序不可重复，但可以按照元素的大小顺序自动排序。 放到TreeSet或者TreeMap集合key部分中的元素要想做到排序，包括两种方式： 第一种：放在集合中的元素实现java.lang.Comparable接口。 第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。 Comparator的设计符合OCP原则。。...
list集合自定义排序
最新发布
蜂蜜柚子茶
06-12 880
本文介绍了基于Comparator，Comparable，stream的三种类型的排序方法。介绍了升序，降序，组合排序，null数据处理等多种情况的排序。
制定TreeSet排序的几种方法
m0_49624594的博客
10-12 1733
一、对int、String类型进行降序输出 1、存储int类型时 public static void main(String[] args) { TreeSet<Integer> intSet = new TreeSet<>(); intSet.add(23); intSet.add(68); intSet.add(33); intSet.add(15); intSet.add(2
JAVA集合，TreeMap排序
随风飘雁
08-11 849
JAVA集合，TreeMap排序。
Set集合中TreeSet里的排序
蝉鸣扰梦
04-14 490
TreeSet:无序不重复列表，又叫二叉树； 倒序返回compareto: -1；顺序返回: 1；返回唯一(数据相等): 0； 记住：排序时，当主要条件相同时，一定要按照次要条件进行再次排序，不然会导致数据丢失。 TreeSet: 可以对Set集合中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性的依据：compareto方法 return 0. ...
浅谈常用字符串与集合类转换的工具类
09-01
这个方法使用正则表达式`"[\\s+]"`来匹配任意空白字符作为分隔符，然后通过`split()`函数将字符串分割为多个元素，并将它们添加到一个排序后的`TreeSet`实例中。这样可以确保集合中的元素没有重复且按某种顺序（如...
TreeSet判断重复元素解析及代码示例
08-28
`TreeSet`保证了其元素按照自然顺序或者自定义比较器的顺序进行排序。在`TreeSet`中，元素的唯一性是由`compareTo()`方法决定的，而不是`equals()`。 `equals()`方法是Java对象默认继承自`Object`类的方法，用于...
Java 集合类面试题.docx
06-15
- `Collections` 是一个工具类，它提供了很多静态方法，用于对 `Collection` 及其子接口实现类进行操作，如排序、查找、反转、线程安全化等。 2. **ArrayList 与 Vector 的差异** - 两者都是 `List` 接口的实现，...
Java 集合框架高难度进阶版面试题集锦解析
06-14
- TreeSet 是有序集合，元素按特定顺序排列，可以使用自定义比较器。 11. EnumSet 和 HashSet 的区别： - EnumSet 专为枚举类型设计，利用位运算优化存储和操作，高效且节省内存。 - HashSet 是通用集合，适用于...
java集合框架之Collection实例解析
09-22
- `TreeSet`：基于红黑树实现，元素按照自然排序或自定义比较器排序，保证了集合的有序性，但插入和删除速度稍慢于`HashSet`。 在学习和使用这些集合时，你需要了解它们各自的特点和适用场景。例如，如果你需要...
Treeset 如何设置自定义的排序规则
qq_31269835的博客
03-02 1208
是什么 : Treeset 是set中的一种具有可以给元素进行排序的作用 并且保证唯一性 做什么 : 进行自定义规则排序 咋样做 两种方式 方式1 要排序的类实现接口Comparable 并且重写方法compareTo,其中返回值分为三种 正数,0,负数, 正数添加到右边 负数添加到左边 0 会把原有数据覆盖. 方式2:匿名内部类 TreeSet<String> set = new TreeSet<>(new Comparator<String>() { @Over
TreeSet中自定义类的排序方法
qq_44655300的博客
11-12 541
TreeSet 自定义类排序
TreeSet集合自定义排序（谨记）
qq_37565772的博客
05-08 1008
TreeSet（不可重复，自动排序）实现自定义排序当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，返回-1表示该元素在前，1表示该元素在后。方法一：让类实现Comparable接口，并覆盖compareTo（）方法，将自定义的类加入TreeSet即可 方法二：自定义一个实现Comparator的排序器，实现...
java treeset类的排序规则_Java中的集合框架之TreeSet排序规则
weixin_39886929的博客
02-24 1384
Java中的集合框架之TreeSet排序规则1、TreeSet排序规则TreeSet集合是一个可以指定元素顺序，即：TreeSet集合是有序的集合类。默认情况下，TreeSet集合的排序规则是自然排序。自然排序：就是元素自身具备的比较性实现了Comparable接口的compareTo()方法。2、自定义排序规则当我们使用TreeSet集合存储自定义对象时，这时候如果不自定义排序规则，则程序会抛出...
Java学习—Treeset的两种排序方法
bairui6666的博客
02-27 674
TreeSet提供了灵活的排序机制，既可以利用Java对象的自然顺序，也可以通过提供自定义的Comparator来实现特定的排序逻辑。选择哪种排序方式取决于你的具体需求。自然排序是对实现了Comparable接口的对象的一种直观排序方式，而定制排序则提供了更多的灵活性，允许定义更加复杂的排序规则。
【Java】TreeSet【自然排序实现Comparable接口、定制排序匿名内部类 new Comparator】 的使用
m0_64210833的博客
03-19 1225
用TreeSet集合存储自定义对象，无参构造方法使用的是 自然排序 对元素进行排序的 自然排序，就是让元素所属的类 实现Comparable接口，重写 compareTo(To)方法 重写方法时，一定要注意排序规则必须按照要求的 主要条件 和 次要条件 来写
javaTreeSet排序
m0_63112274的博客
08-03 332
TreeSet排序 自然排序 比较器排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

SSS4362

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

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

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

打赏作者

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

抵扣说明：

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

余额充值