第二章 JAVA集合之HashSet源码浅析

     一.概况

        HashSet这个集合我们平时用的不是很多，但我们还是需要去了解他，先说一下HashSet的特点:

                  1.HashSet存取的值是不能重复的；

                  2.HashSet存取的值是无序的；

                  3.HashSet不是线现安全的；

                  4.HashSet允许存取null；这些特点也都是由HashSet的源码决定的。

        HashSet其实就是对HashMap的一个封装，对HashSet的操作其实就是在对HashMap的操作，HashSet用来存储值是用HashMap的key来存储的，这个HashMap所有的key对应的value是一个无用的Object对象。现在想想HashSet的特点就不难理解了。如果你没有看过HashMap的源码，建议你先看一下HashMap的源码后，再来看看HashSet的源码。

    二.HashSet的数据结构

             

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
    //HashSet其实就是对这个HashMap的封装，所有对HashSet的操作就是对这个HashMap的操作
    private transient HashMap<E,Object> map;

    //当对HashSet进行存值操作的时候，就将这个Object对象存入到HashMap的value中
    private static final Object PRESENT = new Object();

    //对HashMap进行初始化就是初始化一个HashMap
    public HashSet() {
        map = new HashMap<>();
    }

    //带有集合参数的构造方法，将c这个集合转变为数组后存储到HashSet中
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    /*
	*带有初始容量和加载因子的构造方法，
	*即初始的是带有初始容量和加载因子的HashMap
	*/
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    //带有初始容量的构造方法，默认的加载因子是0.75
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

    //构造的是一个LinkedHashMap
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }
}

     我们看到HashSet继承了AbstractSet，实现了Set接口，虽然HashSet是对HashMap的一种封装，但是HashSet却不是和HashMap同宗共组的，HahsMap实现的是map接口；HashSet还实现了Cloneable和Serializable接口，这说明HashSet能被序列号和浅拷贝。HashSet中的map属性前面有一个关键字 transient，transient修饰的关键字是不能在序列化的时候是不被保存的，也就是说你用流来传输HashSet的时候，再反序列化HashSet，你是获取不到map对应的值得，那我们怎么在反序列化后拿到map对应的值得呢，HashSet是有专门的方法来进行序列化和反序列化的。

   

    三.HashSet的API源码          

 //HashSet的遍历方法，其实就是对HashMap的key进行遍历
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    //获取HashSet的大小方法，获取的就是HashMap的大小
    public int size() {
        return map.size();
    }

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

    //判断HashSet是否包含某一个对象，也就是判断HashMap中是否有相等的key值
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

        /*
	 *向HashSet里面存值，也就是像HashMap里面存值，
	 *只是这个值只是以key存入HashMap中，而key对应的value就是一个Object对象
	 *当存入的key值已经存在的时候，HashMap会替换key所对应的value，但key值保持不变
	 *所以也符合HashSet的不可重复性
	 */
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    //移除HashSet里面的值
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

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

    //HashSet的克隆
    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的map属性被transient关键字修饰了，
	*导致map属性不能被序列化和反序列化，
	*所以得用方法来专门来对map属性来做序列化和反序列化
	*/     
    //序列化
    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);
        }
    }

    四.总结

       无论从HashSet的初始化还是从HashSet的API操作来看，HashSet的所有操作都是在围绕着HashMap来展开的，但HashSet的特点和HashMap又有所不同，这是因为HashSet存取值是存取在HashMap的key里面的，而不管key对应的value什么事，所以HashSet的特点就是HashMap的key的特点，HashMap的key的特点是无序，不可重复的。最后需要注意的一点是要视情况重写保存在HashSet对象的hashCode方法和equal方法，以保证对象的唯一性。

       参考博客：http://www.cnblogs.com/ITtangtang/p/3948538.html

      博客专栏终于开通了，我会将java集合这块博客专栏写好的，一定要坚持写完，也要写好。