//这一段就告诉了我们hashset底层就是用hashMap来存储的，那我们对HashMap就挺熟悉了，能够存储null值，不是按顺序存储也可以理解，因为HashMap中元素的位置就会变动。
这里hashSet的第一个特性就是无序，现在就差不多知道了为什么无序了把。
This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration 
order of the set; in particular, it does not guarantee 
that the order will remain constant over time. This class permits the null element. 

//讲解一些特点，在add、remove等操作上性能好，查询元素时的效率跟hashset中存放的元素个数还有map的bucket数量成比例，所以不要讲inital capacity设置的太高，也不能讲加载印子设置的太低了
This class offers constant time performance for the basic operations (add, remove, contains and size), assuming the hash function disperses the elements properly among
 the buckets. Iterating over this set requires time proportional to the sum of the HashSet instance‘s size (the number of elements) plus the "capacity" of the backing HashMap instance (the number of buckets). Thus, it‘s very
 important not to set the initial capacity too high (or the load factor too low) if iteration performance is important. 

//非线程安全的，如果多个线程访问他并改变了内部结构，比如add、delete等操作，会发生快速失败，所以解决的方案就是set对象上加同步锁。或者在创建的时候，用Collections.SynchronizedSet这个方法修饰它。还有更下面那些就是解释快速失败是干什么的，等一些东西。
Note that this implementation is not synchronized. If multiple threads access a hash set concurrently, and at least one of the threads modifies the set, it must be 

synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should 
be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the set:

Set s = Collections.synchronizedSet(new HashSet(...));The iterators returned by this class‘s iterator method are fail-fast: if the set is modified at any time after the iterator is created, in any way except through the iterator‘s own remove method, the Iterator throws a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future. 

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs. 

This class is a member of the Java Collections Framework.

Since: 

    /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
//一个空的构造函数，new一个hashMap对象实例出来。默认初始容量是16，加载因子是0.75，这些都市HashMap的知识

    public HashSet() {
        map = new HashMap<>();
    }
//讲一个新的collection转换为一个HashSet集合。这个构造和空构造函数都市规定需要写的。
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
//自己初始化容量和加载因子的大小
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
//初始化容量大小，加载因子用默认的
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
//这个就是那个default权限的构造方法，只能在包内可见，作用是将其能够适用于LinkedHashMap。我们只讲解了HashMap，LinkedHashMap很简单，只要理解了他的数据结构，你就懂了，这里先不做讲解，
可以关注我后续的文章或者自己尝试去看看。
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

//这个方法就可以得知HashSet添加的元素是不能够重复的，原因是什么呢，set将每次添加的元素度是通过map中的key来保存，当有相同的key时，也就是添加了相同的元素，那么map会讲value给覆盖掉，而key还是原来的key
，所以，这就是set不能够重复的原因。这个方法的PRESENT可以看下面的注释，
//返回值的式子的意思很好理解，map中增加元素是先通过key查找有没有相同的key值，如果有，则覆盖value，返回oldValue。没有，则创建一个新的entry，并且返回null值。如果key等于null，也会返回null值。
　　所以return会有一个==null的判断

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

//PERSENT:通过注释，可以知道这个一个假的值，为了符合map的key，value的方式才用到这个值。
    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

//map中通过key来移除对应的元素，如果有该key，会返回其value值，没有，则返回null
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

//HashMap中的remove，看一眼就懂了。
    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

//是否包含某值，也就是判断HashMap中是否有这个Key值。
    public boolean contains(Object o) {
        return map.containsKey(o);
    }
//HashMap中的containsKey方法
    public boolean containsKey(Object key) {
//也就是通过key能不能找得到其entry，找得到就说明有。找不到就没有
        return getEntry(key) != null;
    }

//非常简单，都市通过调用map的方法 
   public boolean isEmpty() {
        return map.isEmpty();
    }

//看set中有多少个元素，也就是看map中有多少个元素
    public int size() {
        return map.size();
    }

//可以重点看一下这个迭代器，这个迭代器在HashMap中就已经构建好了。
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }
//keySet这个方法也就是为了new一个KeySet这个类出来，来看看KeySet这个类
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }
//KeySet类是HashMap中的一个内部类，继承了AbstractSet，所以他也是一个set，其中就是一个写普通的操作，看一下这个newKeyIterator是什么
   private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }
//newKeyIterator
    Iterator<K> newKeyIterator()   {
        return new KeyIterator();
    }
//KeyIterator，重点来了，KeyIterator。看名字就知道，就对key进行迭代的迭代器，也就是为set量身打造的，因为set存放的元素就是存放在HashMap中的key，所以为了能够迭代set，HashMap
就实现了这个专门遍历key的迭代器，通过继承HashIterator，能够每次拿到nextEntry。也就能拿到对应的可以了，可以看下面的图，看下HashIterator有哪些方法就明白了
    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

//复制一个HashSet，但是只是复制原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();
        }
    }