集合之HashSet

HashSet是实现Collection接口的子接口Set的一个子类，其使用的底层数据结构是哈希表，当存储元素时，该集合使用哈希算法来计算出一个哈希值作为元素存在哈希表中的地址，由于存入的元素是不可重复的，所以哈希表保证了每个对象元素的唯一性，这不仅仅体现在拥有唯一的地址，当哈希值相同时，集合查重的方式变成调用当前元素的equals方法来检测是否为相同的对象，不相同则在改地址下存入新的对象，否则被集合视为重复元素拒绝签收。。

由于是Collection的实现子类，所以Collection的一些方法对其也适用，但添加、删除元素的顺序与其在集合中的排序无关，这也体现了元素的无序性。

下面通过代码来验证一下。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

package com.wk.collection;
import java.util.HashSet;
import java.util.Iterator;
public class TreeSet {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();
        hs.add("one");
        hs.add("two");
        hs.add("three");
        hs.add("four");

        Iterator<String> it = hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        /*
         * for(Iterator<String> it = hs.iterator();it.hasNext();){
         *      System.out.println(it.next());
         *  }
         */

    }
}

这里使用HashSet存入四个数据，可以看到存入的数据与元素在集合中的排序不一致。

这里在迭代元素时使用for语句进行小小的优化，使用while循环当循环结束时Iterator对象仍在内存中，使用for语句可以在循环结束后Iterator对象也随之回收，对内存的消耗也减少了一些。

继续来看，如果添加一个相同的元素时，比如one，输出为：

可以看到元素并没有被添加进来，由于添加的元素字符串对象，而String继承了Object类，所以直接调用了父类的equals方法进行比较，相同则没有添加。

接下来用HashSet添加一个对象而不是简单的字符串。。。。。。。。。。。。。。。。。。。。。

package com.wk.collection;

import java.util.HashSet;
import java.util.Iterator;

//创建一个Person类
class Person{
    private String name;
    private int age;
    public Person(String name,int age) {
        // TODO 自动生成的构造函数存根
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

public class TreeSet {
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<>();
        Iterator<Person> it = hs.iterator();
        Person p = new Person("小明", 16);
        System.out.println(p);
    }
}

这里新建两个Person对象，然后输出了两个不同的哈希值，这就是存在HashMap中的地址。

这就是元素在哈希表中存储的方式。。。

当然集合本身只是比较了哈希值，那么可以在Person类中重写hasCode方法使每个对象有相同的哈希值，然后在添加几个Person对象，其中有一个重复的（名字年龄相同视为同一元素）看集合如何比较。

class Person{
...
//重写父类hashCode方法
public int hashCode(){
        return 90;      
    }
...
}
...
public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();
        hs.add(new Person("小明", 16));
        hs.add(new Person("小红", 17));
        hs.add(new Person("小华", 18));
        hs.add(new Person("小明", 16));

        Iterator<Person> it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p);
            System.out.println(p.getName()+"---"+p.getAge());
        }
    }
...

然后看输出

可以看到所有元素返回了相同的哈希值，但重复元素仍然被添加了进去，这是怎么回事，难道equals方法未被调用？不是的，由于equals方法比较的是对象，这里创建了两个不同的对象，虽然对象内容相同，所以应该重写equals方法，定义我们想要的“相同元素”的概念。

...
public boolean equals(Object obj){
        if(!(obj instanceof Person))
            return false;
        Person p = (Person) obj;
        System.out.println(this.name+"-equals-"+p.name);
        //判断名字和年龄是否相同
        return this.name.equals(p.name)&&this.age == p.age;
    }
...

由于哈希值相同就不在赘述了，然后看每存入一个元素，都会和其他元素equals一次，当第二个“小明”元素存入时发现是相同元素，所以就没有存入。这也实现了之前自定义的相同元素的效果。

然后还原HashSet的原始比较方法，修改一下hashCode方法即可。

...
public int hashCode(){
        System.out.println(this.name+"获得一个hashCode");
        return name.hashCode()+age*50;
    }
...

至于为什么hashCode方法返回这样一个值呢？其实也没有什么特别的地方，只要保证其唯一型即可，从输出可以看到HashSet的整个比较过程。