java集合（三）Set集合之HashSet详解

 

①：实现了Serializable接口，代表它支持序列化。
②：实现了Cloneable接口，代表它支持克隆，能够调用超类的clone（）方法进行浅拷贝。
③继承了AbstractSet抽象类，和ArrayList和LinkedList同样，在他们的抽象父类中，都提供了equals（）方法和hashCode（）方法。它们自身并不实现这两个方法，（可是ArrayList和LinkedList的equals（）实现不一样。你能够看个人关于ArrayList这一块的源码解析）这就意味着诸如和HashSet同样继承自AbstractSet抽象类的TreeSet、LinkedHashSet等，他们只要元素的个数和集合中元素相同，即便他们是AbstractSet不一样的子类，他们equals（）相互比较的后的结果仍然是true。下面给出的代码是JDK中的equals（）代码：
从JDK源码能够看出，底层并无使用咱们常规认为的利用hashcode（）方法求的值进行比较，而是经过调用AbstractCollection的containsAll（）方法，若是他们中元素彻底相同（与顺序无关），则他们的equals（）方法的比较结果就为true。

public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; //必须保证元素的个数相等。
        if (c.size() != size()) return false; try { //调用了AbstractCollection的方法。
            return containsAll(c); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } }

public boolean containsAll(Collection<?> c) { //只须要逐个判断集合是否包含其中的元素。
        for (Object e : c) if (!contains(e)) return false; return true; }

④实现了Set接口。

老规矩仍是先把总结放到上面：
①HashSet内部经过使用HashMap的键来存储集合中的元素，并且内部的HashMap的全部值
都是null。（由于在为HashSet添加元素的时候，内部HashMap的值都是PRESENT），而PRESENT在实例域的地方直接初始化了，并且不容许改变。
②HashSet对外提供的全部方法内部都是经过HashMap操做完成的，因此，要真正理解HashSet的实现，只须要把HashMap的原理理解便可。我也对HashMap作了分析。传送门：
③因此，若是你对HashMap很熟悉的话，学习HastSet的源码垂手可得！

1：首先咱们先看看HashSet的有哪些实例域:（是否是少了不少，并且还简单(⊙o⊙)…）

//序列化ID
    static final long serialVersionUID = -5024744406713321676L; //底层使用了HashMap存储数据。
    private transient HashMap<E,Object> map; //用来填充底层数据结构HashMap中的value，由于HashSet只用key存储数据。
    private static final Object PRESENT = new Object();

2：老规矩，仍是先看一下它们的构造方法：
构造器的实现基本都是使用HashMap

//其实只是实例化了HashMap (⊙o⊙)…（不懂的童鞋，能够看个人另外一篇关于HashMap的源码解析）
    public HashSet() { map = new HashMap<>(); }

//仍是关于
    public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16)); addAll(c); } //调用的AbstractCollection中的方法。而后调用HashSet的add（）方法把集合中的 //全部元素添加到了集合中。（由于）
    public boolean addAll(Collection<? extends E> c) { boolean modified = false; for (E e : c) if (add(e)) modified = true; return modified; } //底层并不支持直接在AbstractCollection类中调用add（）方法，而是调用add（）方法 //的自身实现。
public boolean add(E e) { throw new UnsupportedOperationException(); }

//初始化HashSet仍然是关于HashMap的知识。
    public HashSet(int initialCapacity) { map = new HashMap<>(initialCapacity); }

//初始化HashSet仍然是关于HashMap的知识。
    public HashSet(int initialCapacity, float loadFactor) { map = new HashMap<>(initialCapacity, loadFactor); }

//此次初始化底层使用了LinkedHashMap实现。
    HashSet(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadFactor); }

3：添加新的元素：

//底层仍然利用了HashMap键进行了元素的添加。 //在HashMap的put()方法中，该方法的返回值是对应HashMap中键值对中的值，而值老是PRESENT, //该PRESENT一直都是private static final Object PRESENT = new Object(); //PRESENT只是初始化了，并不能改变，因此PRESENT的值一直为null。 //因此只要插入成功了，put（）方法返回的值老是null。
    public boolean add(E e) { return map.put(e, PRESENT)==null; }

4：删除一个元素：

 

//该方法底层实现了仍然使用了map的remove（）方法。 //map的remove（）方法的返回的是被删除键对应的值。（在HashSet的底层HashMap中的全部 //键值对的值都是PRESENT）
    public boolean remove(Object o) { return map.remove(o)==PRESENT; }

5：清空方法

public void clear() { map.clear(); }

6：克隆方法（浅克隆）
底层仍然使用了Object的clone（）方法，获得的Object对象，并把它强制转化为HashSet<E>,而后把它的底层的HashMap也克隆一份（调用的HashMap的clone（）方法），并把它赋值给newSet，最后返回newSet便可。

@SuppressWarnings("unchecked") 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(e); } }

7：是否包含某个元素

底层仍然使用了HashMap的containsKey（）方法（由于HashSet只用到了HashMap的键）一样的话重复了好多遍 ……….(艹皿艹 )

public boolean contains(Object o) { return map.containsKey(o); }

8：判断是否为空
仍然调用HashMap的方法。

public boolean isEmpty() { return map.isEmpty(); }

9：生成一个迭代器

仍然使用了HashMap的键的迭代器

public Iterator<E> iterator() { return map.keySet().iterator(); }

10： 统计HashSet中包含元素的个数

仍是调用HashMap的实现。

public int size() { return map.size(); }

11：把HashSet写入流中（也就是序列化）
在HashSet序列化实现中，仍然是把HashMap中的属性写入流中。（由于HashSet中真正存储数据的数据结构是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 //把HashMap的容量写入流中。
 s.writeInt(map.capacity()); //把HashMap的装载因子写入流中。
 s.writeFloat(map.loadFactor()); //把HashMap中键值对的个数写入流中。
 s.writeInt(map.size()); // 按正确的顺序把集合中的全部元素写入流中。
        for (E e : map.keySet()) s.writeObject(e); }

12：从流中读取数据，组装HashSet（反序列化）

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in any hidden serialization magic
 s.defaultReadObject(); // Read capacity and verify non-negative.
        int capacity = s.readInt(); if (capacity < 0) { throw new InvalidObjectException("Illegal capacity: " + capacity); } // Read load factor and verify positive and non NaN.
        float loadFactor = s.readFloat(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) { throw new InvalidObjectException("Illegal load factor: " + loadFactor); } // Read size and verify non-negative.
        int size = s.readInt(); if (size < 0) { throw new InvalidObjectException("Illegal size: " + size); } // Set the capacity according to the size and load factor ensuring that // the HashMap is at least 25% full but clamping to maximum capacity.
        capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f), HashMap.MAXIMUM_CAPACITY); //HashMap中构建哈希桶数组是在第一个元素被添加的时候才构建，因此在构建以前检查它, // 调用HashMap.tableSizeFor来计算实际分配的大小, // 检查Map.Entry []类，由于它是最接近的公共类型实际建立的内容。
 SharedSecrets.getJavaOISAccess() .checkArray(s, Map.Entry[].class,HashMap.tableSizeFor(capacity)); //建立HashMap。
        map = (((HashSet<?>)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) : new HashMap<E,Object>(capacity, loadFactor)); // 按写入流中的顺序再把元素依次读取出来放到map中。
        for (int i=0; i<size; i++) { @SuppressWarnings("unchecked") E e = (E) s.readObject(); map.put(e, PRESENT); } }