Java HashSet源码解析

本解析源码来自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);
        }
    }