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接口的结果是一样的