1 package day6.lesson2;
  2 
  3 import java.util.TreeSet;
  4 
  5 /*
  6 2.2 自然排序Comparable的使用
  7 
  8     案例：
  9         存储学生对象并遍历，创建TreeSet集合使用无参构造方法
 10     要求：
 11         按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 12     实现：
 13         用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
 14         自然排序，就是让元素所属的类实现Comparable接口，重写compareTo()方法
 15         重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
 16  */
 17 public class TreeSetDemo2 {
 18     public static void main(String[] args) {
 19         TreeSet<Student> ts = new TreeSet<>();
 20 
 21         Student s1 = new Student("lisi", 22);
 22         Student s2 = new Student("wang", 25);
 23         Student s3 = new Student("sun", 23);
 24         Student s4 = new Student("sun", 23);
 25         Student s5 = new Student("amy", 23);
 26 
 27         //Student类实现Comparable接口前：
 28         /*//day6.lesson2.Student cannot be cast to java.lang.Comparable
 29         ts.add(s1); //类转换异常
 30         ts.add(s2);
 31         ts.add(s3);
 32         ts.add(s4);
 33         ts.add(s5);
 34         //Comparable接口对实现它的类的对象强加一个整体排序，称为类的自然排序，类的compareTo()称为其自然比较方法
 35         //为啥报异常？因为Student未实现Comparable接口*/
 36 
 37         //Student类实现Comparable接口后：
 38         /*ts.add(s1); //ok但不完全ok
 39         ts.add(s2);
 40         ts.add(s3);
 41         ts.add(s4);
 42         ts.add(s5);
 43         //lisi,22
 44         //为啥ts只存储了第一个元素呢？
 45         //因为Student类未重写Comparable接口的compareTo()
 46         //而compareTo()默认return0,意思是比较相等元素重复
 47         //所以只添加了第一个元素，后边的都认为与第一个相同*/
 48 
 49         //Student类重写compareTo()后：
 50         ts.add(s1); //ok
 51         ts.add(s2);
 52         ts.add(s3);
 53         ts.add(s4);
 54         ts.add(s5);
 55 
 56         /*
 57         return 1; //升序
 58         lisi,22
 59         wang,25
 60         sun,23
 61         sun,23
 62          */
 63 
 64         /*
 65         return -1; //降序
 66         sun,23
 67         sun,23
 68         wang,25
 69         lisi,22
 70          */
 71 
 72         /*
 73         自定义：按照年龄升序
 74         lisi,22
 75         sun,23
 76         wang,25
 77          */
 78 
 79         //注意，s4年龄同s3年龄，返回0，故s4未存入
 80 
 81         /*
 82         自定义：按照年龄降序
 83         wang,25
 84         sun,23
 85         lisi,22
 86          */
 87 
 88         /*
 89         自定义：先年龄升序，年龄相同时按照姓名的字母顺序排序
 90         lisi,22
 91         amy,23
 92         sun,23
 93         wang,25
 94          */
 95 
 96         for(Student s: ts){
 97             System.out.println(s.getName() + "," + s.getAge());
 98         }
 99     }
100 }

 1 package day6.lesson2;
 2 
 3 public class Student implements Comparable<Student>{
 4 
 5     private String name;
 6     private int age;
 7 
 8     public Student() {
 9     }
10 
11     public Student(String name, int age) {
12         this.name = name;
13         this.age = age;
14     }
15 
16     public void setName(String name) {
17         this.name = name;
18     }
19 
20     public void setAge(int age) {
21         this.age = age;
22     }
23 
24     public String getName() {
25         return name;
26     }
27 
28     public int getAge() {
29         return age;
30     }
31 
32     @Override
33     public int compareTo(Student s) {
34 //        return 0; //默认 (说明比较相等，则元素重复)
35 
36         //重写
37 //        return 1; //升序
38 //        return -1; //降序
39 
40         //自定义：按照年龄升序
41         /*int num = this.age - s.age; //this-->s2  s-->s1
42         return num;*/
43 
44         //自定义：按照年龄降序
45         /*int num = s.age - this.age;
46         return num;*/
47 
48         //自定义：先年龄升序，年龄相同时按照姓名的字母顺序排序
49         int num = this.age - s.age;
50         int num2 = ( num == 0 ? this.name.compareTo(s.name) : num );
51         //String类也实现了Comparable接口，所以其内部已重写compareTo()，可直接调用
52         return num2;
53     }
54 
55 }