JavaSE-15.2.2【自然排序Comparable的使用】

package day6.lesson2;

import java.util.TreeSet;

/*
2.2 自然排序Comparable的使用

    案例：
        存储学生对象并遍历，创建TreeSet集合使用无参构造方法
    要求：
        按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
    实现：
        用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
        自然排序，就是让元素所属的类实现Comparable接口，重写compareTo()方法
        重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
 */
public class TreeSetDemo2 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();

        Student s1 = new Student("lisi", 22);
        Student s2 = new Student("wang", 25);
        Student s3 = new Student("sun", 23);
        Student s4 = new Student("sun", 23);
        Student s5 = new Student("amy", 23);

        //Student类实现Comparable接口前：
        /*//day6.lesson2.Student cannot be cast to java.lang.Comparable
        ts.add(s1); //类转换异常
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //Comparable接口对实现它的类的对象强加一个整体排序，称为类的自然排序，类的compareTo()称为其自然比较方法
        //为啥报异常？因为Student未实现Comparable接口*/

        //Student类实现Comparable接口后：
        /*ts.add(s1); //ok但不完全ok
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //lisi,22
        //为啥ts只存储了第一个元素呢？
        //因为Student类未重写Comparable接口的compareTo()
        //而compareTo()默认return0,意思是比较相等元素重复
        //所以只添加了第一个元素，后边的都认为与第一个相同*/

        //Student类重写compareTo()后：
        ts.add(s1); //ok
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        /*
        return 1; //升序
        lisi,22
        wang,25
        sun,23
        sun,23
         */

        /*
        return -1; //降序
        sun,23
        sun,23
        wang,25
        lisi,22
         */

        /*
        自定义：按照年龄升序
        lisi,22
        sun,23
        wang,25
         */

        //注意，s4年龄同s3年龄，返回0，故s4未存入

        /*
        自定义：按照年龄降序
        wang,25
        sun,23
        lisi,22
         */

        /*
        自定义：先年龄升序，年龄相同时按照姓名的字母顺序排序
        lisi,22
        amy,23
        sun,23
        wang,25
         */

        for(Student s: ts){
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

package day6.lesson2;

public class Student implements Comparable<Student>{

    private String name;
    private int age;

    public Student() {
    }

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

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Student s) {
//        return 0; //默认 (说明比较相等，则元素重复)

        //重写
//        return 1; //升序
//        return -1; //降序

        //自定义：按照年龄升序
        /*int num = this.age - s.age; //this-->s2  s-->s1
        return num;*/

        //自定义：按照年龄降序
        /*int num = s.age - this.age;
        return num;*/

        //自定义：先年龄升序，年龄相同时按照姓名的字母顺序排序
        int num = this.age - s.age;
        int num2 = ( num == 0 ? this.name.compareTo(s.name) : num );
        //String类也实现了Comparable接口，所以其内部已重写compareTo()，可直接调用
        return num2;
    }

}