Java中的集合框架-Collection（二）

　　上一篇《Java中的集合框架-Collection（一）》把Java集合框架中的Collection与List及其常用实现类的功能大致记录了一下，本篇接着记录Collection的另一个子接口Set及其实现类。

一，Collection子接口Set

　　Set接口与List接口同时是Collection接口的子接口，但两者区别还是很大的。

　　首先，Set里的方法与Collection里的方法完全一样；

　　其次，Set是无序的，即Set的存储与取出顺序可能不一致；演示如下：

     private static void function_demo9() {
         Set set = new HashSet();
         set.add(7);
         set.add(4);
         set.add(3);
         Iterator it = set.iterator();
         while (it.hasNext()) {
             System.out.println(it.next());
         }
     }

　　程序运行结果：

　　　　　　　　

　　可见Set存储的顺序与取出的顺序是不一致的，但是可以看到，其实Set采用了某种方式进行默认的排序，这一点在后面会说。

　　最后，Set里的元素不可重复；演示如下：

     private static void function_demo9() {
         Set set = new HashSet();
         set.add(7);
         set.add(4);
         set.add(3);
         set.add(3);
         Iterator it = set.iterator();
         while (it.hasNext()) {
             System.out.println(it.next());
         }
     }

　　程序运行结果：

　　　　　　　　

　　可见Set里存储相同的元素时不能被放到容器里。

二，Set常用实现类

　　Set接口也有很多的实现类，比较常用的也有三个：HashSet，TreeSet，LinkedHashSet，我们再次完善一下Collection接口的类图，如下：

　　　　　　　　　　

　　1，Set常用实现类-HashSet

　　　　HashSet实现了Set接口，它是非同步，不保证顺序的一个集合，查看源码可知，其实HashSet内部维护的是一个HashMap，只是value值的是一个Object对象而已。

　　　　HashSet使用hash算法存储数据，在存储的时候，先去判断hashcode是否相同，若相同的情况下再去判断对象的内容是否相同；

　　　　在判断hashcode是否相同的时候用的是hashcode方法，在判断内容是否相同的时候用的是equals方法；

　　　　若hashcode不同则不必再去判断对象内容即不会再调用equals方法；

　　　　看下面一个例子，HashSet里存储自定义的对象类型

 public class Person {
     public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     private int age;
 }

     private static void function_demo10() {
         HashSet hs = new HashSet();
         hs.add(new Person("张三", 32));
         hs.add(new Person("李四", 12));
         hs.add(new Person("赵五", 12));
         hs.add(new Person("马七", 56));
         hs.add(new Person("马七", 56));
         for (Iterator iterator = hs.iterator(); iterator.hasNext();) {
             System.out.println(((Person)iterator.next()).getName());
         }
     }

　　　　程序运行结果：

　　　　　　　　　　

　　　　我们知道，Set里是不可以存储重复的元素的，但为何上面可以存储两个“马七”？

　　分析一下，我们存储对象的时候用的是new Person（）的方式，前面说过，HashSet在存储的时候先会去判断每个对象的hashcode是否相同，那么每次new出来的Person对象的hashcode值肯定是不相同的，所以HashSet直接就判断这两个对象不是同一个对象但存储进去了，若想完成这个去除重复的存储，可以先让Person类重写hashcode方法，修改如下：

 public class Person {
     public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     private int age;

     @Override
     public int hashCode() {
         return this.name.hashCode();
     }
 }

　　此时再运行程序便会发现，”马七“还是两个了。其实HashSet在存储元素的时候，会拿两个元素的hashcode去做比较，此时若hashcode相同便去比较两个元素的内容，调用的是该元素的equals方法；若hashcode不同则存储该元素。因为Person重写了hashcode方法，但hashcode方法里我们返回的是当前对象的name的hashcode值；当往HashSet存储Person对象时，存储第二个”马七“时hashcode值还是一样的，便会去调用对象的equals方法，但是equals方法比较的是堆里的地址，两个对象在堆里的地址是不一样的，所以判定还是两个不同的对象，所以还是出来了两个”马七“。为了解决这个问题，我们再把Person类的equals方法重写一下，代码如下：

 public class Person {
     public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     private int age;

     @Override
     public int hashCode() {
         return this.name.hashCode();
     }

     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         Person other = (Person) obj;
         if (age != other.age)
             return false;
         if (name == null) {
             if (other.name != null)
                 return false;
         } else if (!name.equals(other.name))
             return false;
         return true;
     }

 }

　　　　此时再运行程序，发现只有一个”马七“了。

　　2，Set常用类-LinkedHashSet

　　　　LinkedHashSet继承自HashSet，不同步；

　　　　LinkedHashSet与HashSet的区别是它内部数据结构是双向链表的形式，它能保证存储的顺序与取出的顺序是一致的；

　　　　LinkedHashSet里面所有的方法都是从HashSet继承而来的，这里演示一下它有HashSet的区别，如下：

     private static void function_demo12() {
         HashSet hs = new HashSet();
         hs.add(1);
         hs.add(6);
         hs.add(2);
         hs.add(4);
         hs.add(3);
         System.out.println("HashSet存取不一致："+hs);
         LinkedHashSet lhs = new LinkedHashSet();
         lhs.add(1);
         lhs.add(6);
         lhs.add(2);
         lhs.add(4);
         lhs.add(3);
         System.out.println("LinkedHashSet存取一致："+lhs);
     }

　　3，Set常用类-TreeSet

　　　　TreeSet内部其实是TreeMap的形式， 是二叉树的数据结构，它是非同步的；

　　　　TreeSet可对存储的元素按照自然顺序进行排序；

     private static void function_demo13() {
         TreeSet ts = new TreeSet();
         ts.add("1");
         ts.add("4");
         ts.add("2");
         ts.add("3");
         ts.add("abc");
         ts.add("zzd");
         ts.add("adef");
         ts.add("mnjuk");
         ts.add("aaac");
         System.out.println(ts);
     }

　　　　程序运行结果：

　　　　　　　　　　

　　　　但是当TreeSet存储自定义对象时，演示如下（Person类还是上面的Person类）：

     private static void function_demo14() {
         TreeSet ts = new TreeSet();
         ts.add(new Person("张三", 32));
         ts.add(new Person("李四", 12));
         ts.add(new Person("赵五", 12));
         ts.add(new Person("马七", 56));
         ts.add(new Person("马七", 56));
     }

　　　　程序运行x结果：

               

　　报错说Person类不能转成Comparable。原因就是当往TreeSet存储元素的时候，因为TreeSet会使用二叉树算法对元素进行排序，它会找比较的依据进行存储，那么这个被存储的对象就要具备比较的功能，这个具备比较功能的接口就是Comoparable；那么存储字符串的时候为什么没报错呢？原因是String已经实现了Comparable接口，具备了比较的功能，下面我们让Person类实现这个接口，代码如下：

 public class Person implements Comparable {
     public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     private int age;

     @Override
     public int compareTo(Object o) {
         return 0;
     }

 }

　　　　Comparable接口强行对实现它的类的对象的元素进行整体的排序，它里面只有一个compareTo方法，此方法返回0表示相等，负数表示小于，正数表示大于，此时程序运行结果如下：

　　　　　　　　　　　　　　　　　　

　　　可以看到，我们往TreeSet里添加了五个元素，但是此时只添加了一个Person对象进去，出现这样问题的原因就是我们在重写了Comparable里的compareTo方法后直接返回了0，它说明添加的所有的元素都是同一个元素，所以只添加一个元素到了容器中，我们再次修改Person对象里的coompareTo方法，代码如下：

 public class Person implements Comparable {
     public Person(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     private int age;

     @Override
     public int compareTo(Object o) {
         Person person = null;
         if (o instanceof Person) {
             person = (Person) o;
         }
         return this.getName().hashCode() - person.getName().hashCode();
     }

 }

　　此时程序运行结果是：　　　　　　　　

　　四个元素添加成功了，并且没有重复的元素。

　　TreeSet在存储自定义对象的时候，还有另外一种不去让对象实现Comparable接口而可以进行排序的方法，那就是在实例化TreeSet的时候，调用带比较器Comparator的构造函数；

　　Comparator接口有两个方法，一个compare，另一个是equals方法；操作如下：

　　实现了Comparator接口的自定义比较器对象代码：

 public class MyComparator implements Comparator {

     @Override
     public int compare(Object o1, Object o2) {
         Person p1 = (Person) o1;
         Person p2 = (Person) o2;
         return p1.getName().hashCode() - p2.getName().hashCode();
     }

 }

　　　　主程序代码如下：

     private static void function_demo15() {
         TreeSet ts = new TreeSet(new MyComparator());
         ts.add(new Person("张三", 32));
         ts.add(new Person("李四", 12));
         ts.add(new Person("赵五", 12));
         ts.add(new Person("马七", 56));
         ts.add(new Person("马七", 56));
         System.out.println(ts);
     }

　　　　程序运结果和让Person类实现Comparable接口的结果是一样的