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

来源：互联网发布：德客会员管理系统源码编辑：程序博客网时间：2024/06/05 04:38

set接口

Set接口继承了Collection接口

Set接口

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

Set接口的实现类HashSet

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

结果：

实现原理：

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类

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

输出结果：

1 0