【JAVA集合框架之Set】

一、Set概述。

Set集合的特点是元素不允许重复，而且是无序的（添加和取出的顺序不一致）。

Set接口中的方法和Collection接口中的方法几乎相同，略。

Set接口下常用的两个类：HashSet、TreeSet。

二、HashSet类。

1、概述。

HashSet内部的数据结构是哈希表，而且是不同步的。

如果添加了重复元素，则重复的元素不会被添加，只保留第一次的对象。

HashSet的底层实现是怎么样的？

2.底层实现。

HashSet底层的数据结构是哈希表，什么是哈希表？哈希表根据对象的不同特点将对象放在内存中的不同地方，根据的是一个算法，类似这样的结构：

1 function (element)
2 {
3     //一个算法，对元素进行计算，并获取其位置。
4     return index;
5 }

因此，如果想要查找这个对象，只需要通过此算法再算一次，即可找到该对象，这就使得通过哈希表查找元素的速度非常快，而不需要从头遍历。

注意，每个对象都有哈希值，不同的对象拥有不同的哈希值。

3.哈希表是怎么判断相同元素的？

（1）哈希表确定元素是否相同第一步判断的是两个元素的哈希值是否相同。如果相同再判断两个对象的内容是否相同。
（2）判断哈希值是否相同其实判断的就是hashCode方法。判断内容是否相同，使用equals方法（自定义对象的时候两个方法均要重写）。
注意：如果哈希值不同，则不需要判断equals方法。

4.当哈希值相同，而内容不同的时候，该怎么将对象存储？

通过顺延、挂上新链等方式。

5.示例代码：

使用HashSet存储自定义对象。

初始代码：

 1 package p01.BaseCollectionDemo;
 2 
 3 import java.util.HashSet;
 4 
 5 class Person
 6 {
 7     private String name;
 8     private int age;
 9     public String getName() {
10         return name;
11     }
12     public Person(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17     public Person() {
18         super();
19     }
20     public void setName(String name) {
21         this.name = name;
22     }
23     public int getAge() {
24         return age;
25     }
26     public void setAge(int age) {
27         this.age = age;
28     }
29     @Override
30     public String toString() {
31         return "Person [name=" + name + ", age=" + age + "]
";
32     }
33 }
34 
35 public class HashSetDemo {
36 
37     public static void main(String[] args) {
38         Demo1();
39 
40     }
41 
42     private static void Demo1() {
43         HashSet hs=new HashSet();
44         hs.add(new Person("张三",13));
45         hs.add(new Person("李四",14));
46         hs.add(new Person("王五",15));
47         hs.add(new Person("赵六",16));
48         hs.add(new Person("陈七",17));
49         
50         hs.add(new Person("张三",13));
51         hs.add(new Person("李四",14));
52         System.out.println(hs);
53     }
54 
55 }

View Code

运行结果：

可以看出，张三、李四添加了两次，这和Set集合不允许添加重复元素相违背。

分析：每次调用add方法都需要和已有的对象做比较，先比较哈希值是否同，如果相同再比较内容是否相同，两个比较是通过hashCode方法、equals方法实现的，但是我们没有重写这两个方法，所以调用了默认的方法，即在Object类中继承而来的方法，hashCode方法是将内存地址转换成整数得到的哈希吗，而equals比较的是对象第至是否相同。因为创建的对象在内存中地址不可能相同，所以HashSet认为是不同的对象。

解决方法：重写hashCode方法和equals方法(这里由于使用了代码补全的功能，所以包括健壮性的判断等做的都很好，可以自定义做出自己的风格)。

 1 package p01.BaseCollectionDemo;
 2 
 3 import java.util.HashSet;
 4 
 5 class Person
 6 {
 7     private String name;
 8     private int age;
 9     @Override
10     public int hashCode() {
11         final int prime = 31;
12         int result = 1;
13         result = prime * result + age;
14         result = prime * result + ((name == null) ? 0 : name.hashCode());
15         return result;
16     }
17     @Override
18     public boolean equals(Object obj) {
19         if (this == obj)
20             return true;
21         if (obj == null)
22             return false;
23         if (getClass() != obj.getClass())
24             return false;
25         Person other = (Person) obj;
26         if (age != other.age)
27             return false;
28         if (name == null) {
29             if (other.name != null)
30                 return false;
31         } else if (!name.equals(other.name))
32             return false;
33         return true;
34     }
35     public String getName() {
36         return name;
37     }
38     public Person(String name, int age) {
39         super();
40         this.name = name;
41         this.age = age;
42     }
43     public Person() {
44         super();
45     }
46     public void setName(String name) {
47         this.name = name;
48     }
49     public int getAge() {
50         return age;
51     }
52     public void setAge(int age) {
53         this.age = age;
54     }
55     @Override
56     public String toString() {
57         return "Person [name=" + name + ", age=" + age + "]
";
58     }
59 }
60 
61 public class HashSetDemo {
62 
63     public static void main(String[] args) {
64         Demo1();
65 
66     }
67 
68     private static void Demo1() {
69         HashSet hs=new HashSet();
70         hs.add(new Person("张三",13));
71         hs.add(new Person("李四",14));
72         hs.add(new Person("王五",15));
73         hs.add(new Person("赵六",16));
74         hs.add(new Person("陈七",17));
75         
76         hs.add(new Person("张三",13));
77         hs.add(new Person("李四",14));
78         System.out.println(hs);
79     }
80 
81 }

View Code

6.思考题：去除重复元素（自定义对象）。

代码一：

 1 package p01.BaseCollectionDemo;
 2 import java.util.ArrayList;
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 class Person
 6 {
 7     private String name;
 8     private int age;
 9     public String getName() {
10         return name;
11     }
12     public Person(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17     public Person() {
18         super();
19     }
20     public void setName(String name) {
21         this.name = name;
22     }
23     public int getAge() {
24         return age;
25     }
26     public void setAge(int age) {
27         this.age = age;
28     }
29     @Override
30     public String toString() {
31         return "Person [name=" + name + ", age=" + age + "]
";
32     }
33 }
34 
35 public class HashSetDemo {
36 
37     public static void main(String[] args) {
38         Demo1();
39     }
40 
41     private static void Demo1() {
42         ArrayList hs=new ArrayList();
43         hs.add(new Person("张三",13));
44         hs.add(new Person("李四",14));
45         hs.add(new Person("王五",15));
46         hs.add(new Person("赵六",16));
47         hs.add(new Person("陈七",17));
48         
49         hs.add(new Person("张三",13));
50         hs.add(new Person("李四",14));
51         System.out.println(hs);
52         ArrayList la=removeCF(hs);
53         System.out.println(la);
54     }
55 
56     private static ArrayList removeCF(ArrayList hs) {
57         ArrayList la=new ArrayList();
58         for(Iterator it=hs.iterator();it.hasNext();)
59         {
60             Person p=(Person)it.next();
61             if(!la.contains(p))
62             {
63                 la.add(p);
64             }
65         }
66         return la;
67     }
68 
69     
70 }

View Code

运行结果：

经过比较，发现去除重复元素失败。

原因分析：问题代码肯定出现在

1 if(!la.contains(p))

这里，也就是说contains方法的实现有问题。

查找API，API的描述如下：

如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

所以我们知道了ArrayList 中的contain是方法底层使用的是equals方法，但是我们并没有重写equals方法，这就使得调用了继承自Object类的equals方法，比较的是对象的地址。所以肯定不相同。

解决方法：重写equals方法。

 1 package p01.BaseCollectionDemo;
 2 import java.util.ArrayList;
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 class Person
 6 {
 7     private String name;
 8     private int age;
 9     public String getName() {
10         return name;
11     }
12     @Override
13     public boolean equals(Object obj) {
14         if (this == obj)
15             return true;
16         if (obj == null)
17             return false;
18         if (getClass() != obj.getClass())
19             return false;
20         Person other = (Person) obj;
21         if (age != other.age)
22             return false;
23         if (name == null) {
24             if (other.name != null)
25                 return false;
26         } else if (!name.equals(other.name))
27             return false;
28         return true;
29     }
30     public Person(String name, int age) {
31         super();
32         this.name = name;
33         this.age = age;
34     }
35     public Person() {
36         super();
37     }
38     public void setName(String name) {
39         this.name = name;
40     }
41     public int getAge() {
42         return age;
43     }
44     public void setAge(int age) {
45         this.age = age;
46     }
47     @Override
48     public String toString() {
49         return "Person [name=" + name + ", age=" + age + "]
";
50     }
51 }
52 
53 public class HashSetDemo {
54 
55     public static void main(String[] args) {
56         Demo1();
57     }
58 
59     private static void Demo1() {
60         ArrayList hs=new ArrayList();
61         hs.add(new Person("张三",13));
62         hs.add(new Person("李四",14));
63         hs.add(new Person("王五",15));
64         hs.add(new Person("赵六",16));
65         hs.add(new Person("陈七",17));
66         
67         hs.add(new Person("张三",13));
68         hs.add(new Person("李四",14));
69         System.out.println(hs);
70         ArrayList la=removeCF(hs);
71         System.out.println(la);
72     }
73 
74     private static ArrayList removeCF(ArrayList hs) {
75         ArrayList la=new ArrayList();
76         for(Iterator it=hs.iterator();it.hasNext();)
77         {
78             Person p=(Person)it.next();
79             if(!la.contains(p))
80             {
81                 la.add(p);
82             }
83         }
84         return la;
85     }
86 
87     
88 }

View Code

运行结果。

假设我们将ArrayList换成HashSet，将以上的过程走一遍，结果又如何？结果是两次都失败！原因还在contains方法上。

contains方法的底层实现是

 1  final Entry<K,V> getEntry(Object key) {
 2         int hash = (key == null) ? 0 : hash(key);
 3         for (Entry<K,V> e = table[indexFor(hash, table.length)];
 4              e != null;
 5              e = e.next) {
 6             Object k;
 7             if (e.hash == hash &&
 8                 ((k = e.key) == key || (key != null && key.equals(k))))
 9                 return e;
10         }
11         return null;
12     }

通过这段代码我们可以发现其中一句非常关键：

1 if (e.hash == hash &&
2  8                 ((k = e.key) == key || (key != null && key.equals(k))))
3  9                 return e;

它将不仅使用equals比较对象内容，而且还比较两个对象的哈希值是否相同。即e.hash==hash这一句。所以，还必须重写hashCode方法才行。

 1 package p01.BaseCollectionDemo;
 2 import java.util.HashSet;
 3 import java.util.Iterator;
 4 class Person 
 5 {
 6     private String name;
 7     private int age;
 8     public String getName() {
 9         return name;
10     }
11     
12     @Override
13     public int hashCode() {
14         final int prime = 31;
15         int result = 1;
16         result = prime * result + age;
17         result = prime * result + ((name == null) ? 0 : name.hashCode());
18         return result;
19     }
20 
21     @Override
22     public boolean equals(Object obj) {
23         if (this == obj)
24             return true;
25         if (obj == null)
26             return false;
27         if (getClass() != obj.getClass())
28             return false;
29         Person other = (Person) obj;
30         if (age != other.age)
31             return false;
32         if (name == null) {
33             if (other.name != null)
34                 return false;
35         } else if (!name.equals(other.name))
36             return false;
37         return true;
38     }
39 
40     public Person(String name, int age) {
41         super();
42         this.name = name;
43         this.age = age;
44     }
45     public Person() {
46         super();
47     }
48     public void setName(String name) {
49         this.name = name;
50     }
51     public int getAge() {
52         return age;
53     }
54     public void setAge(int age) {
55         this.age = age;
56     }
57     @Override
58     public String toString() {
59         return "Person [name=" + name + ", age=" + age + "]
";
60     }
61 }
62 
63 public class HashSetDemo {
64 
65     public static void main(String[] args) {
66         Demo1();
67     }
68 
69     private static void Demo1() {
70         HashSet hs=new HashSet();
71         hs.add(new Person("张三",13));
72         hs.add(new Person("李四",14));
73         hs.add(new Person("王五",15));
74         hs.add(new Person("赵六",16));
75         hs.add(new Person("陈七",17));
76         
77         hs.add(new Person("张三",13));
78         hs.add(new Person("李四",14));
79         System.out.println(hs);
80         HashSet la=removeCF(hs);
81         System.out.println(la);
82     }
83 
84     private static HashSet removeCF(HashSet hs) {
85         HashSet la=new HashSet();
86         for(Iterator it=hs.iterator();it.hasNext();)
87         {
88             Person p=(Person)it.next();
89             if(!la.contains(p))
90             {
91                 la.add(p);
92             }
93         }
94         return la;
95     }
96 
97     
98 }

View Code

运行结果是，重写hashCode方法之后，第一次的添加就已经将重复元素去掉了，这体现了JAVA高度的安全机制。

结论：不同的容器虽然有相同的方法，但是底层实现却不相同。例如，ArrayList的contains方法只需要使用equals方法比较内容是否相同就可以了；但是HashSet的contains方法却需要比较哈希的值同时使用equals方法比较对象的内容，而后面讲到的TreeSet判断元素是否存在的依据就是使用方法compareTo；这种不同是容器底层不同的数据结构导致的。remove方法同理。

三、HashSet子类：LinkedHashSet类。

HashSet类是属于Set旗下的类，这就导致了对象的唯一性和有序性不能共存，但是其子类LinkedHashSet弥补了这一缺点，他拥有HashSet的所有特性，同时它又保证了元素的有序。

API1.6的描述：LinkedHashSet：具有可预知迭代顺序的哈希表和链表实现。

改动前面的代码：将HashSet改为LinkedHashSet即可。

  1 package p01.BaseCollectionDemo;
  2 
  3 
  4 import java.util.LinkedHashSet;
  5 import java.util.Iterator;
  6 class Person1 
  7 {
  8     private String name;
  9     private int age;
 10     public String getName() {
 11         return name;
 12     }
 13     
 14     @Override
 15     public int hashCode() {
 16         final int prime = 31;
 17         int result = 1;
 18         result = prime * result + age;
 19         result = prime * result + ((name == null) ? 0 : name.hashCode());
 20         return result;
 21     }
 22 
 23     @Override
 24     public boolean equals(Object obj) {
 25         if (this == obj)
 26             return true;
 27         if (obj == null)
 28             return false;
 29         if (getClass() != obj.getClass())
 30             return false;
 31         Person1 other = (Person1) obj;
 32         if (age != other.age)
 33             return false;
 34         if (name == null) {
 35             if (other.name != null)
 36                 return false;
 37         } else if (!name.equals(other.name))
 38             return false;
 39         return true;
 40     }
 41 
 42     public Person1(String name, int age) {
 43         super();
 44         this.name = name;
 45         this.age = age;
 46     }
 47     public Person1() {
 48         super();
 49     }
 50     public void setName(String name) {
 51         this.name = name;
 52     }
 53     public int getAge() {
 54         return age;
 55     }
 56     public void setAge(int age) {
 57         this.age = age;
 58     }
 59     @Override
 60     public String toString() {
 61         return "Person1 [name=" + name + ", age=" + age + "]
";
 62     }
 63 }
 64 public class LinkedHashSetDemo 
 65 {
 66 
 67     public static void main(String[] args) {
 68         Demo1();
 69     }
 70 
 71     private static void Demo1() {
 72         LinkedHashSet hs=new LinkedHashSet();
 73         hs.add(new Person1("张三",13));
 74         hs.add(new Person1("李四",14));
 75         hs.add(new Person1("王五",15));
 76         hs.add(new Person1("赵六",16));
 77         hs.add(new Person1("陈七",17));
 78         
 79         hs.add(new Person1("张三",13));
 80         hs.add(new Person1("李四",14));
 81         System.out.println(hs);
 82         LinkedHashSet la=removeCF(hs);
 83         System.out.println(la);
 84     }
 85 
 86     private static LinkedHashSet removeCF(LinkedHashSet hs) {
 87         LinkedHashSet la=new LinkedHashSet();
 88         for(Iterator it=hs.iterator();it.hasNext();)
 89         {
 90             Person1 p=(Person1)it.next();
 91             if(!la.contains(p))
 92             {
 93                 la.add(p);
 94             }
 95         }
 96         return la;
 97     }
 98 
 99     
100 }

View Code

也就是说如果我们想让元素唯一，同时又想让元素有序，则使用LinkedHashSet类。

四、TreeSet类。

TreeSet类中的方法和其父类基本相同，不再赘述，但是应当掌握其底层实现。

1.引例。

向容器中添加字符串对象，并输出，观察结果。

 1 package p03.TreeSetDemo;
 2 
 3 import java.util.TreeSet;
 4 
 5 public class TreeSetDemo {
 6 
 7     public static void main(String[] args) {
 8         Demo1();
 9 
10     }
11 
12     private static void Demo1() {
13         TreeSet ts=new TreeSet();
14         ts.add("abc1");
15         ts.add("abc3");
16         ts.add("abc4");
17         ts.add("abc2");
18         System.out.println(ts);
19     }
20 
21 }

View Code

运行结果：[abc1, abc2, abc3, abc4]

观察结果我们可以发现，虽然并不是“有序”的，但是结果却有一些规律，重复添加其它对象，也可以观察到类似的结果。

原因：TreeSet底层的数据结构是一棵排序树，在添加元素的时候其位置就已经被决定了。

这个示例没有问题，现在添加自定义对象。

 1 package p03.TreeSetDemo;
 2 
 3 import java.util.TreeSet;
 4 
 5 class Person
 6 {
 7     private String name;
 8     private int age;
 9     public Person() {
10         super();
11     }
12     public Person(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17     public String getName() {
18         return name;
19     }
20     public void setName(String name) {
21         this.name = name;
22     }
23     public int getAge() {
24         return age;
25     }
26     public void setAge(int age) {
27         this.age = age;
28     }
29 }
30 public class TreeSetDemo {
31 
32     public static void main(String[] args) {
33         //Demo1();
34         Demo2();
35     }
36 
37     private static void Demo2() {
38         TreeSet ts=new TreeSet();
39         ts.add(new Person("zhangsan",13));
40         ts.add(new Person("chenqi",17));
41         ts.add(new Person("wangwu",15));
42         ts.add(new Person("lisi",14));
43         ts.add(new Person("zhaoliu",16));
44         
45         System.out.println(ts);
46     }
47 
48     private static void Demo1() {
49         TreeSet ts=new TreeSet();
50         ts.add("abc1");
51         ts.add("abc3");
52         ts.add("abc4");
53         ts.add("abc2");
54         System.out.println(ts);
55     }
56 
57 }

View Code

运行时，出现了异常信息：

根据错误信息，我们可以知道错误发生在第39行，重复操作数次，仍然失败，证明了程序有了问题，但是我们的思路和之前完全相同，应当是没有什么问题。

查找API，查看TreeSet的add方法，发现了和上图相同的异常：ClassCastExceptin。

API描述：ClassCastException - 如果指定对象无法与此 set 的当前元素进行比较。

也就是说Person类的对象没有比较性导致的异常。怎样让对象具有比较性？

2.使对象具有可比性：使用Comparable接口。

Comparable接口的完整包名为：java.lang.Comparable。

这个接口中只封装了一个方法：compareTo方法。

API描述：

int compareTo(T o)
比较此对象与指定对象的顺序。

该方法功能：比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

更改之前的代码，使得Person类具有可比性，这里是以年龄为参照，并按照年龄大小升序排列。

 1 package p03.TreeSetDemo;
 2 
 3 import java.util.TreeSet;
 4 
 5 class Person implements Comparable
 6 {
 7     private String name;
 8     private int age;
 9     public Person() {
10         super();
11     }
12     public Person(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17     public String getName() {
18         return name;
19     }
20     public void setName(String name) {
21         this.name = name;
22     }
23     public int getAge() {
24         return age;
25     }
26     public void setAge(int age) {
27         this.age = age;
28     }
29     @Override
30     public int compareTo(Object o) {
31         Person p=(Person)o;
32         if(this.age>p.age)
33         {
34             return 1;
35         }
36         else if(this.age<p.age)
37         {
38             return -1;
39         }
40         else
41         {
42             return 0;
43         }
44     }
45     @Override
46     public String toString() {
47         return "Person [name=" + name + ", age=" + age + "]"+"
";
48     }
49     
50 }
51 public class TreeSetDemo {
52 
53     public static void main(String[] args) {
54         //Demo1();
55         Demo2();
56     }
57 
58     private static void Demo2() {
59         TreeSet<Person> ts=new TreeSet();
60         ts.add(new Person("zhangsan",13));
61         ts.add(new Person("chenqi",17));
62         ts.add(new Person("wangwu",15));
63         ts.add(new Person("lisi",14));
64         ts.add(new Person("zhaoliu",16));
65         
66         System.out.println(ts);
67     }
68 
69     private static void Demo1() {
70         TreeSet ts=new TreeSet();
71         ts.add("abc1");
72         ts.add("abc3");
73         ts.add("abc4");
74         ts.add("abc2");
75         System.out.println(ts);
76     }
77 
78 }

View Code

运行结果：

从结果中我们可以看出年龄确实是按照从小到大排序了。

思考：如果我们又想要按照名字排序，该怎么做？只需要更改compareTo方法即可，但是反复的更改程序并不是治本的方法。解决方法是使用比较器。

3.使集合具有比较功能：使用Comparator接口。

Comparator的完整包名为：java.util.Comparator。

实现Comparator接口的对象称为比较器。它封装了两个方法：

方法摘要
`int`	`compare(T o1, T o2)` 比较用来排序的两个参数。
`boolean`	`equals(Object obj)` 指示某个其他对象是否“等于”此 Comparator。

我们最常使用的就是compare方法了。

API对于compare方法的描述：比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

我们知道TreeSet在使用add方法的时候就已经具有比较功能了，所以它在构造的时候就必须拥有比较器（本来应当有set方法，但是很遗憾API中并没有提及），即构造方法中必定有一个方法参数是比较器。

TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序。

改造之前的代码，使其按照名字的字典序排序。

  1 package p03.TreeSetDemo;
  2 
  3 import java.util.Comparator;
  4 import java.util.TreeSet;
  5 class NewComparator implements Comparator
  6 {
  7 
  8     @Override
  9     public int compare(Object o1, Object o2) {
 10         Person p1=(Person)o1;
 11         Person p2=(Person)o2;
 12         int temp=p1.getName().compareTo(p2.getName());
 13         return temp==0?(p1.getAge()-p2.getAge()):temp;//按照字典序将名字排序，如果名字相同，则
 14         //按照年龄大小从小到大排序。
 15     }
 16 }
 17 class Person implements Comparable
 18 {
 19     private String name;
 20     private int age;
 21     public Person() {
 22         super();
 23     }
 24     public Person(String name, int age) {
 25         super();
 26         this.name = name;
 27         this.age = age;
 28     }
 29     public String getName() {
 30         return name;
 31     }
 32     public void setName(String name) {
 33         this.name = name;
 34     }
 35     public int getAge() {
 36         return age;
 37     }
 38     public void setAge(int age) {
 39         this.age = age;
 40     }
 41     @Override
 42     public int compareTo(Object o) {
 43         Person p=(Person)o;
 44         if(this.age>p.age)
 45         {
 46             return 1;
 47         }
 48         else if(this.age<p.age)
 49         {
 50             return -1;
 51         }
 52         else
 53         {
 54             return 0;
 55         }
 56     }
 57     @Override
 58     public String toString() {
 59         return "Person [name=" + name + ", age=" + age + "]"+"
";
 60     }
 61     
 62 }
 63 public class TreeSetDemo {
 64 
 65     public static void main(String[] args) {
 66         //Demo1();
 67         //Demo2();
 68         Demo3();
 69     }
 70 
 71     private static void Demo3() {
 72         TreeSet ts=new TreeSet(new NewComparator());
 73         ts.add(new Person("zhangsan",13));
 74         ts.add(new Person("chenqi",17));
 75         ts.add(new Person("wangwu",15));
 76         ts.add(new Person("lisi",14));
 77         ts.add(new Person("zhaoliu",16));
 78         
 79         ts.add(new Person("zhangsan",11));//加入了名字相同但是年龄不同的对象
 80         
 81         System.out.println(ts);
 82     }
 83 
 84     private static void Demo2() {
 85         TreeSet<Person> ts=new TreeSet();
 86         ts.add(new Person("zhangsan",13));
 87         ts.add(new Person("chenqi",17));
 88         ts.add(new Person("wangwu",15));
 89         ts.add(new Person("lisi",14));
 90         ts.add(new Person("zhaoliu",16));
 91         
 92         System.out.println(ts);
 93     }
 94 
 95     private static void Demo1() {
 96         TreeSet ts=new TreeSet();
 97         ts.add("abc1");
 98         ts.add("abc3");
 99         ts.add("abc4");
100         ts.add("abc2");
101         System.out.println(ts);
102     }
103 
104 }

View Code

运行结果：

观察结果，和预期结果相同。

4.比较两种比较方法

实现Comparable接口的对象具有比较的功能，这种使对象具有比较性的方法为自然比较方法。实现这个接口的类有很多，比如之前使用的字符串类，使用它作为TreeSet容器的元素的时候没有报错正是因为String类实现了Comparable接口。所有的基本数据类型包装类都实现了此接口。除此之外还有很多类都实现了此接口，因为只要对象想要具备比较性，就需要此接口，此接口中的compareTo方法正是用于比较对象的。简单来说，该方法的功能就是让对象本身具备比较性。

实现Comparator接口的类称为比较器，如果对象具备了自然比较的属性，同时集合又拥有了比较器，则优先使用比较器。即对象的自然比较属性将会无效。简单来说，该方法的功能呢就是让集合具备比较性。

应当注意：compareTo方法中的this指的是当前对象，即正在插入的对象；而compare方法的第一个参数是当前对象，即正在插入的对象。

5.如何使得TreeSet有序？

所谓有序，即怎么添加的就怎么取出来，添加和取出的顺序相同。

假设此时对象已经拥有了比较性，则这时候只能使用Comparator接口。

思路：让当前的对象永远大于当前集合中的所有对象即可。即让compare方法返回1；

  1 package p03.TreeSetDemo;
  2 
  3 import java.util.Comparator;
  4 import java.util.TreeSet;
  5 class NewComparator implements Comparator
  6 {
  7 
  8     @Override
  9     public int compare(Object o1, Object o2) {
 10 //        Person p1=(Person)o1;
 11 //        Person p2=(Person)o2;
 12 //        int temp=p1.getName().compareTo(p2.getName());
 13 //        return temp==0?(p1.getAge()-p2.getAge()):temp;//按照字典序将名字排序，如果名字相同，则
 14         //按照年龄大小从小到大排序。
 15         return 1;
 16     }
 17 }
 18 class Person implements Comparable
 19 {
 20     private String name;
 21     private int age;
 22     public Person() {
 23         super();
 24     }
 25     public Person(String name, int age) {
 26         super();
 27         this.name = name;
 28         this.age = age;
 29     }
 30     public String getName() {
 31         return name;
 32     }
 33     public void setName(String name) {
 34         this.name = name;
 35     }
 36     public int getAge() {
 37         return age;
 38     }
 39     public void setAge(int age) {
 40         this.age = age;
 41     }
 42     @Override
 43     public int compareTo(Object o) {
 44         Person p=(Person)o;
 45         if(this.age>p.age)
 46         {
 47             return 1;
 48         }
 49         else if(this.age<p.age)
 50         {
 51             return -1;
 52         }
 53         else
 54         {
 55             return 0;
 56         }
 57     }
 58     @Override
 59     public String toString() {
 60         return "Person [name=" + name + ", age=" + age + "]"+"
";
 61     }
 62     
 63 }
 64 public class TreeSetDemo {
 65 
 66     public static void main(String[] args) {
 67         //Demo1();
 68         //Demo2();
 69         Demo3();
 70     }
 71 
 72     private static void Demo3() {
 73         TreeSet ts=new TreeSet(new NewComparator());
 74         ts.add(new Person("zhangsan",13));
 75         ts.add(new Person("chenqi",17));
 76         ts.add(new Person("wangwu",15));
 77         ts.add(new Person("lisi",14));
 78         ts.add(new Person("zhaoliu",16));
 79         
 80         ts.add(new Person("zhangsan",11));//加入了名字相同但是年龄不同的对象
 81         
 82         System.out.println(ts);
 83     }
 84 
 85     private static void Demo2() {
 86         TreeSet<Person> ts=new TreeSet();
 87         ts.add(new Person("zhangsan",13));
 88         ts.add(new Person("chenqi",17));
 89         ts.add(new Person("wangwu",15));
 90         ts.add(new Person("lisi",14));
 91         ts.add(new Person("zhaoliu",16));
 92         
 93         System.out.println(ts);
 94     }
 95 
 96     private static void Demo1() {
 97         TreeSet ts=new TreeSet();
 98         ts.add("abc1");
 99         ts.add("abc3");
100         ts.add("abc4");
101         ts.add("abc2");
102         System.out.println(ts);
103     }
104 
105 }

View Code