HashSet浅析原理学习

最近在研究集合的原理,从collection开始向下梳理,所以一开始就碰到了hashset,打开hashset一看,这小子就是个hashmap,让我想起小时候带的奥特曼面具,哎!出门左转吧去看hashmap了!!!

HashSet

implements Serializable, Cloneable, Iterable<E>, Collection<E>, Set<E>

方法摘要

boolean add(E e) 
            如果此 set 中尚未包含指定元素，则添加指定元素。 
 void clear() 
            从此 set 中移除所有元素。 
 Object clone() 
            返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。 
 boolean contains(Object o) 
            如果此 set 包含指定元素，则返回 true。 
 boolean isEmpty() 
            如果此 set 不包含任何元素，则返回 true。 
 Iterator<E> iterator() 
            返回对此 set 中元素进行迭代的迭代器。 
 boolean remove(Object o) 
            如果指定元素存在于此 set 中，则将其移除。 
 int size() 
            返回此 set 中的元素的数量（set 的容量）。

源码

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

    private transient HashMap<E,Object> map;

    //map的虚拟value
    private static final Object PRESENT = new Object();

    //hashset构造器内置一个map集合
    public HashSet() {
    map = new HashMap<E,Object>();
    }

    //构造新集合到set中
    //计算初始化容量,否则默认容量
    public HashSet(Collection<? extends E> c) {
    map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
    }

    //自定义初始化容量和加载因子
    public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<E,Object>(initialCapacity, loadFactor);
    }

    //自定义初始容量默认加载因子
    public HashSet(int initialCapacity) {
    map = new HashMap<E,Object>(initialCapacity);
    }


    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
    }

    //返回一个迭代器
    public Iterator<E> iterator() {
    return map.keySet().iterator();
    }

    //以下常用方法都是hashmap的方法
    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();
    }


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


    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 (Iterator i=map.keySet().iterator(); i.hasNext(); )
            s.writeObject(i.next());
    }


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

总结

1. hashset集合内置hashmap,使用了key的存储机制,虚拟value值,根本上是一个map集合
2. hashset允许null,equlas和hashcode方法和hashset一致
3. hashset不允许重复元素,原理上hashcode相同的key,新key替换旧key所以看上去是无法存入,其实是没有发生改变
4. hashset中所有的方法源于hashmap
5. hashset线程不同步与hashmap相同

综上描述要理解hashset,需要去研究hashmap附上hashmap原理解析博客一篇

http://blog.youkuaiyun.com/ns_code/article/details/36034955