java基础 之 自定义类的排序：自然排序 和 定制排序

前言

在往期讲Map的时候我们提到了自然排序和定制排序 戳这里→java基础 之 集合与栈的使用（三）
本期就来聊聊自然排序和定制排序的区别

我们在写代码的时候会用到很多的类，有String,Integer等封装类，也有集合类中。
更多的时候根据自己的业务需求需要自己创建很多的类，我们把自己创建的非java中自带的类叫自定义类。

自定义类为什么要排序

• 一般的包装类，如String，Integer都已经自动实现了Comparable接口，重写了compareTo方法，所以可以直接进行排序
• 自定义类在使用hashMap、hashSet或者在对类对象的数组中排序的时候需要对对象进行排序
• 自定义的类没有实现Comparable接口，对于创建的类对象在排序上是没有依据的，所以我们需要排序

自然排序

• 自然排序顺序是指一种默认的对象比较方式，通常基于对象的某个属性或多个属性的值
• 自定义类继承Comparable接口，重写CompareTo方法
  （完整的代码可以到最后的【代码附录】查看）
  

说明：
1、类Person继承了Comparable接口，并重写了compareTo()方法
2、由实现了自然排序的自定义类的集合list，可以直接使用Collenction.sort(list)进行排序
3、由实现了自然排序的自定义类的数组arr，可以直接使用Arrays.sort(arr)进行排序

排序规则
1、this 比 obj 小, 返回负数，不交换
2、this 比 obj 大, 返回正数，两者交换
3、this 和 obj 一样大, 返回0，不交换
4、如果属性是Integer类型的，this.age - obj.age表示升序，obj.age-this.age表示降序

定制排序（指定比较器）

• 自定义类不需要继承Comparable接口，需要匿名内部来来实现Comparator接口
• Comparator必须加上static修饰，final修饰的作用？
• 如果类已经定义了自然排序，也可以添加定制排序，定制排序是对自然排序的一种补充，适用于不适合使用自然排序的情况
  

说明：
1、COMPARATOR_ZIRAN 的功能同自然排序
2、COMPARATOR 实现了一个按照输入顺序倒序排序的功能
3、排序规则同上
4、匿名类重写的compare方法，需要传入的是两个参数

总结

• 实现上的区别：
  • 自然排序是自定义类实现类Comparable接口的，重写的是compareTo方法
  • 定制排序是在类内部使用匿名函数实现Comparator接口，重写的是compare方法
• 对类对象集合排序：
  • 自然排序直接是Collection.sort(List)，可以添加Collections.reverseOrder()参数对排好序的集合倒序排序
  • 定制排序需要传入要排序的比较器，如Collection.sort(List,COMPARATOR），不能对排好序的集合倒序排序
• 变更排序规则：
  • 自然排序变更容易影响已写代码的排序
  • 定制排序更灵活

代码附录

Student类

import java.util.Comparator;

public class Student implements Comparable{
    private String name;  // 姓名
    private Integer age;  // 年龄
    private String sno;   // 学号
    // 构造函数
    public Student(String name, Integer age, String sno) {
        this.name = name;
        this.age = age;
        this.sno = sno;
    }
    // 重写compareto方法。
    @Override
    public int compareTo(Object o) {
        if(o instanceof Student){
            Student s = (Student) o;
            int s_name= this.name.compareTo(s.name);
            int s_age = this.age.compareTo(s.age);
            int s_sno = this.sno.compareTo(s.sno);
            if(s_name!=0){  // 先按照名称排序
                return s_name;
            }else if(s_age!=0){  // 名称相同按照年龄排序
                return s_age;
                //return this.age.compareTo(s.age);
            }else { // 名称、年龄相同，按照学号排序
                return s_sno;
            }
        }
        return 0;
    }
    // 匿名类模拟写自然排序
    public static final Comparator<Student> COMPARATOR_ZIRAN = new Comparator<Student>() {
        @Override
        public int compare(Student s1, Student s2) {
            int s_name = s1.getName().compareTo(s2.getName());
            int s_age = s1.getAge().compareTo(s2.getAge());
            int s_sno = s1.getSno().compareTo(s2.getSno());
            if(s_name!=0){  // 先按照名称排序
                return s_name;
            }else if(s_age!=0){  // 名称相同按照年龄排序
                return s_age;
                //return this.age.compareTo(s.age);
            }else { // 名称、年龄相同，按照学号排序
                return s_sno;
            }
        }
    };

    // 匿名类实现comparaTor接口。这次排序写个固定的不变的
    public static  final Comparator<Student>  COMPARATOR = new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return -1;  // 按输入顺序倒序排序
        }
    };
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Integer getAge() {return age;}

    public void setAge(Integer age) { this.age = age;}
    public String getSno() {return sno;}
    public void setSno(String sno) {this.sno = sno;}
    // 方便打印显示
    @Override
    public String toString() {
        return "Student{" +"name='" + name + '\'' +", age=" + age +", sno='" + sno + '\'' +'}';
    }
}

Test类

（运行结果就自己来吧~）

public class Test {
    public static void main(String[] args) {
        List<Student> listStudent = new ArrayList<>();
        listStudent.add(new Student("a01",11,"110"));
        listStudent.add(new Student("b",21,"100"));
        listStudent.add(new Student("c",11,"120"));
        listStudent.add(new Student("d",20,"999"));
        listStudent.add(new Student("d",21,"200"));
        listStudent.add(new Student("d",21,"100"));
        System.out.println("排序前\n"+listStudent);
        Collections.sort(listStudent);
        Collections.sort(listStudent,Student.COMPARATOR_ZIRAN);
        Collections.sort(listStudent,Student.COMPARATOR);
        System.out.println("排序后\n"+listStudent);
        Collections.sort(listStudent,Collections.reverseOrder());
        System.out.println("排序后\n"+listStudent);
        
        Student[] students = new Student[5];
        students[0] = new Student("jackS",11,"110");
        students[1] = new Student("lucyS",21,"100");
        students[2] = new Student("milkS",11,"120");
        students[3] = new Student("adaS",45,"999");
        students[4] = new Student("jackS",21,"110");
        System.out.println("排序前\n"+Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后\n"+Arrays.toString(students));
    }
}