精华内容
下载资源
问答
  • Java TreeSet排序的2种方法

    千次阅读 2021-02-27 20:05:44
    TreeSet类Java TreeSet排序的2种方法1.自然排序,实现Comparable接口,重写compareTo方法。让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法,这种方式也称为元素的自然排序或默认排序方式。...

    首页 > 基础教程 > 集合框架 > TreeSet类

    Java TreeSet排序的2种方法

    1. 自然排序,实现Comparable接口,重写compareTo方法。

    让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法,这种方式也称为元素的自然排序或默认排序方式。排序代码如下:

    /* 向TreeSet集合中存储自定义对象学生按照学生的年龄进行排序 */

    import java.util.*;

    //此接口强制让Student实现比较性

    class Student implements Comparable { //定义Student私有属性

    private String name;private int age; //构造Student函数,初始化

    Student(String name, int age) {this.name = name;

    this.age = age;

    } //公共访问方法,访问私有属性

    public String getName() {

    return name;

    }

    public int getAge() {

    return age;

    } //复写Comparator中的compare方法,自定义比较器

    public int compareTo(Object obj) {

    //判断是否属于Student类型,否则抛异常

    if (! (obj instanceof Student)) throw new RuntimeException("NotSuchTypeException"); //将Object类对象强转为Student类

    Student s = (Student) obj;

    //System.out.println(this.age + "--compare-" + s.age);//测试用,查看比较情况

    //按年龄大小比较,相同则比较姓名大小,不同返回两年龄之差

    if (this.age == s.age) {

    return this.name.compareTo(s.name);

    } else if (this.age < s.age) return this.age - s.age;

    return this.age - s.age;

    }

    /*

    //如果按照存入顺序输出

    public int compareTo()

    {

    return 1;//改为-1则按倒叙输出

    }

    */

    }

    //测试

    class TreeSetTest {

    public static void main(String[] args) { //创建集合,并添加元素

    TreeSet ts = new TreeSet();ts.add(new Student("li01", 25));ts.add(new Student("li02", 20));ts.add(new Student("li01", 22));ts.add(new Student("li05", 24));

    ts.add(new Student("li08", 40)); //打印集合中元素

    printE(ts);

    System.out.println("Hello World!");

    }

    //定义打印集合中元素的功能

    public static void printE(TreeSet ts) {

    //迭代器方法获取

    Iterator it = ts.iterator();

    while (it.hasNext()) {

    //将返回的元素(Object类)强转为Student类

    Student s = (Student) it.next();System.out.println(s.getName() + "---" + s.getAge());

    }

    }

    }

    2. 比较器,实现Comparator接口,并实现其compare(Object o1,Object o2)方法。

    当元素自身不具备比较性是,或者具备比较性,却不是所需要的,这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式(即参阅构造函数),其实就是定自己定一个比较器,这个比较器必须实现Comparator接口,并实现其compare(Object o1,Object o2)方法,方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同,然后将这个比较器作为参数传入TreeSet构造方法中。

    注意: 当两种排序方式都存在时,以比较器为主,排序时,当主要条件相同时,按次要条件排序。字符串本身具备比较性,但是它的比较方式可能不是所需要的,这时,就只能使用比较器了。

    版权声明:本文为JAVASCHOOL原创文章,未经本站允许不得转载。

    展开全文
  • 关于Java Treeset排序

    2021-02-28 10:21:03
    实现先按学生的成绩升序排序,若成绩相等再按年龄升序排序,若年龄相等...package 第四道题;import java.util.Comparator;/** 学生有名字,年龄,成绩字段把多个学生放进一个TreeSet集合;(1).实现先按学...

    package第四道题;importjava.util.Comparator;/**学生有名字,年龄,成绩字段把多个学生放进一个TreeSet集合;(1).实现先按学生的成绩升序排序,若成绩相等再按年龄升序排序,若年龄相等...

    package 第四道题;

    import java.util.Comparator;

    /*

    * 学生有名字,年龄,成绩字段

    把多个学生放进一个TreeSet集合;

    (1).实现先按学生的成绩升序排序,若成绩相等再按年龄升序排序,若年龄相等再按照名字升序排序;

    (2).实现先按学生的成绩逆序排序,若成绩相等再按年龄逆序排序,若年龄相等再按照名字逆序排序;

    */

    public class Student{

    private String name;

    private Integer age;

    private Integer degree;

    public Student(String name,Integer age,Integer degree){

    this.name=name;

    this.age=age;

    this.degree=degree;

    }

    public Student(){}

    public String getName() {

    return name;

    }

    public Integer getAge() {

    return age;

    }

    public Integer getDegree() {

    return degree;

    }

    /*public int compare(Student o1, Student o2) {

    if(o1.getDegree()

    return 1;

    }else if(o1.getDegree()>o2.getDegree()){

    return -1;

    }else{

    if(o1.getAge()

    return 1;

    }else if(o1.getAge()>o2.getAge()){

    return -1;

    }else{

    return 0;

    }

    }

    }

    */

    @Override

    public String toString() {

    return "["+name+","+age+","+degree+"]";

    }

    }

    package 第四道题;

    /*

    * 学生有名字,年龄,成绩字段

    把多个学生放进一个TreeSet集合;

    (1).实现先按学生的成绩升序排序,若成绩相等再按年龄升序排序,若年龄相等再按照名字升序排序;

    (2).实现先按学生的成绩逆序排序,若成绩相等再按年龄逆序排序,若年龄相等再按照名字逆序排序;

    */

    import java.util.TreeSet;

    import java.util.Comparator;

    import java.util.Set;

    public class TestDemo {

    public static void main(String[] args) {

    Student a=new Student("张三", 17, 90);

    Student b=new Student("李四", 17, 90);

    Student c=new Student("王五", 20, 92);

    /**

    * 升序排序

    */

    Set set=new TreeSet<>(new Comparator() {

    public int compare(Student o1, Student o2) {

    if(o1.getDegree()

    return -1;

    }else if(o1.getDegree()>o2.getDegree()){

    return 1;

    }else{

    if(o1.getAge()

    return -1;

    }else if(o1.getAge()>o2.getAge()){

    return 1;

    }else{

    return 0;

    }

    }

    }

    });

    set.add(a);

    set.add(b);

    set.add(c);

    System.out.println(set);

    }

    }

    这样运行结果是[[张三,17,90], [王五,20,92]] 请大神告诉我怎么实现名字自然排序???

    展开

    展开全文
  • 一、对int、String类型进行降序输出 1、存储int类型时 ... TreeSet<Integer> intSet = new TreeSet<>(); intSet.add(23); intSet.add(68); intSet.add(33); intSet.add(15); intSet.add(2

    一、对int、float、String类型进行降序输出

    TreeSet在默认的情况下对int、float等基本数据以及String类型的排序升序排序的,但如果我们想对这类数据执行降序排序怎么办呢?别怕,TreeSet提供了个descendingSet();来满足我们这一需求,下面分别以int类型和String类型的数据进行演示如何在代码中使用descendingSet()来实现降序排序。

    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(22);
            intSet.add(53);
            System.out.println("整型在TreeSet中自然排序后输出:");
            for (int x : intSet) {
                System.out.printf("%d ", x);
            }
            System.out.println();
            TreeSet<Integer> reIntSet = new TreeSet<Integer>();
            reIntSet = (TreeSet) intSet.descendingSet();
            System.out.println("整型降序排序后输出:");
            //此处也可以直接遍历intSet.descendingSet()结果是相同的
            //即for (int x : intSet.descendingSet())
            for (int x : reIntSet) {
                System.out.printf("%d ", x);
            }
    
        }

    输出为:

    2、存储String类型时

    public static void main(String[] args) {
            TreeSet<String> stringSet = new TreeSet<>();
            stringSet.add("makor");
            stringSet.add("jack");
            stringSet.add("Boolo");
            stringSet.add("xiaodong");
            stringSet.add("3huan");
            stringSet.add("3ajk");
            System.out.println("String在TreeSet中自然排序后输出:");
            for (String s : stringSet) {
                System.out.printf("%s ", s);
            }
            System.out.println("\nString降序后输出:");
            for (String s : stringSet.descendingSet()) {
                System.out.printf("%s ", s);
            }
            
        }

    输出为:

    二、对自定义对象进行排序

            有时候,我们会有对自定义类进行排序的需求,这个时候就要用到我们的Comparator接口和Comparable接口了。        

    1、通过比较器Comparator来实现(让容器自身具有比较性)

    首先我们创建一个自定义对象User:

    static class User {
            int age;
            String name;
            User(){}
            User(int age, String name) {
                this.age = age;
                this.name = name;
            }
            public String toString(){
                return "姓名:" + name + ", 年龄:" + age;
            }
    
            //根据age来升序排序的比较器
            static class UserCompForAge implements Comparator {
                @Override
                public int compare(Object o1, Object o2) {
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    // 注意:此处用自定义类的age来实施比较,
                    // 所以age值相同的元素不能被加入成功
                    return u1.age - u2.age;
                }
            }
            //根据name来降序排序的比较器
            static class UserCompForName implements Comparator {
                @Override
                public int compare(Object o1, Object o2) {
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    // 注意:此处用自定义类的name来实施比较,
                    // 所以name值相同的元素后面不能被加入成功
                    return u2.name.compareTo(u1.name);
                }
            }
            //根据age降序,若age相同则根据name来升序排序的比较器
            //若age和name都相同,则加入不成功
            static class UserCompForAgeAndName implements Comparator {
                @Override
                public int compare(Object o1, Object o2) {
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    if (u1.age == u2.age) return u1.name.compareTo(u2.name);
                    return u2.age - u1.age;
                }
            }
        }

    然后编写测试方法,此处我们传入的是根据age升序来排序的比较器

    (TreeSet<User> userSet = new TreeSet<>(new User.UserCompForAge());):

    public static void main(String[] args) {
            //此处传入的是根据age来排序的,所以后面加入的user中,
            //如果年龄已经出现过了,就加入不了集合中
            TreeSet<User> userSet = new TreeSet<>(new User.UserCompForAge());
            userSet.add(new User(18, "zhang"));
            userSet.add(new User(58, "li"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(68, "wang"));
            userSet.add(new User(18, "qian"));
            userSet.add(new User(18, "wu"));
            for (User u : userSet) {
                System.out.println(u.toString());
            }
        }

     运行结果如下:

    修改测试代码,将传入的比较器换成根据name降序排序的比较器,只需要修改下面这行代码:

    TreeSet<User> userSet = new TreeSet<>(new User.UserCompForName());具体如下:
    public static void main(String[] args) {
            //此处传入的是根据name来排序的,所以后面加入的user中,
            // 如果name已经出现过了,就加入不了集合中
            TreeSet<User> userSet = new TreeSet<>(new User.UserCompForName());
            userSet.add(new User(18, "zhang"));
            userSet.add(new User(58, "li"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(68, "wang"));
            userSet.add(new User(18, "qian"));
            userSet.add(new User(18, "wu"));
            for (User u : userSet) {
                System.out.println(u.toString());
            }
        }

    运行结果如下:

     

     可以发现,TreeSet会根据传入的比较器来去重(即:如果向集合中加入一个元素,它会先将该元素中的一个属性与集合中已有的元素的这个属性进行比较,如果该属性的值已经出现过了,那么这个元素将不能加入集合。比较的那个属性是你传入的比较器中来指定排序规则的那个属性)。

    当然,我们也可以通过修改比较器中的compare方法,让元素的排序规则由多个属性的值来决定,那么只要这些属性的值中有一个不同,那么就可以加入成功,但如果都相同的话,还是不能加入成功。测试代码只修改了下面这一行

    TreeSet<User> userSet = new TreeSet<>(new User.UserCompForAgeAndName());

    具体如下:

    public static void main(String[] args) {
            //此处传入的是根据age,name来排序的,所以后面加入的user中,
            // 如果集合中有元素的age和name值都与要加入的元素的值相同的话,就加入不了集合中
            TreeSet<User> userSet = new TreeSet<>(new User.UserCompForAgeAndName());
            userSet.add(new User(18, "zhang"));
            userSet.add(new User(58, "li"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(68, "wang"));
            userSet.add(new User(18, "qian"));
            userSet.add(new User(18, "wu"));
            for (User u : userSet) {
                System.out.println(u.toString());
            }
        }

    输出如下,我们可以看出,代码中先后加入了两个age=28, name=“wang”的元素,但只成功加入了第一个。而单独的name或age相同的元素,我们都能加入多个。

    2、自定义类实现Comparable接口(让元素自身具有比较性)  

    首先,我们编写我们的测试方法如下:

    public static void main(String[] args) {
            TreeSet<User> userSet = new TreeSet<>();
            userSet.add(new User(18, "zhang"));
            userSet.add(new User(58, "li"));
            userSet.add(new User(28, "wang"));
            userSet.add(new User(68, "wang"));
            userSet.add(new User(18, "qian"));
            userSet.add(new User(18, "wu"));
            for (User u : userSet) {
                System.out.println(u.toString());
            }
        }

     然后编写我们的User类,此处实现了Comparable接口,需要重写compareTo方法,然后在该方法中实现我们自定义的比较逻辑。同样的,集合中不能有相同的决定我们排序规则的属性值。具体代码如下:

    static class User implements Comparable{
            int age;
            String name;
            User(){}
            User(int age, String name) {
                this.age = age;
                this.name = name;
            }
            public String toString(){
                return "姓名:" + name + ", 年龄:" + age;
            }
            @Override
            //根据age升序,age相同的根据name降序排序,重复的age和name会加入集合失败
            public int compareTo(Object o) {
                User u = (User) o;
                if (age == u.age) return u.name.compareTo(name);
                return age - u.age;
            }
    
    //        @Override
    //        //根据name降序排序,重复的name会加入集合失败
    //        public int compareTo(Object o) {
    //            User u = (User) o;
    //            return u.name.compareTo(name);
    //        }
    //        @Override
    //        //根据age升序排序,重复的age会加入集合失败
    //        public int compareTo(Object o) {
    //            User u = (User) o;
    //            return age - u.age;
    //        }
            
    
        }

    运行结果如下:

     此处我们使用的是根据age升序,age相同的根据name降序来排序的,所以测试代码中add了两个age=28, name="wang"的对象,可加入集合的只有一个。当然也可以根据单独的age或那么来制定排序规则,实现方法如User类中的注释代码所示。运行结果与定义Comparator类的类似,此处就不重复演示了。有兴趣的读者可以自己运行一下以增加理解和印象。

    展开全文
  • TreeSet使用与总结1.基础知识点集合中元素唯一可进行自由排序2.排序方法2.1自然排序排序对象必须实现了Comparable接口,否则出现转换异常。import lombok.Getter;import lombok.Setter;/*** 比较对象* @author wsz* ...

    TreeSet使用与总结

    1.基础知识点

    集合中元素唯一可进行自由排序

    2.排序方法

    2.1自然排序

    排序对象必须实现了Comparable接口,否则出现转换异常。import lombok.Getter;

    import lombok.Setter;

    /**

    * 比较对象

    * @author wsz

    * @date 2018年1月7日

    */

    public class Person implements Comparable{

    @Setter

    @Getter

    private int id;

    @Setter

    @Getter

    private int age;

    @Setter

    @Getter

    private String name;

    /**

    * Compares this object with the specified object for order. Returns a

    * negative integer, zero, or a positive integer as this object is less

    * than, equal to, or greater than the specified object.

    *

    * @param o the object to be compared.

    * @return a negative integer, zero, or a positive integer as this object

    * is less than, equal to, or greater than the specified object.

    * 比较规则:

    * 返回负数,倒序存储;

    * 返回0,即包含重复,无法再次添加;

    * 返回正数,正序存储

    */

    @Override

    public int compareTo(Person o) {

    int temp = this.id - o.id;

    if(temp == 0)return this.age - o.age;//假如id相等,可以继续比较其他字段

    return temp;

    }

    public Person(int id, int age, String name) {

    super();

    this.id = id;

    this.age = age;

    this.name = name;

    }

    @Override

    public String toString() {

    return "Person [id=" + id + ", age=" + age + ", name=" + name + "]";

    }

    }

    import java.util.TreeSet;

    /**

    * 自然排序模式

    * 所比较对象必须实现Comparable接口

    * @author wsz

    * @date 2018年1月7日

    */

    public class Demo {

    public static void main(String[] args) {

    //先比较id;如果id相等,则比较age。

    TreeSet set = new TreeSet();

    set.add(new Person(1,3,"a"));

    set.add(new Person(1,2,"a"));

    set.add(new Person(1,1,"a"));

    set.add(new Person(2,2,"b"));

    set.add(new Person(3,3,"c"));

    for (Person p : set) {

    System.out.println(p.toString());

    }

    }

    }

    2.2比较器方法

    import java.util.Comparator;

    import java.util.TreeSet;

    /**

    * 比较器方法

    * @author wsz

    * @date 2018年1月7日

    */

    public class Test {

    public static void main(String[] args) {

    TreeSet set = new TreeSet(new Comparator() {

    //先比较是否相等;若相等,则比较长度。

    @Override

    public int compare(String s1, String s2) {

    //s1为新增的参数

    //s2为集合中的数据

    System.out.println(s1+"_"+s2);

    int temp = s1.compareTo(s2);

    if(temp == 0) return s1.length() - s2.length();

    return temp;

    }

    });

    set.add("aaaaaa");

    set.add("aaa");

    set.add("abc");

    set.add("bcd");

    set.add("cde");

    set.add("aa");

    for (String string : set) {

    System.out.println(string);

    }

    }

    }

    展开全文
  • 使用jdk1.8新特性做Treeset排序 public static void main(String[] args){ TreeSet integers = new TreeSet<>((o1, o2) -> o2.compareTo(o1)); integers.add(“张三”); integers.add(“SDK积分”); ...
  • import java.util.Iterator;import java.util....public class Main {public static void main(String[] args){TreeSet classMates = new TreeSet<>();classMates.add(new ClassMate("Lilith", 10, 6));c...
  • TreeSet排序

    2021-03-25 16:03:22
    两种排序 Comparable与Comparator接口 Comparable(内部)一般让类去实现,然后重写compareTo方法 public class Human implements Comparable<Human> --------------- public int compareTo(Human o) { ...
  • 集合操作--treeset排序

    2021-04-08 09:59:38
    //TreeSet 设定了比较器之后,加入的数据自动排序//TreeSet数据可以排序,但不能重复//TreeSet中的元素必须可排序,要么元素是接口comparable实现类的实例,要么给定比较器import java.util.TreeSet;public class Main {...
  • import java.util.Comparator; import java.util.TreeMap;... } } } 以上这篇浅谈java中的TreeMap 排序TreeSet 排序就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。
  • TreeSet排序JSONObject

    2021-02-02 16:45:02
    TreeSet构造方法 /** * Constructs a new, empty tree set, sorted according to the specified * comparator. All elements inserted into the set must be <i>mutually * comparable</i> by the ...
  • 前言:对于后端开发而言,学会对数据的自定义排序还是十分有必要的。需要用到排序的场景也是很多的,什么排行版展示、利用时间+别的条件排序、还有预接单的数据就是要展示在已接单的数据前面这种需求、等等。总之很...
  • TreeSet : 自定义倒序排序,默认按照正序排序,1,2,3,4,5,6 package com; import java.util.Comparator; import java.util.TreeSet; public class Test6 { /** * @param args */ public static void main(String[] ...
  • TreeSet进行排序的方法

    2021-09-24 10:04:41
    TreeSet进行排序的方法的方法有两种,分别是 一种是类实现Comparable<>方法,重写compareTo(Object o)方法 public class Demo1 { public static void main(String[] args) { Student s1 = new Student(...
  • 该结构支持按给定的排序规则遍历。 于是就想到了 priorityQueue!!! 给它定义一个按字符串的长度倒序排序: priorityQueue = new PriorityQueue<>(Comparator.comparingInt(String::length).reversed()); ...
  • java集合-TreeSet排序方式
  • TreeSet是依靠TreeMap来实现的。TreeSet是一个有序集合,TreeSet...TreeSet支持两种排序方法:自然排序和定制排序TreeSet默认采用自然排序。Java常用类实现Comparable接口,并提供了比较大小的标准。实现Comparabl...
  • TreeSet集合里的元素都会按一定的大小顺序排序 public class main { public static void main(String[] args) { TreeSet<customInt> ts = new TreeSet(); ts.add(new customInt(20)); ts.add( new ...
  • 2、定制排序 TreeSet的自然排序是根据集合元素的大小,TreeSet将他们以升序排列。如果需要实现定制排序,例如降序,则可以使用Comparator接口。该接口里包含一个int compare(T o1, T o2)方法,该方法用于比较o1...
  • TreeSet 和TreeMap 排序

    2021-03-05 13:17:44
    TreeSet 有两种排序方式1. Java.lang.Comparble+compareTonew TreeSet()用这种方法必须要求实体类实现Comparable接口,也就是说要求添加到TreeSet中的元素是可排序的2. java.util.Comparator +compare举个TreeSet...
  • 2、定制排序TreeSet的自然排序是根据集合元素的大小,TreeSet将他们以升序排列。如果需要实现定制排序,例如降序,则可以使用Comparator接口。该接口里包含一个int compare(T o1, T o2)方法,该方法用于比较o1和o2...
  • 放到TreeSet或者TreeMap集合key部分的元素要想做到排序,包括两种方式: 第一种:放在集合中的元素实现java .lang. Comparable接口。 第二种:在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。 1.实现...
  • TreeSet支持两种排序方法:自然排序和定制排序TreeSet默认采用自然排序。1、自然排序TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系,然后将集合元素按升序排列,这种方式就是自然排序...
  • TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Object o)方法;该方法用于比较对象,若:obj...
  • 演示TreeSet对String是可排序的 1.TreeMap集合底层实际上是一个TreeMap 2.TreeMap集合底层是一个二叉树 3.放到TreeSet集合中的元素,等同于放到TreeMap集合key部分了 4.TreeSet集合中的元素,无序不可重复,但是可以...
  • @ Eugene的答案很甜蜜,因为番石榴很甜.但如果您的类路径中没有Guava,这是另...首先,我将所有集合平面化为一个流,然后我将所有元素排序,最后,我将整个排序流收集到集合列表中.为此,我正在调用一个使用自定义收集器的...
  • import java.util.TreeSet; class Person{ private String name ; private int age ; public Person(String name,int age){ this.name = name ; this.age = age ; } public String gtoStr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,653
精华内容 25,061
关键字:

treeset排序