【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);        }    }}}