标签：
1 public class HashSet<E> 2 extends AbstractSet<E> 3 implements Set<E>, Cloneable, java.io.Serializable
我们看到HashSet继承了AbstractSet抽象类，并实现了Set、Cloneable、Serializable接口。AbstractSet是一个抽象类，对一些基础的set操作进行封装。继续来看下Set接口的定义：
1 public interface Set<E> extends Collection<E> { 2 // Query Operations 3 int size(); 4 boolean isEmpty(); 5 boolean contains(Object o); 6 Iterator<E> iterator(); 7 Object[] toArray(); 8 <T> T[] toArray(T[] a); 9 // Modification Operations 10 boolean add(E e); 11 boolean remove(Object o); 12 // Bulk Operations 13 boolean containsAll(Collection<?> c); 14 boolean addAll(Collection<? extends E> c); 15 boolean retainAll(Collection<?> c); 16 boolean removeAll(Collection<?> c); 17 void clear(); 18 // Comparison and hashing 19 boolean equals(Object o); 20 int hashCode(); 21 }
发现了什么，Set接口和java.util.List接口一样也实现了Collection接口，但是Set和List所不同的是，Set没有get等跟下标先关的一些操作方法，那怎么取值呢？Iterator还记得吗，使用迭代器对不对。（不明白的回去看Iterator讲解）
2.底层存储
1 // 底层使用HashMap来保存HashSet的元素 2 private transient HashMap<E,Object> map; 3 4 // Dummy value to associate with an Object in the backing Map 5 // 由于Set只使用到了HashMap的key，所以此处定义一个静态的常量Object类，来充当HashMap的value 6 private static final Object PRESENT = new Object();
看到这里就明白了，和我们前面说的一样，HashSet是用HashMap来保存数据，而主要使用到的就是HashMap的key。
看到private static final Object PRESENT = new Object();不知道你有没有一点疑问呢。这里使用一个静态的常量Object类来充当HashMap的value，既然这里map的value是没有意义的，为什么不直接使用null值来充当value呢？比如写成这样子private final Object PRESENT = null;我们都知道的是，Java首先将变量PRESENT分配在栈空间，而将new出来的Object分配到堆空间，这里的new Object()是占用堆内存的（一个空的Object对象占用8byte），而null值我们知道，是不会在堆空间分配内存的。那么想一想这里为什么不使用null值。想到什么吗，看一个异常类java.lang.NullPointerException， 噢买尬，这绝对是Java程序员的一个噩梦，这是所有Java程序猿都会遇到的一个异常，你看到这个异常你以为很好解决，但是有些时候也不是那么容易解决，Java号称没有指针，但是处处碰到NullPointerException。所以啊，为了从根源上避免NullPointerException的出现，浪费8个byte又怎么样，在下面的代码中我再也不会写这样的代码啦if (xxx == null) { ... } else {....}，好爽。
3.构造方法
1 /** 2 * 使用HashMap的默认容量大小16和默认加载因子0.75初始化map，构造一个HashSet 3 */ 4 public HashSet() { 5 map = new HashMap<E,Object>(); 6 } 7 8 /** 9 * 构造一个指定Collection参数的HashSet，这里不仅仅是Set，只要实现Collection接口的容器都可以 10 */ 11 public HashSet(Collection<? extends E> c) { 12 map = new HashMap<E,Object>(Math. max((int) (c.size()/.75f) + 1, 16)); 13 // 使用Collection实现的Iterator迭代器，将集合c的元素一个个加入HashSet中 14 addAll(c); 15 } 16 17 /** 18 * 使用指定的初始容量大小和加载因子初始化map，构造一个HashSet 19 */ 20 public HashSet( int initialCapacity, float loadFactor) { 21 map = new HashMap<E,Object>(initialCapacity, loadFactor); 22 } 23 24 /** 25 * 使用指定的初始容量大小和默认的加载因子0.75初始化map，构造一个HashSet 26 */ 27 public HashSet( int initialCapacity) { 28 map = new HashMap<E,Object>(initialCapacity); 29 } 30 31 /** 32 * 不对外公开的一个构造方法（默认default修饰），底层构造的是LinkedHashMap，dummy只是一个标示参数，无具体意义 33 */ 34 HashSet( int initialCapacity, float loadFactor, boolean dummy) { 35 map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor); 36 }
从构造方法可以很轻松的看出，HashSet的底层是一个HashMap，理解了HashMap后，这里没什么可说的。只有最后一个构造方法有写区别，这里构造的是LinkedHashMap，该方法不对外公开，实际上是提供给LinkedHashSet使用的，而第三个参数dummy是无意义的，只是为了区分其他构造方法。
4.增加和删除
/** * 利用HashMap的put方法实现add方法 */ public boolean add(E e) { return map .put(e, PRESENT)== null; } /** * 利用HashMap的remove方法实现remove方法 */ public boolean remove(Object o) { return map .remove(o)==PRESENT; } /** * 添加一个集合到HashSet中，该方法在AbstractCollection中 */ public boolean addAll(Collection<? extends E> c) { boolean modified = false; // 取得集合c迭代器Iterator Iterator<? extends E> e = c.iterator(); // 遍历迭代器 while (e.hasNext()) { // 将集合c的每个元素加入到HashSet中 if (add(e.next())) modified = true; } return modified; } /** * 删除指定集合c中的所有元素，该方法在AbstractSet中 */ public boolean removeAll(Collection<?> c) { boolean modified = false; // 判断当前HashSet元素个数和指定集合c的元素个数，目的是减少遍历次数 if (size() > c.size()) { // 如果当前HashSet元素多，则遍历集合c，将集合c中的元素一个个删除 for (Iterator<?> i = c.iterator(); i.hasNext(); ) modified |= remove(i.next()); } else { // 如果集合c元素多，则遍历当前HashSet，将集合c中包含的元素一个个删除 for (Iterator<?> i = iterator(); i.hasNext(); ) { if (c.contains(i.next())) { i.remove(); modified = true; } } } return modified; }
5.是否包含
1 /** 2 * 利用HashMap的containsKey方法实现contains方法 3 */ 4 public boolean contains(Object o) { 5 return map .containsKey(o); 6 } 7 8 /** 9 * 检查是否包含指定集合中所有元素，该方法在AbstractCollection中 10 */ 11 public boolean containsAll(Collection<?> c) { 12 // 取得集合c的迭代器Iterator 13 Iterator<?> e = c.iterator(); 14 // 遍历迭代器，只要集合c中有一个元素不属于当前HashSet，则返回false 15 while (e.hasNext()) 16 if (!contains(e.next())) 17 return false; 18 return true; 19 }
由于HashMap基于hash表实现，hash表实现的容器最重要的一点就是可以快速存取，那么HashSet对于contains方法，利用HashMap的containsKey方法，效率是非常之快的。在我看来，这个方法也是HashSet最核心的卖点方法之一。
6.容量检查
1 /** 2 * Returns the number of elements in this set (its cardinality). 3 * 4 * @return the number of elements in this set (its cardinality) 5 */ 6 public int size() { 7 return map .size(); 8 } 9 10 /** 11 * Returns <tt>true</tt> if this set contains no elements. 12 * 13 * @return <tt> true</tt> if this set contains no elements 14 */ 15 public boolean isEmpty() { 16 return map .isEmpty(); 17 }
1 /** 2 * Returns an iterator over the elements in this set. The elements 3 * are returned in no particular order. 4 * 5 * @return an Iterator over the elements in this set 6 * @see ConcurrentModificationException 7 */ 8 public Iterator<E> iterator() { 9 return map .keySet().iterator(); 10 }
我cha，咋回事，HashSet的iterator()方法竟然也是利用HashMap实现的，我们去看看HashMap的keySet()方法是什么鬼。
1 public Set<K> keySet() { 2 Set<K> ks = keySet; 3 return (ks != null ? ks : (keySet = new KeySet())); 4 }
HashMap的keySet()方法的返回值竟然是一个Set，具体实现是一个叫KeySet的东东，KeySet又是什么鬼。
1 private final class KeySet extends AbstractSet<K> { 2 public Iterator<K> iterator() { 3 return newKeyIterator(); 4 } 5 public int size() { 6 return size ; 7 } 8 public boolean contains(Object o) { 9 return containsKey(o); 10 } 11 public boolean remove(Object o) { 12 return HashMap.this.removeEntryForKey(o) != null; 13 } 14 public void clear() { 15 HashMap. this.clear(); 16 } 17 }
哦，KeySet是一个实现了AbstractSet的HashMap的内部类。而KeySet的iterator()方法返回的是一个newKeyIterator()方法，好绕好绕，头晕了。
1 Iterator<K> newKeyIterator() { 2 return new KeyIterator(); 3 }
newKeyIterator()方法返回的又是一个KeyIterator()方法，what are you 弄啥嘞？
1 private final class KeyIterator extends HashIterator<K> { 2 public K next() { 3 return nextEntry().getKey(); 4 } 5 }
好吧，不想说什么了，继续往下看吧。
1 private abstract class HashIterator<E> implements Iterator<E> { 2 // 下一个需要返回的节点 3 Entry<K,V> next; // next entry to return 4 int expectedModCount ; // For fast-fail 5 int index ; // current slot 6 // 当前需要返回的节点 7 Entry<K,V> current;// current entry 8 9 HashIterator() { 10 expectedModCount = modCount ; 11 if (size > 0) { // advance to first entry 12 Entry[] t = table; 13 // 初始化next参数，将next赋值为HashMap底层的第一个不为null节点 14 while (index < t.length && ( next = t[index ++]) == null) 15 ; 16 } 17 } 18 19 public final boolean hasNext() { 20 return next != null; 21 } 22 23 final Entry<K,V> nextEntry() { 24 if (modCount != expectedModCount) 25 throw new ConcurrentModificationException(); 26 // 取得HashMap底层数组中链表的一个节点 27 Entry<K,V> e = next; 28 if (e == null) 29 throw new NoSuchElementException(); 30 31 // 将next指向下一个节点，并判断是否为null 32 if ((next = e.next) == null) { 33 Entry[] t = table; 34 // 如果为null，则遍历真个数组，知道取得一个不为null的节点 35 while (index < t.length && ( next = t[index ++]) == null) 36 ; 37 } 38 current = e; 39 // 返回当前节点 40 return e; 41 } 42 43 public void remove() { 44 if (current == null) 45 throw new IllegalStateException(); 46 if (modCount != expectedModCount) 47 throw new ConcurrentModificationException(); 48 Object k = current.key ; 49 current = null; 50 HashMap. this.removeEntryForKey(k); 51 expectedModCount = modCount ; 52 } 53 54 }
1 private abstract class LinkedHashIterator<T> implements Iterator<T> { 2 // header.after为LinkedHashMap双向链表的第一个节点，因为LinkedHashMap的header节点不保存数据 3 Entry<K,V> nextEntry = header .after; 4 // 最后一次返回的节点 5 Entry<K,V> lastReturned = null; 6 7 /** 8 * The modCount value that the iterator believes that the backing 9 * List should have. If this expectation is violated, the iterator 10 * has detected concurrent modification. 11 */ 12 int expectedModCount = modCount; 13 14 public boolean hasNext() { 15 return nextEntry != header; 16 } 17 18 public void remove() { 19 if (lastReturned == null) 20 throw new IllegalStateException(); 21 if (modCount != expectedModCount) 22 throw new ConcurrentModificationException(); 23 24 LinkedHashMap. this.remove(lastReturned .key); 25 lastReturned = null; 26 expectedModCount = modCount ; 27 } 28 29 Entry<K,V> nextEntry() { 30 if (modCount != expectedModCount) 31 throw new ConcurrentModificationException(); 32 if (nextEntry == header) 33 throw new NoSuchElementException(); 34 35 // 将要返回的节点nextEntry赋值给lastReturned 36 // 将nextEntry赋值给临时变量e（因为接下来nextEntry要指向下一个节点） 37 Entry<K,V> e = lastReturned = nextEntry ; 38 // 将nextEntry指向下一个节点 39 nextEntry = e.after ; 40 // 放回当前需返回的节点 41 return e; 42 } 43 }
给jdk写注释系列之jdk1.6容器(6)-HashSet源码解析&Map迭代器
标签：
原文地址：http://www.cnblogs.com/tstd/p/5064032.html
