刚入java不久的程序猿,对于简单的使用已毫不满足,最终为了一探究竟,翻开了JDK的源码,以下观点为自己的理解及看了多篇博客的总结,欢迎各位大神指出不对的地方,当然也欢迎和我一样刚学的同学,一起加油努力吧~~
HashSet是什么 |
HashSet是一个无序并且不重复的集合,它是基于HashMap来实现的,如果看过HashMap源码的会发现HashSet实现相对简单,如未看过的,可查询相关解析资料,或进入我的这篇博文中了解一下:HashMap源码解析,通常在工作中我们会使用HashSet来去重,很方便,下面开始HashSet源码解析
HashSet源码分析 |
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{
...
}
这里我们看到HashSet继承了AbstractSet,实现了Set接口,下面我们继续追踪,分别从AbstractSet和Set一层一层点进去,会发现它们都继承了Collection这个接口
public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
}
public abstract class AbstractCollection<E> implements Collection<E> {
}
public interface Set<E> extends Collection<E> {
}
至此集合分成了两类,一类是继承了Collection接口的,一类是继承了Map接口的,下面继续由Collection深入下去,最终会进入到这个接口
public interface Iterable<T> {
Iterator<T> iterator();
}
相信这东西大家应该都不陌生。没错,就是迭代器,AbstractCollection里的方法都是通过迭代器来实现的,反观Map的实现,也是通过迭代来完成的,所以说迭代器在集合里起到了至关重要的角色,看完继承与实现体系后,继续HashSet的源码解读,首先我们先看一下HashSet的参数
/**
* 版本号
*/
static final long serialVersionUID = -5024744406713321676L;
/**
* 后面用到的map
*/
private transient HashMap<E,Object> map;
// 与KEY值对应的一个虚值(value)
private static final Object PRESENT = new Object();
下面来看一下HashSet的构造方法
/**
* 调用HashMap空的构造方法,实际上是调用了HashMap(int initialCapacity, float loadFactor)这个方法
*/
public HashSet() {
map = new HashMap<>();
}
/**
* 调用了HashMap(int initialCapacity, float loadFactor)这个方法
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* 循环添加,并返回添加状态
*/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
/**
* 调用了HashMap(int initialCapacity, float loadFactor)这个方法
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
/**
* 调用了HashMap(int initialCapacity)这个构造方法,实际上仍是调用HashMap(int initialCapacity, float loadFactor)这个方法
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
/**
* 调用了LinkedHashMap(int initialCapacity, float loadFactor)这个构造方法,实际上仍是调用HashMap(int initialCapacity, float loadFactor)这个父类方法
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
下面来看一下剩下的方法,也都是基于HashMap实现的
/**
* 通过keySet方法取得所有的key(set集合),接着调用iterator方法
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* 获取map的长度,也就是HashSet的长度
*/
public int size() {
return map.size();
}
/**
* 判断是否为空
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* 判断HashSet中某个元素是否存在
* 存在返回true
*/
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
* 添加元素,调用map的put方法
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
/**
* 移除元素,调用map的remove方法
*/
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
/**
* 清空集合,调用map的clear方法
*/
public void clear() {
map.clear();
}
/**
* 浅克隆,实际并没有复制元素本身,调用map的克隆方法
*/
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();
}
}
/**
* 序列化写入,将map中所得到的容量,加载因子,长度都写入到流中
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out HashMap capacity and load factor
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// Write out size
s.writeInt(map.size());
// Write out all elements in the proper order.
for (E e : map.keySet())
s.writeObject(e);
}
/**
* 序列化读取,将容量,加载因子,长度一次读出
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in HashMap capacity and load factor and create backing HashMap
int capacity = s.readInt();
float loadFactor = s.readFloat();
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}