比较器

package class06;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeMap;

/**
 * 比较器
 * <p>
 * 自定义比较器，比如按照Student对象的id升序排序。
 * 比如当id相同时，按照age降序排序。
 */
public class Code01_Comparator {
    public static class AComp implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    }

    static class Student {
        private String name;
        private int id;
        private int age;

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

    /*
     * 在任何比较器的compare方法中，遵循一个统一的规范：
     * 返回负数时：认为第一个参数应该排在前面。
     * 返回正数时：认为第二个参数应该排在前面。
     * 返回0时，认为谁排在前面都一样。
     */
    public static class idASCAgeDESC implements Comparator<Student> {
        //先按照id升序排序。如果id一样大，则按照age降序排序。
        @Override
        public int compare(Student o1, Student o2) {
            return o1.id != o2.id ? o1.id - o2.id : o2.age - o1.age;
        }
    }

    public static void main(String[] args) {
        Integer[] arr = {5, 1, 4, 6, 9, 8, 2};
        Arrays.sort(arr, new AComp());
        System.out.println("arr = " + Arrays.toString(arr));
        System.out.println("=============== 1 ===============");
        Student student1 = new Student("A", 3, 12);
        Student student2 = new Student("B", 3, 11);
        Student student3 = new Student("C", 2, 21);
        Student student4 = new Student("D", 2, 22);
        Student student5 = new Student("E", 2, 23);

        Student[] students = new Student[]{student1, student2, student3, student4, student5};
        Arrays.sort(students, new idASCAgeDESC());
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.name + ", " + student.id + ", " + student.age);
        }
        System.out.println("=============== 2 ===============");
        ArrayList<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        studentList.add(student5);
        studentList.sort(new idASCAgeDESC());
        for (int i = 0; i < studentList.size(); i++) {
            Student student = studentList.get(i);
            System.out.println(student.name + ", " + student.id + ", " + student.age);
        }
        System.out.println("=============== 3 ===============");
        student1 = new Student("A", 3, 12);
        student2 = new Student("B", 3, 11);
        student3 = new Student("C", 2, 21);
        student4 = new Student("D", 2, 22);
        student5 = new Student("E", 2, 23);
//        TreeMap<Student, String> treeMap = new TreeMap<>(Comparator.comparingInt(a -> a.id));
        TreeMap<Student, String> treeMap = new TreeMap<>((a, b) -> a.id - b.id);
        /*
         * 这样写比较器，就是当a.id和b.id相等时，认为a和b是一样。
         * 所以TreeMap对于id一样的Student对象，只会保存一个。
         * 而且只保存第一个，后边put的id相同的Student对象，不会覆盖之前的对象。
         */
        treeMap.put(student1, "这是学生1，名字叫A");
        treeMap.put(student2, "这是学生2，名字叫B");
        treeMap.put(student3, "这是学生3，名字叫C");
        treeMap.put(student4, "这是学生4，名字叫D");
        treeMap.put(student5, "这是学生5，名字叫E");
        for (Student student : treeMap.keySet()) {
            System.out.println(student.name + ", " + student.id + ", " + student.age);
        }
        System.out.println("=============== 4 ===============");
        student1 = new Student("A", 3, 12);
        student2 = new Student("B", 3, 11);
        student3 = new Student("C", 2, 21);
        student4 = new Student("D", 2, 22);
        student5 = new Student("E", 2, 23);
        //这样定义比较器，就是认为，当a.id和b.id不同时，a和b是不同的对象(前提是a.hashCode()和b.hashCode()不同)。
        //TreeMap也就会把id相同但是hashCode()不同的对象，都保存进有序表。
        TreeMap<Student, String> treeMap3 = new TreeMap<>((a, b) -> a.id != b.id ? a.id - b.id : a.hashCode() - b.hashCode());
        treeMap3.put(student1, "这是学生1，名字叫A");
        treeMap3.put(student2, "这是学生2，名字叫B");
        treeMap3.put(student3, "这是学生3，名字叫C");
        treeMap3.put(student4, "这是学生4，名字叫D");
        treeMap3.put(student5, "这是学生5，名字叫E");
        for (Student student : treeMap3.keySet()) {
            System.out.println(student.name + ", " + student.id + ", " + student.age);
        }

        System.out.println("=============== 5 ===============");
        student1 = new Student("A", 2, 12);
        student2 = new Student("B", 6, 11);
        student3 = new Student("C", 6, 21);
        student4 = new Student("D", 1, 22);
        student5 = new Student("E", 1, 23);
        //先按照id升序排序。如果id一样大，则按照age降序排序。
        TreeMap<Student, String> treeMap2 = new TreeMap<>((a, b) -> a.id != b.id ? a.id - b.id : b.age - a.age);
        treeMap2.put(student1, "这是学生1，名字叫A");
        treeMap2.put(student2, "这是学生2，名字叫B");
        treeMap2.put(student3, "这是学生3，名字叫C");
        treeMap2.put(student4, "这是学生4，名字叫D");
        treeMap2.put(student5, "这是学生5，名字叫E");
        for (Student student : treeMap2.keySet()) {
            System.out.println(student.name + ", " + student.id + ", " + student.age);
        }
    }

}