本解析源码来自JDK1.7，HashSet是基于HashMap实现的，方法实现大都直接调用HashMap的方法
另一篇HashMap的源码解析文章
概要
- 实现了Set接口，实际是靠HashMap实现的
- 不保证遍历时的顺序，不保证集合顺序的不变性
- HashSet允许出现null值
- 假定Hash算法能很好的分散元素，查询的时间复杂度为O(1)
- 遍历的时间复杂度由set的size和其依靠的HashMap的capacity来决定
- HashSet是非同步的可以通过
Set s = Collections.synchronizedSet(new HashSet(...));的方式获得同步的set - HashSet的Iterator有fast-fail机制，但是并不能保证程序一定正确，fail-fast机制通常只用来检测bug
实现接口
- Set接口包含集合常用方法
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
public interface Set<E> extends Collection<E> {
// Query Operations
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
// Modification Operations
boolean add(E e);
boolean remove(Object o);
// Bulk Operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean retainAll(Collection<?> c);
boolean removeAll(Collection<?> c);
void clear();
// Comparison and hashing
boolean equals(Object o);
int hashCode();
} - Cloneable 对集合元素进行浅拷贝，调用了map的clone方法来克隆自身map域，由于HashMap执行的是浅拷贝，虽然创建了新的Entry，但是没有创建新的key和value，通过原Set和clone后的set对key和value的改变是等效的。
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();
}
} - Serializable HashSet实现了自己readObject和writeObject方法，将map的keySet中的元素分别写入，对端读出后放入自己的map中去
主要成员
- map用来装载set的元素，HashSet就是HashMap的keySet。transient表明序列化时略过，HashSet实现了自己的序列化方法。
- 常量PRESENT用来填充HashMap的value，也就是说HashSet中的map的value都是同一个对象，高效的利用堆空间
NOTE：所有被装入集合(map,set,list)的对象，都只是将对象的引用复制一份到集合中。如果通过外部引用改变了对象的内容，集合中的对象的内容也会跟着改变。但是如果将外部引用指向其他对象，集合内部的引用并不会改变，还是会指向加入集合时引用指向的对象。也即元素被放入集合时，执行的是浅拷贝，引用复制而对象不会重新创建
private transient HashMap<E,Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object(); 构造函数
我们看到初始化HashSet就是初始化对应的HashMap对象map成员变量
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
} 集合相关方法
可以看到对HashSet的操作就是对对应的HashMap对象map的操作
public Iterator<E> iterator() {
return map.keySet().iterator();
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
public boolean add(E e) {
return map.put(e, PRESENT) == null;
}
public boolean remove(Object o) {
return map.remove(o) == PRESENT;
}
public void clear() {
map.clear();
} HashMap解决扩容问题
- 调整的时机 （负载因子）x（容量）>（Map 大小），则调整 Map大小 为之前的二倍，该过程包含了table的复制，性能消耗较大，如果map大小已知，可以在初始化时合理设定map的初始大小，避免扩容。
- 如果数组大小已经到达最大容量，将阈值置为Integer.MAX_VAlUE,不再进行扩容
- 新申请数组，重新定址并将原数组中的Entry转移到新数组中，由于容量变化，即使Hash值不变，Entry的index也会改变，index=hash&(length-1),取hash的低位，length增大，index取的位数增多
- 依旧使用头插法将所有元素进行复制
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
} HashMap 元素存储位置的计算 hash值
- String类型的key的hashcode是根据与字符串内容相关的，由于可能引起很多碰撞，所以值单独计算
- Object类型的key的HashCode是基于其内存地址的。为了充分利用Integer值的高位，需要将高位的影响引入低位，（由于多数map的length是比较小的）
- 由于length是2的指数倍，所以可以用hash&（length-1）代替 hash%length，位运算有更高的效率
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);
}
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
} HashMap的put方法
下面以HashMap的put方法为例对HashSet的集合方法进行说明
- 如果是key为null，遍历查找table中key是否有null，如果有更新value，否则添加null，value节点
- 如果key不为null，根据Key的hashcode获取Hash值，根据Hash计算其在table中的索引。hash值计算时利用高位与低位进行异或操作，加入高位因素，来减少Hash碰撞。
- 由于tablelength 都是2的指数次幂，所以indexFor用 HashCode&（table.lenght-1）取HashCode的低位，使用位运算提高运算效率
- 如果table[i]不为null(并不表示Hash值相同，HashCode不同也可能碰撞)，也就是发生了Hash碰撞，如果存在与keyHash相等（equals）或相同（==）的key，那么更新value
- 如果table[i]为null，或者table[i]链表中不存在Hash值与Key相同且equals函数返回true的情况就根据Hash值添加新的节点
- addEntry()方法首先判断大小是否超过阈值，然后使用头插法，插入元素
NOTE
在判断插入Entry是否为覆盖时，会先判断Key的hashCode是否和map中的key相等，然后判断Equals方法或者==，所以如果重写了equals方法，要记得重写hashcode方法，使得其逻辑相同，否则即使equals方法判断相等也不会发生覆盖
public V put(K key, V value) {
// HashMap允许存放null键和null值。
// 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。
if (key == null)
return putForNullKey(value);
// 根据key的keyCode重新计算hash值。
int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
// 搜索指定hash值在对应table中的索引。
int i = indexFor(hash, table.length);
// 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
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;
}
}
// 如果i索引处的Entry为null，表明此处还没有Entry。
modCount++;
// 将key、value添加到i索引处。
addEntry(hash, key, value, i);
return null;
}
/**产生哈希码*/
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
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).
/*加入高位计算，防止低位不变，高位变化是引起hash冲突*/
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
/**产生索引，由于索引产生是不确定的，因此也就造成了HashMap顺序的不确定性。
需要注意的是不同的hash产生的索引完全有可能相同的
该方法的实现十分的巧妙，它通过h & (length-1)来的到对象保存的
索引，有可知道底层数组为2的n次方，这在速度上就有了明显的优化
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
} Clone方法
Clone方法是浅拷贝方法
Clone就是将对应的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();
}
}HashMap的Clone方法
Clone实现的是浅拷贝，虽然重新创建了Entry但是并没有重新创建key，value，即如果通过原HashMap的key的引用改变了key的属性，clone出来的HashMap的key也会跟着改变，克隆出来的Map的数组的大小也不一定与原Map相同
- HashSet的Clone方法其实就是对成员变量map的clone
- 首先会创建一个空的HashMap对象
- 然后对该HashMap进行扩容，容量大小取Math.min(当前table大小，HashMap的最大容量，当前的Size*（Math.min(1/loadFactor,4))，克隆出来的HashMap的数组初始大小并不会与当前Map一致，而是考虑合理的初始化loadFactor之后的结果。
- 最后调用putAllForCreate(this)依次将当前Map的(key,value)放到Map中去，过程中虽然创建了新的Entry但是并没有创建新的key，value，通过原HashMap和通过克隆出来的HashMap改变(key,value)效果是等同的。
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();
}
}
public Object clone() {
HashMap<K,V> result = null;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
if (result.table != EMPTY_TABLE) {
result.inflateTable(Math.min(
(int) Math.min(
size * Math.min(1 / loadFactor, 4.0f),
// we have limits...
HashMap.MAXIMUM_CAPACITY),
table.length));
}
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
result.putAllForCreate(this);
return result;
}
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key);
int i = indexFor(hash, table.length);
/**
* Look for preexisting entry for key. This will never happen for
* clone or deserialize. It will only happen for construction if the
* input Map is a sorted map whose ordering is inconsistent w/ equals.
*/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
createEntry(hash, key, value, i);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
} 序列化方法
序列化方法就是将Map keySet中的元素依次写出，然后在对端依次读入，重建HashMap
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);
}
}