TreeSet集合的自然排序与比较器排序、Comparable接口的compareTo()方法

【自然排序】

package com.hxl;

public class Student implements Comparable<Student> {

    private String name;
    private int age;

    public Student() {
        super();
    }

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

    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;
    }

    @Override
    public int compareTo(Student s) {
        // 先让两个对象的age属性做差比较，这个是主要排序条件
        int num = this.age - s.age;
        // 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
        // 即在主要排序条件相同的情况下，次要排序条件起作用
        int flag = num == 0 ? this.name.compareTo(s.name) : num;
        // 返回比较结果
        return flag;
    }
}

package com.hxl;

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //这里使用的无参构造实例化TreeSet集合，则默认启用的是自然排序
        TreeSet<Student> ts = new TreeSet<Student>();
        ts.add(new Student("cc", 11));
        ts.add(new Student("ee", 11));
        ts.add(new Student("cc", 22));
        ts.add(new Student("aa", 22));
        ts.add(new Student("bb", 11));

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

        /*
            为什么TreeSet集合中的元素既唯一又有序呢？
            原因是它在存储元素的时候就是有序存储的（红黑树结构存储）
            TreeSet的add()方法底层依赖的是Comparable的compareTo方法
            这里就是说元素类本身要有自己的compareTo方法
            所以元素类本身必须实现Comparable接口，重写compareTo方法
            compareTo方法有个特点：它返回的是int型数据，结果有三类负数、0、正数
            例如：(Java中一些常见的有比较意义的一些类都实现了Comparable接口，如Integer类)
                Integer a = new Integer(10);
                Integer b = new Integer(20);
                int num = a.compareTo(b);     //因为a小于b，所以num返回的是负数
            而TreeSet的add()方法这样理解此返回值：
            即返回负数则比根节点小，元素在此集合中唯一，元素存放根的左孩子
            返回正数则比根节点大，元素在此集合中唯一，元素存放根的右孩子
            返回0则表示，元素相同，在此集合中不唯一，故而丢掉不存放
            由此可见，我们的重写的compareTo()方法决定了TreeSet集合中元素的去留和顺序！
        */
    }
}

【比较器排序（外部类实现）】

package com.hxl;

public class Student{

    private String name;
    private int age;

    public Student() {
        super();
    }

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

    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;
    }
}

package com.hxl;

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        // 先让两个对象的age属性做差比较，这个是主要排序条件
        int num = s1.getAge() - s2.getAge();
        // 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
        // 即在主要排序条件相同的情况下，次要排序条件起作用
        int flag = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        // 返回比较结果
        return flag;
    }
}

package com.hxl;

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //这里使用TreeSet(Comparator comparator)构造实例化TreeSet集合，则启用的是指定比较器排序
        TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());
        ts.add(new Student("cc", 11));
        ts.add(new Student("ee", 11));
        ts.add(new Student("cc", 22));
        ts.add(new Student("aa", 22));
        ts.add(new Student("bb", 11));

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

【比较器排序（内部类实现，如果只使用一次的话）】

package com.hxl;

public class Student{

    private String name;
    private int age;

    public Student() {
        super();
    }

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

    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;
    }
}

package com.hxl;

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

public class Test {
    public static void main(String[] args) {
        //如果一个方法的参数是接口，那么真实想要的是其实是接口实现类的对象
        //这里的对象只用一次，专门定义一个外部类显得麻烦
        //匿名内部类可以实现这个需求
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>(){
            public int compare(Student s1, Student s2) {
                // 先让两个对象的age属性做差比较，这个是主要排序条件
                int num = s1.getAge() - s2.getAge();
                // 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
                // 即在主要排序条件相同的情况下，次要排序条件起作用
                int flag = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                // 返回比较结果
                return flag;
            }
        });
        ts.add(new Student("cc", 11));
        ts.add(new Student("ee", 11));
        ts.add(new Student("cc", 22));
        ts.add(new Student("aa", 22));
        ts.add(new Student("bb", 11));

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

 【注】开发中会用最后一种，因为第一种只有固定的排序方式，第二种每次都要定义外面类显得麻烦。