HashSet源码解析
源码解析对应JDK1.7
JDK1.7源码下载地址:JDK1.7下载地址
HashSet源码中官方注释是这样描述的:
This class implements the Set interface, backed by a hash table (actually a HashMap instance).
It makes no guarantees as to the iteration order of the set;
in particular, it does not guarantee that the order will remain constant over time.
This class permits the null element.
大意是:
此类实现了Set接口,由哈希表(实际上是HashMap实例)支持。
对集合的迭代次序不作任何保证; 特别是不能保证订单在一段时间内保持不变。
此类允许null元素。
首先记住结论:
a. HashSet 没有重复元素的集合。
b. HashSet 是无序的。
c. HashSet 元素允许为null。
d. HashSet 非线程安全
HashSet的构造函数
HashSet():
构造一个新的空 set,其底层 HashMap 实例的默认初始容量是 16,加载因子是 0.75。
HashSet(int initialCapacity):
构造一个新的空 set,其底层 HashMap 实例具有指定的初始容量和默认的加载因子(0.75)。
HashSet(int initialCapacity, float loadFactor):
构造一个新的空 set,其底层 HashMap 实例具有指定的初始容量和指定的加载因子。
HashSet(Collection<? extends E> c):
构造一个包含指定 collection 中的元素的新 set。
HashSet参数
// HashSet的底层容器,没错,是HashMap!
private transient HashMap<E, Object> map;
// Dummy value to associate with an Object in the backing Map
// 定义一个Object对象作为HashMap的value值
private static final Object PRESENT = new Object();
HashSet常用方法
add()方法
public boolean add(E e) {
return map.put(e, PRESENT) == null;
}
add()方法底层调用的是HashMap的put方法;
这时候e就是key,PRESENT就是value。
public V put(K key, V value) {
// 如果key为空,将null存放在table[0]第一个位置,这就是HashMap允许存null的原因
if (key == null)
return putForNullKey(value);
// 计算key的hash值
int hash = hash(key);
// 根据hash码和数组长度,计算table数组下标
int i = indexFor(hash, table.length);
// 从i处开始迭代entry链表,找到key保存的位置
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
// 判断该链条上是否有hash值相同的(key相同)
// 若存在key相同,直接覆盖value,返回旧的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;// 取出旧值
e.value = value;// 赋新值
e.recordAccess(this);
return oldValue;// 返回旧值
}
}
// 修改次数+1
modCount++;
// i处没有entry链表(该位置为空),将key,value添加至i处
addEntry(hash, key, value, i);
return null;
}
这个源码很熟悉吧..HashMap中的put方法。
当我们第一次插入的时候很顺利,调用addEntry(),插入到Entry中。
那么问题来了,HashSet是怎么通过HashMap来实现元素不重复的呢?
举个栗子:
HashSet<String> set = new HashSet<String>();
set.add("a");
set.add("a");
第一次add时候,调用put("a",PRESENT),之后没问题,看源码就行。
第二次add相同的数据,依旧调用put("a",PRESENT)
运行到这里:
// 从i处开始迭代entry链表,找到key保存的位置
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
// 判断该链条上是否有hash值相同的(key相同)
// 若存在key相同,直接覆盖value,返回旧的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;// 取出旧值
e.value = value;// 赋新值
e.recordAccess(this);
return oldValue;// 返回旧值
}
}
你看啊,因为两次的key是一样的,计算出来的下标也是一样的,这时候就开始比较key了
如果两个key一样,那么将新key的value覆盖旧key的value,也就是说,key始终没有发生变化!!
简单地说当key存在于HashMap的key时,会替换原有的value,但是key保持不变。
所以将一个已经存在的key元素添加到HashSet中,新添加的元素不会保存到HashMap中。
clear()方法
/**
* Removes all of the elements from this set. The set will be empty after
* this call returns.<br>
* 从该集合中删除所有元素。 此通话返回后,该设置将为空。
*/
public void clear() {
map.clear();
}
调用了底层
map
的
clear
方法;
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}
将
map
清空
...
contains()方法
public boolean contains(Object o) {
return map.containsKey(o);
}
底层调用了map的containsKey方法。
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
跟下去看getEntry()方法
final Entry<K, V> getEntry(Object key) {
// 计算key的hash值
int hash = (key == null) ? 0 : hash(key);
// 根据hash值,算出下标位置,从table数组中取出Entry
for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
// 查找的key与entry中的key相同,则返回对应的value
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
注释写的比较清楚了不解释了
...
HashSet底层是基于HashMap实现的,如果之前HashMap看明白,看透了,HashSet也是很容易的。