java.util.HashSet类解析

HashSet 是一个由 HashMap 实现的集合,元素无序且不能重复。
其方法基本都是HashMap的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 继承 AbstractSet
* AbstractSet也是实现了Set接口的,跟HashMap一个毛病,脱裤子放屁....
* 实现 Set 接口
* 这个接口是 Set 类集合的上层接口,定义了实现该接口的类都必须要实现的一组方法
* 实现 Cloneable 接口
* 这个类是 java.lang.Cloneable,前面我们讲解深拷贝和浅拷贝的原理时,
* 我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现,
* 但是调用该方法的对象必须要实现 Cloneable 接口,
* 否则会抛出 CloneNoSupportException异常。
* 实现 Serializable 接口
* 序列化
*/
public class HashSet<E> extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{}

成员变量

1
2
3
4
5
6
7
8
/**
* 就是一个HashMap,说明靠这个来存储数据了
*/
private transient HashMap<E,Object> map;
/**
* 向HashSet中添加数据,数据在上面的 map 结构是作为 key 存在的,而value统一都是 PRESENT
*/
private static final Object PRESENT = new Object();

构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
* 就是new一个HashMap
*/
public HashSet() {
map = new HashMap<>();
}
/**
* 指定初始容量HashMap
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}

/**
* 指定初始容量和加载因子HashMap
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}

/**
* 这个dummy都没用到,兼容旧版本用的吧。
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}


/**
* 构造包含指定集合中的元素
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}

方法

add

1
2
3
4
5
6
/**
* 往map里put值
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

clear

1
2
3
4
5
6
/**
* 清除map
*/
public void clear() {
map.clear();
}

clone

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 克隆
*/
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}

contains

1
2
3
4
5
6
/**
* 是否包含此值,也就是判断是否包含此key
*/
public boolean contains(Object o) {
return map.containsKey(o);
}

isEmpty

1
2
3
4
5
6
/**
* 是否为空
*/
public boolean isEmpty() {
return map.isEmpty();
}

iterator

1
2
3
4
5
6
/**
* 迭代类
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}

remove

1
2
3
4
5
6
/**
* 移除某值
*/
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}