TreeSet集合

TreeSet集合的特点：

　　两种排序方式：

　　　　方式一：让集合中的元素自身具有比较性，这就让加入到TreeSet集合中的对象必须实现comparable接口重写compareTo(Object obj)方法

　　　　　　　　这种方式也成为元素的自然排序或默认排序。（但是如果排序的元素不是本人写的，别人写的没有实现comparable接口时想排序使用第二种方式）

　　　　方式二：让集合容器具有比较性，自定义一个比较器实现comparator接口，重写compare(Object o1,Object o2)方法，在初始化TreeSet容器对象将这个

　　　　　　　　自定义的比较器作参数传给容器的构造函数，使得集合容器具有比较性，使用这种方式的优先级高于方式一，

方式一实例：

 1 package com.collection;

 2 

 3 import java.util.Iterator;

 4 import java.util.TreeSet;

 5 

 6 public class TreeSetTest {

 7 

 8     public static void main(String[] args) {

 9         TreeSet<Person> treeSet = new TreeSet<Person>();

10         treeSet.add(new Person("zhangsan", 12));

11         treeSet.add(new Person("zhangsan", 16));

12         treeSet.add(new Person("lisi", 16));

13         treeSet.add(new Person("wangwu", 20));

14         treeSet.add(new Person("ada", 20));

15         Iterator<Person> it = treeSet.iterator();

16         while(it.hasNext()){

17             Person p = it.next();

18             System.out.println(p.toString());

19         }

20     }

21 }

22 

23 //集合元素实现comparable接口 重写compareTo()方法

24 class Person implements Comparable<Person>{

25 

26     private String name;

27     private int age;

28     

29     public Person(String name, int age) {

30         super();

31         this.name = name;

32         this.age = age;

33     }

34     public String getName() {

35         return name;

36     }

37     public void setName(String name) {

38         this.name = name;

39     }

40     public int getAge() {

41         return age;

42     }

43     public void setAge(int age) {

44         this.age = age;

45     }

46     

47     @Override

48     public int compareTo(Person o) {

49         int result = this.name.compareTo(o.getName());

50         if(result == 0){

51             return Integer.valueOf(age).compareTo(new Integer(o.getAge()));

52         }

53         return result;

54     }

55     

56     @Override

57     public String toString() {

58         return this.name+"---"+this.age;

59     }

60     

61 }

View Code

方式二实例：

 1 package com.collection;

 2 

 3 import java.util.Collections;

 4 import java.util.Comparator;

 5 import java.util.Iterator;

 6 import java.util.TreeSet;

 7 

 8 public class TreeSetTest {

 9 

10     public static void main(String[] args) {

11         //用Collections.reverseOrder()将比较结果反排列

12         TreeSet<Person> treeSet = new TreeSet<Person>(Collections.reverseOrder(new MyComparator()));

13         treeSet.add(new Person("zhangsan", 12));

14         treeSet.add(new Person("zhangsan", 16));

15         treeSet.add(new Person("lisi", 16));

16         treeSet.add(new Person("wangwu", 20));

17         treeSet.add(new Person("ada", 20));

18         Iterator<Person> it = treeSet.iterator();

19         while(it.hasNext()){

20             Person p = it.next();

21             System.out.println(p.toString());

22         }

23     }

24 }

25 

26 class MyComparator implements Comparator<Person>{

27 

28     @Override

29     public int compare(Person o1, Person o2) {

30         int result = o1.getName().compareTo(o2.getName());

31         if(result == 0){

32             return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));

33         }

34         return result;

35     }

36     

37 }

38 

39 //集合元素实现comparable接口 重写compareTo()方法

40 class Person implements Comparable<Person>{

41 

42     private String name;

43     private int age;

44     

45     public Person(String name, int age) {

46         super();

47         this.name = name;

48         this.age = age;

49     }

50     public String getName() {

51         return name;

52     }

53     public void setName(String name) {

54         this.name = name;

55     }

56     public int getAge() {

57         return age;

58     }

59     public void setAge(int age) {

60         this.age = age;

61     }

62     

63     @Override

64     public int compareTo(Person o) {

65         int result = this.name.compareTo(o.getName());

66         if(result == 0){

67             return Integer.valueOf(age).compareTo(new Integer(o.getAge()));

68         }

69         return result;

70     }

71     

72     @Override

73     public String toString() {

74         return this.name+"---"+this.age;

75     }

76     

77 }

View Code

　　排序性：加入到TreeSet集合中的对象必须具有比较性，也就是对象事项comparable接口覆盖compareTo(Object obj)方法，

　　　　　　判断集合中元素是否相同的标准就是compareTo()中返回值是不是return 0；

　　　　　　如果只加入一个对象到TreeSet中，无需比 该对象不实现comparable接口也不抱错 但这样就没有意义了

　　底层结构：二叉树，由于TreeSet集合底层结构是二叉树，那么compareTo()中返回值return 1时就会按照插入顺序排序，

　　　　　　相反 return -1，就会按插入的顺序凡序

 1 class MyComparator implements Comparator<Person>{

 2 

 3     @Override

 4     public int compare(Person o1, Person o2) {

 5         

 6         return 1;

 7         //结果

 8         /*zhangsan---12

 9         zhangsan---16

10         lisi---16

11         wangwu---20

12         ada---20*/

13     }

14     

15 }

  　唯一性条件：compareTO() return 0；如果相同，则元素不会被加入到集合中....