1. package com.kxg.set;
   
2. 
   
3. import java.util.TreeSet;
   
4. 
   
5. /*
   
6. * TreeSet:能够对元素按照某种规则进行排序。
   
7. * 特点：
   
8. *                 排序和唯一
   
9. * 排序的两种方式：
   
10. *                 自然排序
    
11. *                         实现Comparable接口中的compareTo()方法
    
12. *                 比较器排序
    
13. *                         实现Comparator接口中的Comparator()方法
    
14. *
    
15. */
    
16. public class TreeSetDemo {
    
17.         public static void main(String[] args) {
    
18. 
    
19.                 // Integer中已经重写了compareTo()方法，可以写成无参构造。
    
20.                 TreeSet<Integer> set = new TreeSet<Integer>();
    
21. 
    
22.                 set.add(25);
    
23.                 set.add(22);
    
24.                 set.add(24);
    
25.                 set.add(25);
    
26.                 set.add(29);
    
27.                 set.add(28);
    
28.                 set.add(25);
    
29.                 set.add(45);
    
30.                 set.add(32);
    
31.                 set.add(89);
    
32.                 set.add(12);
    
33. 
    
34.                 for (Integer i : set) {
    
35.                         System.out.println(i);
    
36.                 }
    
37.         }
    
38. }

复制代码

1. package com.kxg.set;
   
2. 
   
3. import java.util.Comparator;
   
4. import java.util.TreeSet;
   
5. public class TreeSetDemo2 {
   
6.         public static void main(String[] args) {
   
7.                 TreeSet<Student> set = new TreeSet<Student>();
   
8. 
   
9.                 TreeSet<Student> set2 = new TreeSet<>(new Comparator<Student>() {
   
10. 
    
11.                         @Override
    
12.                         public int compare(Student s1, Student s2) {
    
13.                                 // 主要条件：按照名字长度排序,访问不到Student类中的name和age，换用getXxx方法得到。
    
14.                                 int num = s1.getName().length() - s2.getName().length();
    
15.                                 // 次要条件：名字长度相同，不代表名字内容相同
    
16.                                 // 如果名字长度相同，就比较名字内容是否相同
    
17.                                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
    
18.                                                 : num;
    
19.                                 // 名字内容相同，不代表年龄相同
    
20.                                 // 如果名字内容相同，比较对象的年龄是否相同，如果相同就认为是同一个对象，不添加
    
21.                                 int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
    
22.                                 return num3;
    
23.                         }
    
24. 
    
25.                 });
    
26.                 Student s1 = new Student("kangxiaoguang", 23);
    
27.                 Student s2 = new Student("liyanxu", 20);
    
28.                 Student s3 = new Student("renxingya", 23);
    
29.                 Student s4 = new Student("zhaolei", 19);
    
30.                 Student s5 = new Student("wangao", 21);
    
31.                 Student s6 = new Student("kangxiaoguang", 23);
    
32.                 Student s7 = new Student("renxingya", 33);
    
33.                 Student s8 = new Student("liyanxu", 20);
    
34.                 Student s9 = new Student("liyanxu", 22);
    
35. 
    
36.                 set.add(s1);
    
37.                 set.add(s2);
    
38.                 set.add(s3);
    
39.                 set.add(s4);
    
40.                 set.add(s5);
    
41.                 set.add(s6);
    
42.                 set.add(s7);
    
43.                 set.add(s8);
    
44.                 set.add(s9);
    
45. 
    
46.                 set2.add(s1);
    
47.                 set2.add(s2);
    
48.                 set2.add(s3);
    
49.                 set2.add(s4);
    
50.                 set2.add(s5);
    
51.                 set2.add(s6);
    
52.                 set2.add(s7);
    
53.                 set2.add(s8);
    
54.                 set2.add(s9);
    
55. 
    
56.                 for (Student s : set) {
    
57.                         System.out.println(s);
    
58.                 }
    
59.         }
    
60. }

复制代码

摘抄强哥：

        a.自然顺序(Comparable)
                对象实现Comparable接口
                TreeSet类的add()方法中会把存入的对象提升为Comparable类型
                调用对象的compareTo()方法和集合中的对象比较
                根据compareTo()方法返回的结果进行存储

        b.比较器顺序(Comparator)
                创建TreeSet的时候可以制定 一个Comparator
                如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
                add()方法内部会自动调用Comparator接口中compare()方法排序

        c.两种方式的区别
                TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
                TreeSet如果传入Comparator, 就优先按照Comparator

Stuent类：

1. package com.kxg.set;
   
2. 
   
3. public class Student implements Comparable<Student> {
   
4.         private String name;
   
5.         private int age;
   
6. 
   
7.         public Student() {
   
8.                 super();
   
9.         }
   
10. 
    
11.         public Student(String naem, int age) {
    
12.                 super();
    
13.                 this.name = naem;
    
14.                 this.age = age;
    
15.         }
    
16. 
    
17.         public String getName() {
    
18.                 return name;
    
19.         }
    
20. 
    
21.         public void setName(String naem) {
    
22.                 this.name = naem;
    
23.         }
    
24. 
    
25.         public int getAge() {
    
26.                 return age;
    
27.         }
    
28. 
    
29.         public void setAge(int age) {
    
30.                 this.age = age;
    
31.         }
    
32. 
    
33.         @Override
    
34.         public int hashCode() {
    
35.                 final int prime = 31;
    
36.                 int result = 1;
    
37.                 result = prime * result + age;
    
38.                 result = prime * result + ((name == null) ? 0 : name.hashCode());
    
39.                 return result;
    
40.         }
    
41. 
    
42.         @Override
    
43.         public String toString() {
    
44.                 return name + "==" + age;
    
45.         }
    
46. 
    
47.         @Override
    
48.         public boolean equals(Object obj) {
    
49.                 if (this == obj)
    
50.                         return true;
    
51.                 if (obj == null)
    
52.                         return false;
    
53.                 if (getClass() != obj.getClass())
    
54.                         return false;
    
55.                 Student other = (Student) obj;
    
56.                 if (age != other.age)
    
57.                         return false;
    
58.                 if (name == null) {
    
59.                         if (other.name != null)
    
60.                                 return false;
    
61.                 } else if (!name.equals(other.name))
    
62.                         return false;
    
63.                 return true;
    
64.         }
    
65. 
    
66.         @Override
    
67.         public int compareTo(Student s) {
    
68.                 // 主要条件：按照名字长度排序
    
69.                 int num = this.name.length() - s.name.length();
    
70.                 // 次要条件：名字长度相同，不代表名字内容相同
    
71.                 // 如果名字长度相同，就比较名字内容是否相同
    
72.                 int num2 = num == 0 ? this.name.compareTo(s.name) : num;
    
73.                 // 名字内容相同，不代表年龄相同
    
74.                 // 如果名字内容相同，比较对象的年龄是否相同，如果相同就认为是同一个对象，不添加
    
75.                 int num3 = num2 == 0 ? this.age - s.age : num2;
    
76.                 return num3;
    
77.         }
    
78. }

复制代码