黑马程序员——java学习9（毕15-16总结）——TreeSet

1、

 1 package learn;
 2 /*
 3  * |--TreeSet
 4  *             可以对Set集合排序
 5  *             底层数据结构是二叉树
 6  *             保证数据唯一性的依据：compareTo方法return 0；原序return 1；
 7  *
 8  *         TreeSet排序的第一种方式：让元素子集具备比较性。元素需要实现compareTo接口，覆盖compareTo方法
 9  *         也称为元素的自然顺序，默认顺序
10  *
11  *        TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的
12  *                            这是就需要让集合自身具备比较性
13  *                            在集合初始化时就有了比较方式
14  *
15  *
16  * 需求：往TreeSet集合中存储自定义对象学生
17  * 想按照学生的年龄进行排序
18  *
19  * 排序时，主要条件一致，一定要判断次要条件！
20  * */
21 import java.util.Iterator;
22 import java.util.TreeSet;
23
24 import learn.Student;
25
26 public class TreeSetDemo {
27     public static void main(String[] args) {
28         TreeSet ts=new TreeSet();
29         ts.add(new Student("lisi02",22));
30         ts.add(new Student("lisi007",20));
31         ts.add(new Student("lisi09",19));
32         ts.add(new Student("lisi08",19));
33 //        ts.add(new Student("lisi01",40));
34
35
36         Iterator it=ts.iterator();
37         while(it.hasNext())
38         {
39             Student stu=(Student)it.next();
40             System.out.println(stu.getName()+"..."+stu.getAge());
41         }
42     }
43 }
44
45 class Student implements Comparable//该接口强制让学生具备比较性
46 {
47     private String name;
48     private int age;
49     Student(String name,int age)
50     {
51         this.name=name;
52         this.age=age;
53     }
54     public int compareTo(Object obj)
55     {
56         if(!(obj instanceof Student))
57             throw new RuntimeException("不是学生对象");
58         Student s =(Student)obj;
59         if(this.age>s.age)
60             return 1;
61         if(this.age==s.age)
62             return this.name.compareTo(s.name);
63         return -1;
64     }
65     public String getName()
66     {
67         return name;
68     }
69     public int getAge()
70     {
71         return age;
72     }
73 }

2、

 1 package learn2;
 2 /*
 3  * 当元素自身不具备比较性，或者具备的比较性不是所需要的
 4  * 这时需要让容器自身具备比较性
 5  * 定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
 6  * 当两种排序都存在时，以比较器为主
 7  *
 8  * 定义了一个类，实现Comparator接口，覆盖compare方法
 9  * */
10 import java.util.Comparator;
11 import java.util.Iterator;
12 import java.util.TreeSet;
13
14 class Student implements Comparable//该接口强制让学生具备比较性
15 {
16     private String name;
17     private int age;
18     Student(String name,int age)
19     {
20         this.name=name;
21         this.age=age;
22     }
23     public int compareTo(Object obj)
24     {
25         if(!(obj instanceof Student))
26             throw new RuntimeException("不是学生对象");
27         Student s =(Student)obj;
28         if(this.age>s.age)
29             return 1;
30         if(this.age==s.age)
31             return this.name.compareTo(s.name);
32         return -1;
33     }
34     public String getName()
35     {
36         return name;
37     }
38     public int getAge()
39     {
40         return age;
41     }
42 }
43 public class TreeSetDemo2 {
44     public static void main(String[] args) {
45         TreeSet ts=new TreeSet(new MyCompare());
46         ts.add(new Student("lisi02",22));
47         ts.add(new Student("lisi007",20));
48         ts.add(new Student("lisi09",19));
49         ts.add(new Student("lisi06",19));
50 //        ts.add(new Student("lisi01",40));
51
52
53         Iterator it=ts.iterator();
54         while(it.hasNext())
55         {
56             Student stu=(Student)it.next();
57             System.out.println(stu.getName()+"..."+stu.getAge());
58         }
59     }
60 }
61
62 class MyCompare implements Comparator
63 {
64     public int  compare(Object o1,Object o2)
65     {
66         Student s1=(Student)o1;
67         Student s2=(Student)o2;
68
69         int num=s1.getName().compareTo(s2.getName());
70         if(num==0)
71         {
72             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
73             /*
74             if(s1.getAge()>s2.getAge())
75                 return 1;
76             if(s1.getAge()==s2.getAge())
77                 return 0;
78                 */
79         }
80         return num;
81
82     }
83 }

3、

 1 package Test;
 2
 3 import java.util.Comparator;
 4 import java.util.Iterator;
 5 import java.util.TreeSet;
 6
 7 /*
 8  * 练习，按照字符串长度排序
 9  * 字符串本身具备比较性，但是比较方式不是所需要的
10  * */
11 public class TreeSetTest {
12     public static void main(String[] args) {
13         TreeSet ts=new TreeSet(new StrLengthComparator());
14         ts.add("abcd");
15         ts.add("cc");
16         ts.add("cba");
17         ts.add("aaa");
18         ts.add("z");
19         ts.add("hahaha");
20
21         Iterator it=ts.iterator();
22         while(it.hasNext())
23         {
24             System.out.println(it.next());
25         }
26     }
27 }
28
29 class StrLengthComparator implements Comparator
30 {
31     public int compare(Object o1,Object o2)
32     {
33         String s1=(String)o1;
34         String s2=(String)o2;
35 //        if(s1.length()>s2.length())
36 //            return 1;
37 //        if(s1.length()==s2.length())
38 //            return 0;
39         int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
40         if(num==0)
41             return s1.compareTo(s2);
42         return num;
43     }
44 }

4、