用Comparator比较器实现自定义排序

用Comparator比较器实现自定义排序

首先，先定义一个Student类，

public class Student {
    private String sid;//学号
    private String name;//姓名
    private int age;//年龄
    private int score;//考试分数


    public Student() {
    }

    public Student(String sid, String name, int age, int score) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.score = score;
    }

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

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    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 int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

1、有序集合

在有序集合定义时，如果该集合存储的值是自定义对象，则需要用Comparator来对其指定排序规则，从而使该集合实现有序存储的功能。在这里以TreeSet为例。
测试类：

import java.util.TreeSet;

public class ComparatorTest {
    public static void main(String[] args) {
        //创建一个用来存储Student对象的TreeSet集合，指定其排序方法为自定义的StudentCompartor()
        TreeSet<Student> studentTreeSet = new TreeSet<>(new StudentCompartor());

        //创建四个Student对象并将其存入上面创建的TreeSet中
        Student s1 = new Student("S123","黄一",20,90);
        Student s2 = new Student("S128","黄二",19,90);
        Student s3 = new Student("S150","黄三",19,70);
        Student s4 = new Student("S130","黄四",18,80);
        studentTreeSet.add(s1);
        studentTreeSet.add(s2);
        studentTreeSet.add(s3);
        studentTreeSet.add(s4);

        //遍历输出各个Student
        //System.out.println(studentTreeSet); //这样输出各个Student对象之前只是用‘，’隔开，并不换行，效果不直观。
        for (Student s: studentTreeSet) {
            System.out.println(s);
        }
    }
}

比较器类：

import java.util.Comparator;

public class StudentCompartor implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if(o1.getScore() == o2.getScore()){
            return o1.getAge() - o2.getAge();
        }else{
            return o2.getScore() - o1.getScore();
        }
    }
}

运行结果

由于上面的比较器类只使用了一次，我们也可以采用匿名定义的方式来使用它，即将上面两面两段代码合并为：

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

public class ComparatorTest {
    public static void main(String[] args) {
        //创建一个用来存储Student对象的TreeSet集合，指定其排序方法为自定义的StudentCompartor()
        //TreeSet<Student> studentTreeSet = new TreeSet<>(new StudentCompartor());
        TreeSet<Student> studentTreeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getScore() == o2.getScore()){
                    return o1.getAge() - o2.getAge();
                }else{
                    return o2.getScore() - o1.getScore();
                }
            }
        });

        //创建四个Student对象并将其存入上面创建的TreeSet中
        Student s1 = new Student("S123","黄一",20,90);
        Student s2 = new Student("S128","黄二",19,90);
        Student s3 = new Student("S150","黄三",19,70);
        Student s4 = new Student("S130","黄四",18,80);
        studentTreeSet.add(s1);
        studentTreeSet.add(s2);
        studentTreeSet.add(s3);
        studentTreeSet.add(s4);

        //遍历输出各个Student
        //System.out.println(studentTreeSet); //这样输出各个Student对象之前只是用‘，’隔开，并不换行，效果不直观。
        for (Student s: studentTreeSet) {
            System.out.println(s);
        }
    }
}

我们可以看到运行结果与上面一致：

2、对无序集合进行排序

直接使用Collections.sort()方法，对其进行排序，
采用类外部的 StudentComparator()规则排序

        //对无序集合进行排序
        Collections.sort(studentList, new StudentComparator());

在类里面定义一个Comparator()规则进行排序

import java.util.*;

public class ComparatorTest2 {
    public static void main(String[] args) {
        //创建一个用来存储Student对象的TreeSet集合，指定其排序方法为自定义的StudentCompartor()
        //TreeSet<Student> studentTreeSet = new TreeSet<>(new StudentCompartor());
       /* TreeSet<Student> studentTreeSet = new TreeSet<>(new Comparator<Student>(){
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getScore() == o2.getScore()){
                    return o1.getAge() - o2.getAge();
                }else{
                    return o2.getScore() - o1.getScore();
                }
            }
        });*/
        
        List<Student> studentList = new ArrayList<>();

        //创建四个Student对象并将其存入上面创建的TreeSet中
        Student s1 = new Student("S123","黄一",20,90);
        Student s2 = new Student("S128","黄二",19,90);
        Student s3 = new Student("S150","黄三",19,70);
        Student s4 = new Student("S130","黄四",18,80);
        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);


        //对无序集合进行排序
        Collections.sort(studentList, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getScore() == o2.getScore()){
                    return o1.getAge() - o2.getAge();
                }else{
                    return o2.getScore() - o1.getScore();
                }
            }
        });

        //遍历输出各个Student
        //System.out.println(studentTreeSet); //这样输出各个Student对象之前只是用‘，’隔开，并不换行，效果不直观。
        for (Student s: studentList) {
            System.out.println(s);
        }
    }
}

运行结果：