Set不保存重复的元素。Set中最常被使用的是测试归属性，你可以很容易的询问某个对象是否在某个Set中。Set具有与Collection完全一样的接口，因此没有任何额外的功能。实际上Set就是Collection，只是行为不同。
实现了Set接口的主要有HashSet、TreeSet、LinkedHashSet这几个共同点就是每个相同的项只保存一份。他们也有不同点，区别如下：
1.HashSet：
HashSet使用的是相当复杂的方式来存储元素的，使用HashSet能够最快的获取集合中的元素，效率非常高（以空间换时间）。会根据 hashcode和equals来庞端是否是同一个对象，如果hashcode一样，并且equals返回true，则是同一个对象，不能重复存放。
1 package com.set;
2
3 import java.util.HashSet;
4 import java.util.Set;
5
6 class Student{
7 int id;
8 public Student(int id) {
9 this.id = id;
10 }
11 @Override
12 public String toString() {
13 return this.id+””;
14 }
15 @Override
16 public int hashCode() {
17 return this.id;
18 }
19 @Override
20 public boolean equals(Object obj) {
21 if (obj instanceof Student){
22 Student stu = (Student) obj;
23 if (stu.id == this.id)
24 return true;
25 }
26 return false;
27 }
28 }
29 public class HashSetTest {
30 public static void main(String[] args) {
31 Set set = new HashSet();
32 Student s1 = new Student(1);
33 Student s2 = new Student(1);
34 Student s3 = new Student(2);
35 set.add(s1);
36 set.add(s2);
37 set.add(s3);
38 for (Student s : set) {
39 System.out.println(s);
40 }
41 }
42 }正如上例所示，重写了hashCode()和equals()方法来区分同意对象后，就不能存放同以对象了。如果注释这两个方法，则所有Student对象视为不同对象，都可以存放。
2.TreeSet
TreeSet也不能存放重复对象，但是TreeSet会自动排序，如果存放的对象不能排序则会报错，所以存放的对象必须指定排序规则。排序规则包括自然排序和客户排序。
①自然排序：TreeSet要添加哪个对象就在哪个对象类上面实现java.lang.Comparable接口，并且重写comparaTo()方法，返回0则表示是同一个对象，否则为不同对象。
②客户排序：建立一个第三方类并实现java.util.Comparator接口。并重写方法。定义集合形式为TreeSet ts = new TreeSet(new 第三方类());
下面一个例子用TreeSet存放自然排序的对象：
1 package com.set;
2
3 import java.util.Set;
4 import java.util.TreeSet;
5
6 class Student1 implements Comparable{
7 int id;
8 public Student1(int id) {
9 this.id = id;
10 }
11 @Override
12 public String toString() {
13 return this.id+””;
14 }
15 @Override
16 public int hashCode() {
17 return this.id;
18 }
19 @Override
20 public boolean equals(Object obj) {
21 if (obj instanceof Student1){
22 Student1 stu = (Student1) obj;
23 if (stu.id == this.id)
24 return true;
25 }
26 return false;
27 }
28 public int compareTo(Student1 o) {
29 return (this.id-o.id);
30 }
31 }
32
33 public class TreeSetTest {
34 public static void main(String[] args) {
35 Set set = new TreeSet();
36 Student1 s1 = new Student1(5);
37 Student1 s2 = new Student1(1);
38 Student1 s3 = new Student1(2);
39 Student1 s4 = new Student1(4);
40 Student1 s5 = new Student1(3);
41 set.add(s1);
42 set.add(s2);
43 set.add(s3);
44 set.add(s4);
45 set.add(s5);
46 for (Student1 s : set) {
47 System.out.println(s);
48 }
49 }
50
51 }输出结果为：
1
2
3
4
5
下面一个例子用TreeSet存放客户排序的对象：
1 package com.set;
2
3 import java.util.Set;
4 import java.util.TreeSet;
5
6 class MySort implements java.util.Comparator{
7
8 public int compare(Student2 o1, Student2 o2) {
9 return o2.id-o1.id;
10 }
11 }
12 class Student2{
13 int id;
14 public Student2(int id) {
15 this.id = id;
16 }
17 @Override
18 public String toString() {
19 return this.id+””;
20 }
21 @Override
22 public int hashCode() {
23 return this.id;
24 }
25 @Override
26 public boolean equals(Object obj) {
27 if (obj instanceof Student2){
28 Student2 stu = (Student2) obj;
29 if (stu.id == this.id)
30 return true;
31 }
32 return false;
33 }
34 }
35 public class TreeSetTest2 {
36 public static void main(String[] args) {
37 Set set = new TreeSet(new MySort());
38 Student2 s1 = new Student2(5);
39 Student2 s2 = new Student2(1);
40 Student2 s3 = new Student2(2);
41 Student2 s4 = new Student2(4);
42 Student2 s5 = new Student2(3);
43 set.add(s1);
44 set.add(s2);
45 set.add(s3);
46 set.add(s4);
47 set.add(s5);
48 for (Student2 s : set) {
49 System.out.println(s);
50 }
51 }
52
53 }输出结果为：
5
4
3
2
1
大家都知道List存放时按照插入顺序排序的，其实也可以用自然排序和客户排序对List集合排序，大家请看：
1 package com.set;
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.List;
6
7 class MySort1 implements java.util.Comparator{
8 public int compare(Student3 o1, Student3 o2) {
9 return o2.id-o1.id;
10 }
11 }
12 class Student3 implements Comparable{
13 int id;
14 public Student3(int id) {
15 this.id = id;
16 }
17 @Override
18 public String toString() {
19 return this.id+””;
20 }
21 public int compareTo(Student3 o) {
22 return (this.id-o.id);
23 }
24 }
25
26 public class ListSort {
27 public static void main(String[] args) {
28 List list = new ArrayList();
29 Student3 s1 = new Student3(5);
30 Student3 s2 = new Student3(1);
31 Student3 s3 = new Student3(2);
32 Student3 s4 = new Student3(4);
33 Student3 s5 = new Student3(3);
34 list.add(s1);
35 list.add(s2);
36 list.add(s3);
37 list.add(s4);
38 list.add(s5);
39 System.out.println(list);
40 //自然排序：
41 Collections.sort(list);
42 System.out.println(list);
43 //客户排序
44 Collections.sort(list, new MySort1());
45 System.out.println(list);
46 }
47 }输出结果为：
[5, 1, 2, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
3.LinkedHashSet
LinkedHashSet按照插入顺序保存对象，同时还保存了HashSet的查询速度。
