集合TreeSet（如何实现两种方法排序）

这两种排序方法是用来对象之间的比较。

1. 自然排序（java.lang.Comparable）

2. 比较器排序

第一种排序实现（自然排序）：（实质：序过程中比较两个对象“大小”时使用的就是 Comparable 接口的 compareTo 方法）

第一步： 元素自身具备比较性（比如说年龄）

第二步： 实现Compareable接口，覆盖其CompareTo方法

以学生为例：

 1 package cn.reed_1.itcast;
 2                            // 第一步 ： 学生类继承Comparable
 3 public class Student implements Comparable<Student>{
 4     private String name; // 属性定义为 私有的，防止其类访问
 5     private int age;
 6     //无参构造方法   子类继承父类，会自动继承父类的默认构造方法（无参构造），如果子类中有有参构造，父类无无参构造，则程序会报错（系统不知道继承哪一个构造函数）
 7     public Student() {
 8         super();
 9     
10     }
11     //有参构造方法     构造方法 都用来初始化类的数据成员（姓名和年龄）
12     public Student(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17 
18     public String getName() {
19         return name;
20     }
21 
22     public void setName(String name) {
23         this.name = name;
24     }
25 
26     public int getAge() {
27         return age;
28     }
29 
30     public void setAge(int age) {
31         this.age = age;
32     }  // 第二步 ： 重写 compareTo方法 
33     @Override
34     public int compareTo(Student s) {
35         /*// TODO Auto-generated method stub
36         return 0;
37         //主要条件
38         int num  =this.age-s.age;
39         //次要条件
40         //如果年龄和姓名相同。才是同一个元素
41         //如果年龄相同，就比较名字，否则（年龄不相同，）返回的是年龄
42         int num2 = num == 0? this.name.compareTo(s.name) :num ;
43         return num2;*/
44         
45         //主要条件以名字长度排序
46         int num = (this.name).length()  - s.name.length();
47         //次要条件 （如果名字长度相同，在比较名字内容是否相同）
48         int num2 =num ==0? this.name.compareTo(s.name) :num;
49        //在次要条件（如果名字长度相同，内容也相同，开始比较年龄）
50         int num3 = num2==0? this.age-s.age :num2;
51         return num3;
52         //

comparable接口提供的compareTo 方法，该方法的返回值类型为 int ，如果返回值的值大于0，则代表

当前对象比obj对象大，反之，则相反。则这就是两个对象比较的其实是compareTo方法

第二种方法： TreeSet 有参构造方法（优于自然排序） java.util.Comparator

之所以会有TreeSet的比较器排序，是因为自然排序它仅仅局限于同一个对象的一种方法，当想要采用其他方法进行排序，就必须在原来的方法上修改。

然而运用比较器排序。可以实现同一对象的不同的排序方法

优点： Comparator 接口将比较排序算法和具体的实体类分离了

TreeSet(Comparator<? super E> comparator)

当参数是一个接口，那么它需要的是接口的实现类对象而匿名内部类刚好能做到这一点。

需要做的是： comparetator 具体实现类，并重写方法

package cn.itcast_01;


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

import cn.reed_1.itcast.Student;

public class TreeDemo {
    public static void main(String[] args) {
        //TreeSet(Comparator<? super E> comparator) 
        //当参数是一个接口，那么它需要的是接口的实现类对象(匿名内部类刚好能做到这一点)
                          
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            
            //重写方法  
            @Override  // 重写 compare方法 
            public int compare(Student s1, Student s2) {
                // 主要条件 长度比较   s.name 不能获取到元素，需要用到getName方法
                int num = s1.getName().length() - s2.getName().length();
                // 次要条件 内容比较
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                // 再次要条件
                int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;

                return num3;
            }

        });

        Student s1 = new Student("reed", 20);
        Student s2 = new Student("dora", 22);
        Student s3 = new Student("betty", 25);
        Student s4 = new Student("sunny", 24);
        Student s5 = new Student("reed", 21);
        Student s6 = new Student("reeds", 21);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

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

}