自然排序和比较器

最新推荐文章于 2024-05-30 23:37:57 发布
最新推荐文章于 2024-05-30 23:37:57 发布
阅读量819 收藏 3
点赞数 2
文章标签： ar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Jumpingyyds/article/details/121278350
版权
本文探讨了如何在Java中使用TreeSet进行无序可排序的集合操作。TreeSet要求存储对象实现Comparable接口以进行自然排序，或者在创建时提供Comparator实现类以自定义排序规则。自然排序需要修改对象类，而使用比较器则会在代码中额外增加一个类。当两者同时存在时，比较器优先用于排序。示例展示了如何为自定义对象实现Comparable接口以符合TreeSet的存储要求。

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

Set：无序不可重复

TreeSet：无序可排序，不可重复，不能存储 null 对象的集合，使用 TreeSet 存储对象，对象类要么实现自然排序，要么传递比较器

自然排序：存储进 TreeSet 集合的对象类必须实现 Comparable 接口，重写 comparaTo（），在 comparaTo（）里指定排序规则，返回正数存储的对象往右子树方向，返回负数存储的对象往左子树方向，返回0则不存储

比较器：在创建 TreeSet 集合对象的时候，传递 Comparator 接口的实现类对象，重写 Comparator 接口的 compare（），在compara（）里制定排序规则

自然排序和比较器的区别：

1、使用自然排序需要改变存储对象类的接口

2、使用比较器会额外添加多一个类

3、当比较器与自然排序共存的时候，使用比较器进行排序

import java.util.Iterator;
import java.util.TreeSet;
public class Demo01 {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(6);
        set.add(4);
        set.add(1);
        set.add(5);
        set.add(3);
        set.add(8);
        set.add(2);
        //迭代器
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            Integer num = it.next();
            System.out.println(num);
        }
        //删除
        set.remove(1);
        System.out.println(set);
        //先删除后添加
        set.remove(4);
        set.add(1);
        System.out.println(set);
    }
}

 使用 TreeSet 存储自定义对象，对象类必须实现 Comparable 接口，重写 comparaTo（），比较规则在方法中

import java.util.TreeSet;

public class Demo02 {
    public static void main(String[] args) {
        TreeSet<User> set = new TreeSet<>();
        set.add(new User(2));
        set.add(new User(1));
        set.add(new User(4));
        set.add(new User(3));
        System.out.println(set);
    }
}

public class User implements Comparable<User> {
    private int id;

    public User() {
    }

    public User(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                '}';
    }

    @Override
    public int compareTo(User user) {
        //根据id从小到大排序
        //return this.getId() - user.getId();
        //根据id从大到小排序
        return user.getId() - this.getId();
    }
}
import java.util.TreeSet;
public class Demo01 {
    public static void main(String[] args) {
        TreeSet<Object> set = new TreeSet<>();
        set.add(new User(1,"小明",16));
        set.add(new User(5,"小红",18));
        set.add(new User(3,"小方",16));
        set.add(new User(6,"小刚",18));
        set.add(new User(7,"小丽",16));
        set.add(new User(4,"小黄",24));
        set.add(new User(8,"小陈",16));
        set.forEach(item -> System.out.println(item));
    }
}

public class User implements Comparable<User>{
    private int id;
    private String name;
    private  int age;

    public User() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //以 age 从大到小排序，如果 age 相同以 id 从小到大排序
    @Override
    public int compareTo(User user) {
        if(this.getAge() == user.getAge()){
            return this.getId() - user.getId();
        }
        return user.getAge() - this.getAge();
    }
}
import java.util.TreeSet;
//          比较器排序
public class Demo01 {
    public static void main(String[] args) {
        TreeSet<User> set = new TreeSet<>(new MyComparator());
        set.add(new User(1,"小明",16));
        set.add(new User(5,"小红",18));
        set.add(new User(3,"小方",16));
        set.add(new User(6,"小刚",18));
        set.add(new User(7,"小丽",16));
        set.add(new User(4,"小黄",24));
        set.add(new User(8,"小陈",16));
        set.forEach(item -> System.out.println(item));
    }
}

import java.util.Comparator;

public class MyComparator implements Comparator<User> {
    //以 age 从大到小排序，如果 age 相同以 id 从小到大排序
    @Override
    public int compare(User user1, User user2) {
        if (user1.getAge() == user2.getAge()) {
            return user1.getId() - user2.getId();
        }
        return user2.getAge() - user1.getAge();
    }
}

public class User{
    private int id;
    private String name;
    private  int age;

    public User() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 }
import java.util.Comparator;
import java.util.TreeSet;

//匿名内部类完成比较器传递
public class Demo01 {
    public static void main(String[] args) {
        TreeSet<User> set = new TreeSet<>(new Comparator<User>() {
            //以 age 从小到大排序，如果 age 相同以 id 从大到小排序
            @Override
            public int compare(User user1, User user2) {
                if(user1.getAge() == user2.getAge()){
                    return user2.getId() - user1.getId();
                }
                return user1.getAge() - user2.getAge();
            }
        });
        set.add(new User(1,"小明",16));
        set.add(new User(5,"小红",18));
        set.add(new User(3,"小方",16));
        set.add(new User(6,"小刚",18));
        set.add(new User(7,"小丽",16));
        set.add(new User(4,"小黄",24));
        set.add(new User(8,"小陈",16));
        set.forEach(item -> System.out.println(item));
    }
}

public class User{
    private int id;
    private String name;
    private  int age;

    public User() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

TreeSet的底层代码： 

 TreeSet的实现过程：

 

勇敢流流
关注
【JavaEE基础与高级 第43章】LinkHashSet、Treeset的Comparable接口自然排序和Comparator比较器排序使用
KJ.JK
09-06 1万+
"LinkedHashSet" "继承了HashSet" ，底层在 "哈希表" 的基础上，又维护了一个 "双向链表" * LinkedHashSet 通过双向链表实现了元素的存取有序性(既可以去重 , 也可以保留原来的顺序) //底层是哈希表和双向链表。...
TreeSet集合的理解（自然排序和比较器排序）
j_better的博客
05-11 3640
TreeSet集合TreeSet集合是Set集合的一个子实现类，它是基于TreeMap中的NavigableSet接口实现的TreeSet集合是默认通过自然排序将集合中的元素进行排序TreeSet有两种排序方式：1）自然排序2）比较器排序让我们先来看看一个例题：package com.TreeSetDome; import java.util.TreeSet; public class T...
Java自然排序（个人总结-求赞）
Monster__Day的博客
07-20 5979
这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Comparabl
Java中的排序比较方式：自然排序和比较器排序
木木森林
11-10 690
　　这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Compar...
自然排序和比较器排序
weixin_42278668的博客
08-07 955
自然排序：如果一个类的元素要想要能够进行自然排序， 就必须实现自然排序接口实现Comparable接口重写CompareTo()方法 该学生类进行自然排序，实现Comparable接口 package day17_Set_son_4; /* * 如果一个类的元素要想要能够进行自然排序，就必须实现自然排序接口 */ public class Student implements Comparab...
【TreeSet】自然排序与比较器排序
Java Island
09-01 3419
使用TreeSet自然排序法时需要实现Comparable接口，并将泛型注为当前对象类，然后重写compareTo();方法。 使用TreeSet比较器排序法时不需要实现Comparable接口，只在新建TreeSet时使用匿名内部类重写compareTo方法即可。当对象类为Java内部类或其他没有修改权限的类时可以使用此方法。效果与自然排序相同。在重写compareTo方法时要注意两个形参属性相减的顺序。
自然排序与比较器排序的简单比较
qq_44776025的博客
04-01 574
自然排序与比较器排序 自然排序： 其实就是接口对实现它的每个类对象强行进行整体排序，这种排序就是自然排序。它只有一个方法是compareTo方法，也被称为自然比较方法。 实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。(Arrays.sort(T[] a)) T - 可以与此对象进行比...
Java中自然排序和比较器排序详解
09-01
在Java编程中，排序是我们经常遇到的任务，而自然排序和比较器排序是两种重要的对象排序方式。本文将深入讲解这两种排序方法，并通过实例代码进行演示。 首先，自然排序是指实现了`java.lang.Comparable`接口的类...
Java 自然排序和比较器排序区别？Comparable接口和Comparator比较器区别？
m0_62567916的博客
05-15 845
Comparaable是一个排序接口实现的是自然排序，如果一个类实现了该接口，证明该类能够排序，否则不能排序，强行排序会抛异常。除了上述自然排序外，还可以实现比较器排序，通过创建比较器来说明这个类如何进行排序。二者可以一起用，举一个例子，一个类实现了自然排序，它是逆序输出，这是我突然就有一个例子想正序输出，则就可以写一个比较器。例如现在有一个学生类，该类实现了该接口，那么如果我们定义了一个LIst集合存储了5个该类的对象。或者实现了该接口，但排序规则不适合当前操作，可以考虑使用比较器进行排序。
java自然排序和比较器排序
最新发布
小趴菜不能喝的博客
05-30 303
首先他是函数式接口，可以通过lambda进行简化写法 ，其次是之所以提供比较器排序接口，是因为有时需要对同一对象进行多种不同方式的排序，这点自然排序 Comparable 不能实现。另外， Comparator 接口的一个好处是将比较排序算法和具体的实体类分离了i
TreeSet 不用自然排序自己做比较器
03-07
Comparator<String> com = new Comparator<String>(){ public int compare(String o1,String o2) { return o1.length()-o2.length(); } }; TreeSet ts = new TreeSet(com);... ts.add("string");...
自然排序与比较器排序的使用
qq_43842093的博客
11-25 739
Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int。如果返回值为正数，则表示当前对象(调用该方法的对象)比 obj 对象“大”；反之“小”；如果为零的话，则表示两对象相等。总结为一句话：实现Comparable，重写 compareTo方法案列：以TreeMap为例，默认的升序，可以重写自然排序的方法改变原有排序//自定义TreeMap排序方法 自然排序。
自然排序
weixin_34221775的博客
11-12 150
$a="a1","a2","a3","a4","a5","a6","a7","a8","a9","a10","a11","a12" Sort中的Property 参数的值可以是新的计算属性。若要创建计算属性，使用哈希表，其实就是相当于新添加了一个Property进行排序
自然排序与比较排序
qq_45086286的博客
06-23 389
1.自然排序 class ComparableTest implements Comparable<ComparableTest>{//实现自然排序的类 private String name; private Integer age; @Override public int compareTo(ComparableTest o) {//重写自然排序 // TODO Auto-generated method stub if(this.age<o.age) { r
自然排序Comparable与比较器排序Comparator
未闻花名
02-03 296
自然排序Comparable 要让一个类使用排序服务必须让它实现comparaeTo方法 这是因为需要向sort方法提供比较方式 任何实现Comparable接口的类都需要包含compareTo方法 注意这里的相减技巧不适用于浮点值 举例： 下面以Student按照id从小到大排序分别用两种方式实现: 比较器排序 比较器是实现了Comparator接口的类的实例 方法1：实现Comparable接口 import java.util.*; public class ComparableTest {
java排序比较_Java中自然排序和比较器排序详解
weixin_42517317的博客
02-12 314
前言当指执行插入排序、希尔排序、归并排序等算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口java.lang.Comparable和java.util.Comparator。...
比较器(Comparable和Comparator)、自然排序、定制排序
扬帆向海的博客
11-07 4391
比如Integer，double等基本类型数据，Java可以对他们进行比较排序，但是在 Java 中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题 。这篇博客对比较器进行了详细的说明并配有完整的代码实现。
Java中的自然排序和比较器排序
打酱油的程序员
01-13 5035
写在前面的话：刚开始学习着两者排序时我也是一头雾水，虽然能写出来但是稀里糊涂，几时该用哪个排序一点想法都没有，后来经过研究这两者的作用点不同，自然排序作用在实体类上，而比较器排序作用在装实体类的集合上。 1、自然排序：java.lang.Comparable Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int 。如果返回值为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值