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