Java-集合框架Collection之Set(一)

set接口

Set接口继承了Collection接口

特点：
（1）无序，即存放元素和取出元素的顺序不保证一致（也有一致的情况，是因为刚好存储的算法）。
（2）不重复，它存放的元素没有重复，更确切的说是Set集合中的元素须满足e1.equals(e2)的条件，所以Set集合中最多包含一个null元素，此接口模仿了数学上的集合(Set)。

Set接口的实现类HashSet

HashSet继承了AbstractSet类，实现了Set接口。其实AbsractSet抽象类也实现了Set接口，AbstarctSet类继承了AbstractCollection类，AbstractCollection类实现了Collection接口中的部分方法。
存放到HashSet集合中的对象，其底层的实现是一个HashMap实例，HashMap实例对象会调用hashcode()和equals()两个方法，而Object的equals()方法比较的是两个对象的引用地址（即是不是同一个对象），所以必须重写equals()方法，hashcode()方法是为了查找的快捷性，hashCode是用来在散列存储结构中确定对象的存储地址的。所以也需要重写。
在几个常见的数据类型中，基本数据类型对应的封装类中对equals()和hashcode()的重写都和值有关。
Boolean类型的hashcode值：

public int hashCode() {
        return value ? 1231 : 1237;
    }

true返回1231，false返回1237；

String对equals()方法重写返回字符串的内容，hashcode()方法如下：

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

最终返回的hashcode值是 s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]（n是字符串长度）

例子1：

存放基本数据类型对应的封装类（集合只能存放对象，jdk1.5之后自动封装基本数据类型）

http://bbs.itheima.com/thread-110254-1-1.html(集合为什么不能存放基本数据类型)

    public static void main(String[] args) {
        HashSet<Integer> set =new HashSet<Integer>();
        set.add(6);
        set.add(2);
        set.add(3);
        set.add(3);
        set.add(5);
        set.add(1);
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next());
        }
    }

结果：

12356

实现原理：

private transient HashMap<E,Object> map;

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

创建HashMap对象，把元素放到HashMap中

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

在存储第一个元素的时候，
会首先创建一个Entry的数组，来准备存储元素

int hash = hash(key);
/*获得hashcode值*/
final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

根据一定的算法，算出hashcode的值，这个hash值和hashcode()方法有关，

int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

这个hash值决定了这个元素存储在数组的那个位置，如果这个位置还没有存放元素，则直接放到该位置，如果后面添加的元素和前面的元素不重复，那么直接添加到数组中，如果有重复，就根据equals()方法来对比。

例子2：

存放自定义类型：如(Dog类，Animal类)

创建Dog类：

public class Dog {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }

    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;
    }
}

public static void main(String[] args) {
        Dog dog1 = new Dog("Teemo",1);
        Dog dog2 = new Dog("Teemo",1);
        HashSet<Dog> set =new HashSet<Dog>();
        set.add(dog1);
        set.add(dog2);
        Iterator<Dog> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next());
        }
    }

结果：

Dog [name=Teemo, age=1]Dog [name=Teemo, age=1]

输出了两个名字和年龄相同的dog,由于没有重写hashcode()和equals()两个方法，所以HashSet集合默认比较的的是两个对象的引用地址是否相同，dog1和dog2都是通过new 关键字创建出来的，所以，他们指向的是两个不同的地址，但是在考虑只有name和age这两个属性的dog时,正常情况下，所有特征都相同的两只dog会被认为是同一只。所以需要重写equals()和hashcode()方法

@Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Dog other = (Dog) 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;
    }

重写Dog类的hashcode()和equals()后的结果：

Dog [name=Teemo, age=1]

Set接口的实现类LinkedHashSet

LinkedHashSet继承自HashSet类，LinkedHashSet中存储的元素的特点是有序、唯一。

/**
 * link 有序
 *  hashset 唯一
 * @author wjf
 */
public class LinkedHashSetTest {
    public static void main(String[] args) {
        LinkedHashSet<Integer> linkSet = new LinkedHashSet<Integer>();
        linkSet.add(3);
        linkSet.add(2);
        linkSet.add(0);
        linkSet.add(5);
        linkSet.add(9);
        Iterator<Integer> iterator = linkSet.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next());
        }
    }
}

输出结果：

32059