Java集合--TreeSet排序

前言

         排序可谓是TreeSet集合一大难点,重点了

基本类型

默认以升序的方式排序

        //创建一个TreeSet集合
        TreeSet ts =new TreeSet<>();
        //添加String
        ts.add("zs");
        ts.add("ls");
        ts.add("wu");
        ts.add("kc");

        for (String t : ts) {
            //按照字典顺序,升序
            System.out.println(t);
        }
        System.out.println("===============");

        TreeSet ts2 = new TreeSet<>();
        ts2.add(100);
        ts2.add(500);
        ts2.add(50);
        ts2.add(30);
        ts2.add(40);
        ts2.add(40);

        for (Integer integer : ts2) {
            System.out.println(integer);
        }

自定义类

自然排序

自定义类

//放在TreeSet集合中的元素需要实现java.lang.Comparable接口
//并且实现compareTo方法
class Customer implements Comparable{
    int age;

    public Customer(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Customer c) {
        int age=this.age-c.age;
        return age;
    }
    @Override
    public String toString() {
        return "Customer{" +
                "age=" + age +
                '}';
    }
}

测试

package com.javase.test.TreeSet;

import java.util.TreeSet;

public class TreeSetTest05 {
    public static void main(String[] args) {
        Customer c1 = new Customer(21);
        Customer c2 = new Customer(41);
        Customer c3 = new Customer(23);
        Customer c4 = new Customer(22);
        Customer c5 = new Customer(29);

        TreeSet c =new TreeSet<>();
        //添加元素
        c.add(c1);
        c.add(c2);
        c.add(c3);
        c.add(c4);
        c.add(c5);

        //遍历
        for (Customer customer : c) {
            System.out.println(customer);
        }
    }
}

比较器排序

自定义类

//自定义类
class Student{
    int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "student{" +
                "age=" + age +
                '}';
    }
}

自定义比较器

class StudentComparator implements Comparator {

    @Override
    public int compare(Student o1, Student o2) {
        //按年龄排序
        int age=o2.age- o1.age;
        return age;
//
    }
}

测试

public class TreeSetTest07 {
    public static void main(String[] args) {
        //创建集合对象,并给构造函数传一个比较器
        TreeSet students = new TreeSet<>(new StudentComparator());
    
        //添加对象
        students.add(new Student(51));
        students.add(new Student(11));
        students.add(new Student(1));
        students.add(new Student(31));
        students.add(new Student(46));

        for (Student student : students) {
            System.out.println(student);
        }
    }
}

还可用匿名内部类的方式使用比较器排序

public class TreeSetTest07 {
    public static void main(String[] args) {      
        //匿名内部类
        TreeSet birds = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Bird o1, Bird o2) {
                return o1.age-o2.age;
            }
        });

        birds.add(new Bird(51));
        birds.add(new Bird(11));
        birds.add(new Bird(1));
        birds.add(new Bird(31));
        birds.add(new Bird(46));

        for (Bird bird : birds) {
            System.out.println(bird);
        }
    }
}

用法

~当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
~如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用comparator接口。