java源码-HashSet

开篇

当抛弃所有虚的东西之外，我决定好好的把java的基础再过一遍，包括java源码、effective java、阿里的java代码编程规范。希望能够进一步夯实自己的基础，增加自己的底气。
java部分的内容我会着重看看java的集合类和java的concurrent包下的多线程部分，有兴趣的同学可以撸下这部分代码，另外jdk8的源码部分可以去github上面找，已经有人在上面贡献了。
就让我以HashSet做一个开局吧。

HashSet类图

构造函数

在HashSet内部我们使用HashMap<E,Object> map对象来实际存储HashSet的集合对象，由于HashSet当中保存的只是key而没有value，所以在实际的HashMap当中map的key保存的是HashSet集合当中的值，map的value是固定的一个Object对象，也就是当前的PRESENT对象。
知道了HashSet内部的存储方式是采用HashMap的，那么其实我们后面的增删改查其实操作的就是HashMap对象，所以后面的分析其实就是在分析HashMap的操作。

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { static final long serialVersionUID = -5024744406713321676L; private transient HashMap<E,Object> map; private static final Object PRESENT = new Object(); 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(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadFactor); } } 

HashSet核心方法分析

size()方法

HashSet的size方法直接调用的HashMap的size方法，而HashMap的size方法内部直接范围内部计数变量值size。

 public int size() { return map.size(); } transient Node<K,V>[] table; transient Set<Map.Entry<K,V>> entrySet; transient int modCount; int threshold; final float loadFactor; public int size() { return size; } 

isEmpty()方法

HashSet的isEmpty方法直接调用的HashMap的isEmpty方法，而HashMap的isEmpty方法内部直接比较size==0是否相等来确定是否为空，所以总结起来还是比较size的值。

 public boolean isEmpty() { return map.isEmpty(); } public boolean isEmpty() { return map.isEmpty(); } public boolean isEmpty() { return size == 0; } 

contains()方法

HashSet的contains方法直接调用HashMap的containsKey方法来判断key是否存在，而containsKey内部通过根据key的hash值，通过计算的hash值找到table的槽位，如果第一个元素的key就是查询的key就直接返回，否则就依次遍历冲突链逐个进行比较解决。
这里需要说明的就是hash方法内部其实就是对key取了个hashcode()的值。

 public boolean contains(Object o) { return map.containsKey(o); } public boolean containsKey(Object key) { return getNode(hash(key), key) != null; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; } 

add()方法

HashSet的add方法内部通过HashMap.put()方法来实现key的添加，在HashMap内部真正执行的是putVal()方法，在putVal()的内部执行其实按照以下顺序执行的。

• 如果HashMap内部的桶数组没有初始化就创建一个桶数组
• 通过hash值找到桶下标，如果对应位置为空就直接创建一个Node节点newNode
• 通过hash值找到桶下标，如果对于位置不为空那么就直接比较key是否相等，如果相等就直接返回，如果遍历完成后都没有找到那么在链表的最后连接一个新创的节点
• 在新增节点后判断是否超过上限需要进行resize动作，resize()函数也是一个很有意思的过程，这个放到HashMap当中去分析吧
• ++modCount这个会记录值的变更然后通过比较值抛出更改异常

 public boolean add(E e) { return map.put(e, PRESENT)==null; } public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } public boolean add(E e) { return map.put(e, PRESENT)==null; } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } 

remove()方法

HashSet的remove方法内部通过调用HashMap的remove方法来实现key的删除。
HashMap的remove方法内部逻辑通过对key进行hash定位到hash桶的下标，然后遍历桶下面的列表节点通过比较key是否相同进行删除。
删除后同样会--size减少size，更新 ++modCount。

 public boolean remove(Object o) { return map.remove(o)==PRESENT; } public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; } 

clear()方法

HashSet的clear方法内部调用HashMap的clear方法，在HashMap的内部clear当中就是直接把HashMap的桶的值的每个下标的值为null就可以了，估计内部会进行垃圾回收？

 public void clear() { map.clear(); } public void clear() { Node<K,V>[] tab; modCount++; if ((tab = table) != null && size > 0) { size = 0; for (int i = 0; i < tab.length; ++i) tab[i] = null; } } 

迭代器

在java的集合对象中，迭代器的实现是非常巧妙的部分，这块内容各位如果真心想了解一定好好看看，我尽量保证能够将这个过程讲解清楚。
HashSet的iterator()方法内部通过HashMap的keySet()方法，核心分析如下：

• 在keySet()方法当中，我们通过构造函数创建一个KeySet的类对象并调用方法iterator()。

• 在方法iterator()当中会创建KeyIterator对象并返回这个对象

• 在创建KeyIterator对象的过程中，我们会先初始化父类HashIterator的对象，在初始化HashIterator类的过程当中我们会赋值hash桶并遍历hash桶找到第一个非空元素

• 执行HashSet的iterator方法会调用KeyIterator对象的next()方法，会把在初始化HashIterator对象的时候第一个非空元素进行返回，然后按照下面的顺序进行遍历

• 遍历的过程为先遍历第一个非空hash桶的所有元素，如果遍历完这个hash桶那么就找下一个非空的hash桶继续遍历，所有整个next过程是按照桶的顺序进行遍历的

public Iterator<E> iterator() { return map.keySet().iterator(); } public Set<K> keySet() { Set<K> ks = keySet; if (ks == null) { ks = new KeySet(); keySet = ks; } return ks; } final class KeySet extends AbstractSet<K> { public final int size() { return size; } public final void clear() { HashMap.this.clear(); } public final Iterator<K> iterator() { return new KeyIterator(); } public final boolean contains(Object o) { return containsKey(o); } public final boolean remove(Object key) { return removeNode(hash(key), key, null, false, true) != null; } public final Spliterator<K> spliterator() { return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super K> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } } } final class KeyIterator extends HashIterator implements Iterator<K> { public final K next() { return nextNode().key; } } abstract class HashIterator { Node<K,V> next; // next entry to return Node<K,V> current; // current entry int expectedModCount; // for fast-fail int index; // current slot HashIterator() { expectedModCount = modCount; Node<K,V>[] t = table; current = next = null; index = 0; if (t != null && size > 0) { // advance to first entry do {} while (index < t.length && (next = t[index++]) == null); } } public final boolean hasNext() { return next != null; } final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; } public final void remove() { Node<K,V> p = current; if (p == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); current = null; K key = p.key; removeNode(hash(key), key, null, false, false); expectedModCount = modCount; } } 

关键点

HashSet的实现支持null的key，同时HashSet的内部不支持重复的key，最后一定好好研究iterator。