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