集合框架——Set

      Set集合为集类型，集是最简单的一种集合，存放于集中的对象不按特定方式排序，只是简单地把对象加入集合中，类似于向口袋里放东西。对集中存在的对象的访问和操作是通过对象的引用进行的，因此在集中不能存放重复对象。Set集合包括Set接口以及Set接口的所有实现类。因为Set接口继承了Collection接口，所以Set接口拥有Collection接口提供的所有常用方法。

1. 使用HashSet类 
      由HashSet类实现的Set集合的优点是能够快速定位集合中的元素。 
      由HashSet类实现的Set集合中的对象必须是惟一的，因此需要添加到由HashSet类实现的Set集合中的对象，需要重新实现equals()方法，从而保证插入集合中对象的标识的惟一性。 
      由HashSet类实现的Set集合的排列方式为按照哈希码排序，根据对象的哈希码确定对象的存储位置，因此需要添加到由HashSet类实现的Set集合中的对象，还需要重新实现hashCode()方法，从而保证插入集合中的对象能够合理地分布在集合中，以便于快速定位集合中的对象。 
      由于Set集合中的对象是无序的，这里所谓的无序并不是完全无序，只是不像List集合按对象的插入顺序保存对象。
例如：
源文件：Person.java

Java代码

1. public class Person{   
2.     private String name;   
3.     private long id_card;   
4.     public Person(String name,long id_card){   
5.         this.name = name;   
6.         this.id_card = id_card;   
7.     }   
8.     public long getId_card(){   
9.         return id_card;   
10.     }   
11.     public void setId_card(long id_card){   
12.         this.id_card = id_card;   
13.     }   
14.     public String getName(){   
15.         return name;   
16.     }   
17.     public void setName(String name){   
18.         this.name = name;   
19.     }   
20.     public int hashCode(){//重新实现hashCode()方法   
21.         final int PRIME = 31;   
22.         int result = 1;   
23.         result = PRIME*result+(int)(id_card^(id_card>>>32));   
24.         result = PRIME*result+((name ==null)?0:name.hashCode());   
25.         return result;   
26.     }   
27.     public boolean equals(Object obj){//重新实现equals()方法   
28.         if(this == obj){   
29.             return true;   
30.         }   
31.         if(obj == null){   
32.             return false;   
33.         }   
34.         if(getClass()!=obj.getClass()){   
35.             return false;   
36.         }   
37.         final Person other = (Person)obj;   
38.         if(id_card!=other.id_card){   
39.             return false;   
40.         }   
41.         if(name == null){   
42.             if(other.name != null){   
43.                 return false;   
44.             }   
45.         }   
46.         else if(!name.equals(other.name)){   
47.             return false;   
48.         }   
49.         return true;   
50.     }   
51. }  

源文件：TestSet.java

Java代码

1. import java.util.*;   
2. public class TestSet{   
3.     public static void main(String args[]){   
4.         Set<Person> hashSet = new HashSet<Person>();   
5.         hashSet.add(new Person("马先生",22015));   
6.         hashSet.add(new Person("李小姐",22018));   
7.         hashSet.add(new Person("李先生",22020));   
8.         Iterator<Person> it = hashSet.iterator();   
9.         while(it.hasNext()){   
10.             Person person = it.next();   
11.             System.out.println(person.getName()+"   "+person.getId_card());   
12.         }   
13.     }   
14. }  

程序的运行结果如下：
李小姐  22018
李先生  22020
马先生  22015 
      如果既想保留HashSet类快速定位集合中对象的优点，又想让集合中的对象按插入的顺序保存，可以通过HashSet类的子类LinkedHashSet实现Set集合，即修改上述代码如下：
将

Java代码

1. Set<Person> hashSet = new HashSet<Person>();  

修改为：

Java代码

1. Set<Person> hashSet = new LinkedHashSet<Person>();  

2. 使用TreeSet类 
      TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，从而保证在遍历集合时按照递增的顺序获得对象。遍历对象时可能是按照自然顺序递增排列，因此存入用TreeSet类实现的Set集合的对象必须实现Comparable接口；也可能是按照指定比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。 
      TreeSet类通过实现java.util.SortedSet接口增加的方法如下表4所示：

例如：
源文件：Person.java

Java代码

1. public class Person implements Comparable{   
2.     private String name;   
3.     private long id_card;   
4.     public Person(String name,long id_card){   
5.         this.name = name;   
6.         this.id_card = id_card;   
7.     }   
8.     public String getName(){   
9.         return name;   
10.     }   
11.     public void setName(String name){   
12.         this.name = name;   
13.     }   
14.     public long getId_card(){   
15.         return id_card;   
16.     }   
17.     public void setId_card(long id_card){   
18.         this.id_card = id_card;   
19.     }   
20.     public int compareTo(Object o){//默认按编号升序排序   
21.         Person person = (Person)o;   
22.         int result = id_card>person.id_card?1:(id_card==person.id_card?0:-1);   
23.         return result;   
24.     }   
25. }  

源文件：TestSet.java

Java代码

1. import java.util.*;   
2. public class TestSet{   
3.     public static void main(String args[]){   
4.         TreeSet<Person> treeSet = new TreeSet<Person>();   
5.         Person p1 = new Person("马先生",22015);   
6.         Person p2 = new Person("李先生",22016);   
7.         Person p3 = new Person("王小姐",22018);   
8.         Person p4 = new Person("尹先生",22020);   
9.         Person p5 = new Person("王先生",22012);   
10.         treeSet.add(p1);   
11.         treeSet.add(p2);   
12.         treeSet.add(p3);   
13.         treeSet.add(p4);   
14.         treeSet.add(p5);   
15.         System.out.println("初始化的集合:");   
16.         Iterator<Person> it = treeSet.iterator();   
17.         while(it.hasNext()){   
18.             Person p = it.next();   
19.             System.out.println(p.getId_card()+" "+p.getName());   
20.         }   
21.         System.out.println("截取前面部分得到的集合：");   
22.         it = treeSet.headSet(p1).iterator();   
23.         while(it.hasNext()){   
24.             Person p = it.next();   
25.             System.out.println(p.getId_card()+" "+p.getName());   
26.         }   
27.         System.out.println("截取中间部分得到的集合：");   
28.         it = treeSet.subSet(p1,p3).iterator();   
29.         while(it.hasNext()){   
30.             Person p = it.next();   
31.             System.out.println(p.getId_card()+" "+p.getName());   
32.         }   
33.         System.out.println("截取后面部分得到的集合：");   
34.         it = treeSet.tailSet(p3).iterator();   
35.         while(it.hasNext()){   
36.             Person p = it.next();   
37.             System.out.println(p.getId_card()+" "+p.getName());   
38.         }   
39.     }   
40. }  

程序的运行结果如下：
初始化的集合:
22012   王先生
22015   马先生
22016   李先生
22018   王小姐
22020   尹先生
截取前面部分得到的集合：
22012   王先生
截取中间部分得到的集合：
22015   马先生
22016   李先生
截取后面部分得到的集合：
22018   王小姐
22020   尹先生 
      在使用由TreeSet类实现的Set集合时，也可以通过单独的比较器对集合中的对象进行排序。 
      例如： 
      比较器既可以作为一个单独的类，也可以作为对应类的内部类，本例中移内部类的形式实现比较器。
源文件：Person.java

Java代码

1. import java.util.Comparator;   
2. public class Person implements Comparable{   
3.     private String name;   
4.     private long id_card;   
5.     public Person(String name,long id_card){   
6.         this.name = name;   
7.         this.id_card = id_card;   
8.     }   
9.     public String getName(){   
10.         return name;   
11.     }   
12.     public void setName(String name){   
13.         this.name = name;   
14.     }   
15.     public long getId_card(){   
16.         return id_card;   
17.     }   
18.     public void setId_card(long id_card){   
19.         this.id_card = id_card;   
20.     }   
21.     public int compareTo(Object o){//默认按编号升序排序   
22.         Person person = (Person)o;   
23.         int result = id_card>person.id_card?1:(id_card==person.id_card?0:-1);   
24.         return result;   
25.     }   
26.     static class PersonComparator implements Comparator{   
27.         public static final int NAME = 1;   
28.         public static final int ID_CARD = 2;   
29.         private int orderByColumn = 1;//默认为按姓名排序   
30.         public static final boolean ASC = true;   
31.         public static final boolean DESC = false;   
32.         private boolean orderByMode = true;//默认为按升序排序   
33.         public int compare(Object o1,Object o2){//实现Comparator接口的方法   
34.             Person p1 = (Person)o1;   
35.             Person p2 = (Person)o2;   
36.             int result = 0;//默认的判断结果为两个对象相等   
37.             switch(orderByColumn){//判断排序条件   
38.                 case 1:   
39.                     String s1 = CnToSpell.getFullSpell(p1.getName());   
40.                     String s2 = CnToSpell.getFullSpell(p2.getName());    
41.                     if(orderByMode){//升序   
42.                         result = s1.compareTo(s2);   
43.                     }   
44.                     else{//降序   
45.                         result = s2.compareTo(s1);   
46.                     }   
47.                     break;   
48.                 case 2:   
49.                     if(orderByMode){//升序   
50.                         result = (int)(p1.getId_card()-p2.getId_card());   
51.                     }   
52.                     else{//降序   
53.                         result = (int)(p2.getId_card()-p1.getId_card());   
54.                     }   
55.                     break;   
56.             }   
57.             return result;   
58.         }   
59.         public void orderByColumn(int orderByColumn){//用来设置排序条件   
60.             this.orderByColumn = orderByColumn;   
61.         }   
62.         public void orderByMode(boolean orderByMode){//用来设置排序方式   
63.             this.orderByMode = orderByMode;   
64.         }   
65.     }   
66. }  

源文件：TestSet.java

Java代码

1. import java.util.*;   
2. public class TestSet{   
3.     public static void main(String args[]){   
4.         TreeSet<Person> treeSet1 = new TreeSet<Person>();   
5.         Person p1 = new Person("马先生",22015);   
6.         Person p2 = new Person("李先生",22016);   
7.         Person p3 = new Person("王小姐",22018);   
8.         treeSet1.add(p1);   
9.         treeSet1.add(p2);   
10.         treeSet1.add(p3);   
11.         System.out.println("客户化排序前，默认按编号升序排序：");   
12.         //新创建一个Set集合，不进行客户化排序，默认按编号升序排序   
13.         TreeSet<Person> treeSet2 = new TreeSet<Person>(treeSet1);//通过构造函数初始化集合   
14.         Iterator<Person> it1 = treeSet2.iterator();   
15.         while(it1.hasNext()){   
16.             Person p = it1.next();   
17.             System.out.println(p.getId_card()+" "+p.getName());   
18.         }   
19.         System.out.println("客户化排序后，按编号降序排序：");   
20.         //新创建一个Set集合，进行客户化排序，客户化排序方式为按编号降序排序   
21.         Person.PersonComparator pc = new Person.PersonComparator();//创建比较器（内部类）的实例   
22.         pc.orderByColumn(Person.PersonComparator.ID_CARD);//设置排序依据的属性   
23.         pc.orderByMode(Person.PersonComparator.DESC);//设置排序方式   
24.         TreeSet<Person> treeSet3 = new TreeSet<Person>(pc);//必须通过构造函数设置比较器   
25.         treeSet3.addAll(treeSet1);//初始化集合   
26.         Iterator<Person> it2 = treeSet3.iterator();   
27.         while(it2.hasNext()){   
28.             Person p = it2.next();   
29.             System.out.println(p.getId_card()+" "+p.getName());   
30.         }   
31.     }   
32. }  

程序的运行结果如下：
客户化排序前，默认按编号升序排序：
22015   马先生
22016   李先生
22018   王小姐
客户化排序后，按编号降序排序：
22018   王小姐
22016   李先生
22015   马先生