【JDK源码阅读10-util】Set接口---HashSet

HashSet

一、类继承关系

  

public class HashSet<E>
                  extends AbstractSet<E>
                  implements Set<E>, Cloneable, Serializable

特点：

         1   HashSet实现Set 接口，由哈希表支持，底层是一个HashMap 实例。

      2   插入元素顺序是无序的(由HashCode决定)。

      3   不能添加重复的元素(即添加重复元素的时候会返回false，添加失败),允许添加null 元素。 

      4  HashSet是非线程同步的，实现同步的操作：         

        Set set = Collections.synchronizedSet(new HashSet());

二、HashSet 两个重要特性

    学习HashSet一定要清楚，其底层实现是一个HashMap实例，其所有的添加删除等基本操作都是调用HashMap实例中的方法进行操作的；

 这也就能理解HashSet的两个重要特性：无序性  和 不可重复性。

          即：

 HashSet 底层是由HashMap 实现的:即将Set集合的值作为Map集合的键，而HashMap中 值不用考虑，可以设置个固定值PRESENT。对应关系如下：

map集合的键《《---》》》Set集合

而我们指知道，map集合的键是不能重复的(键key可以为null)，这也就是解释了HashSet集合允许有null元素集合，且不能有重复元素的原因。  

三、HashSet 中add（）方法在算法题中的应用

HashSet 最有用的方法就是set.add(Element e)这个方法，可用来判断原集合中是否含有将要添加的元素e：

 如果含有重复元素e,就返回false,添加失败；否则添加成功返回true。

The fucking source code:

package jdk_util;

import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class JDK_HashSet {

	/**
	 * HashSet底层由于是HashMap实现的，即HashSet集合的值被当做HashMap的键，HashMap值设为定值:伪值--PRESENT
	 * 由于HashMap键允许为null,不能重复；所以HashSet集合允许有null元素，且不能有重复元素。
	 * 
	 *HashSet类是Set的主要实现类，由哈希表支持(实际上是一个HashMap实例)。它不能确保set集合中元素的迭代顺序；
	 *特别是不能确保顺序不变，HashSet允许null元素存在。

	 *假定哈希函数正确地将这些元素分配在桶中。
	 *迭代set集合需要的时间与HashSet实例的大小(元素数量)和底层HashMap实例(桶的数量)的"容量"成比例。
	 *因此，如果迭代性能很重要，就不要将集合初始容量设置太高(即加载因子设置太低)。
	 *
	 * 注意，HashSet是非同步，即非线程安全的。  
	 * 			Set s = Collections.synchronizedSet(new HashSet(...));
	 * 
	 * HashSet 底层是由HashMap 实现的:即将Set集合的值作为Map集合的键。
	 *     而我们指知道，map集合的键是不能重复的(键值可以为null),
	 *     map集合的键《《---》》》Set集合，
	 *     这也就是解释了HashSet集合允许有null元素集合，且不能有重复元素的原因
	 *    而值不用考虑，可以设置个固定值PRESENT
	 */

	public static class HashSet<E>
	    extends AbstractSet<E>
	    implements Set<E>, Cloneable, java.io.Serializable
	{
	    static final long serialVersionUID = -5024744406713321676L;

	    //创建一个HashMap 对象。
	    //transient防止对象被序列化；
	    //由此可看出 HashSet 底层是由HashMap 实现的:即将Set集合的值作为Map集合的键。
	    private transient HashMap<E,Object> map;

	    //用来填充HashMap的值对象(键对象由set集合填充)
	    private static final Object PRESENT = new Object();

	    //构造器：创建空的Set集合；
	    //底层的HashMap的初始化容量为16，加载因子为0.75
	    public HashSet() {
	        map = new HashMap<>();
	    }

	    //创建包含集合对象c的Set集合；
	    //底层的加载因子仍然是0.75；大小不小于16
	    public HashSet(Collection<? extends E> c) {
	        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
	        addAll(c);
	    }

	    //指定初始化容量和加载因子的HashSet;底层即为HashMap
	    public HashSet(int initialCapacity, float loadFactor) {
	        map = new HashMap<>(initialCapacity, loadFactor);
	    }

	    //指定初始化容量HashSet;用HashMap实现,加载因子的默认为0.75
	    public HashSet(int initialCapacity) {
	        map = new HashMap<>(initialCapacity);
	    }

	    //构建一个链式hashSet，指定初始化容量和加载因子；
	    //这个构造器只用来提供给LinkedHashSet使用；
	    //底层的HashMap实例是一个具有指定初始化容量和加载因子的LinkedHashMap
	    //dummy：？
	    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
	        map = new LinkedHashMap<>(initialCapacity, loadFactor);
	    }

	    //返回set集合迭代器，顺序是无序的
	    //底层实现是返回map集合的keySet集合的遍历(再次证明hashset集合值作为hashmap集合的键)
	    public Iterator<E> iterator() {
	        return map.keySet().iterator();
	    }

	    //返回set集合的大小；
	    //实际上是map集合的大小
	    public int size() {
	        return map.size();
	    }

	    //判断是否非空 
	    public boolean isEmpty() {
	        return map.isEmpty();
	    }

	    //判断是否包含元素o,实际上是在map集合中keySet寻找，是否有这样的键值o
	    public boolean contains(Object o) {
	        return map.containsKey(o);
	    }

	    //添加，若待添加的值存在，就返回false
	    //原理：调用的是hashMap.put(key,value);
	    //hashMap中添加元素是先判断键所在位置是否有元素，有的话就将新值value覆盖旧值，并返回旧值；
	    //                      若所在位置没有元素，就加入value值到指定key处，并返回null
	    //这也就解释了hashset中不能有重复元素的原因，因为不能添加重复元素
	    public boolean add(E e) {
	        return map.put(e, PRESENT)==null;//若添加后值==null，说明原来key处无值，就返回true
	        							       //否则返回false
	    }

	    //移除指定元素o
	    public boolean remove(Object o) {
	        return map.remove(o)==PRESENT;
	    }

	    //清空集合
	    public void clear() {
	        map.clear();
	    }

	    //浅复制
	    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();
	        }
	    }

	    //序列化：将HashSet实例保存在流中
	    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);
	        }
	    }
	}

}