HashSet与HashMap底层实现

点它 : 这个大佬写的更详细，更易懂

1.HashSet底层是基于HashMap实现的

    public class HashSet<E>  
        extends AbstractSet<E>  
        implements Set<E>, Cloneable, java.io.Serializable  
    {  
        static final long serialVersionUID = -5024744406713321676L;  
      
        // 底层使用HashMap来保存HashSet中所有元素。  
        private transient HashMap<E,Object> map;  
          
        // 定义一个虚拟的Object对象作为HashMap的value，将此对象定义为static final。  
        private static final Object PRESENT = new Object();  
      
        /** 
         * 默认的无参构造器，构造一个空的HashSet。 
         *  
         * 实际底层会初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。 
         */  
        public HashSet() {  
        map = new HashMap<E,Object>();  
        }  
      
        /** 
         * 构造一个包含指定collection中的元素的新set。 
         * 
         * 实际底层使用默认的加载因子0.75和足以包含指定 
         * collection中所有元素的初始容量来创建一个HashMap。 
         * @param c 其中的元素将存放在此set中的collection。 
         */  
        public HashSet(Collection<? extends E> c) {  
        map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
        addAll(c);  
        }  
      
        /** 
         * 以指定的initialCapacity和loadFactor构造一个空的HashSet。 
         * 
         * 实际底层以相应的参数构造一个空的HashMap。 
         * @param initialCapacity 初始容量。 
         * @param loadFactor 加载因子。 
         */  
        public HashSet(int initialCapacity, float loadFactor) {  
        map = new HashMap<E,Object>(initialCapacity, loadFactor);  
        }  
      
        /** 
         * 以指定的initialCapacity构造一个空的HashSet。 
         * 
         * 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。 
         * @param initialCapacity 初始容量。 
         */  
        public HashSet(int initialCapacity) {  
        map = new HashMap<E,Object>(initialCapacity);  
        }  
      
        /** 
         * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 
         * 此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet的支持。 
         * 
         * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 
         * @param initialCapacity 初始容量。 
         * @param loadFactor 加载因子。 
         * @param dummy 标记。 
         */  
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
        map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
        }  
      
        /** 
         * 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。 
         *  
         * 底层实际调用底层HashMap的keySet来返回所有的key。 
         * 可见HashSet中的元素，只是存放在了底层HashMap的key上， 
         * value使用一个static final的Object对象标识。 
         * @return 对此set中元素进行迭代的Iterator。 
         */  
        public Iterator<E> iterator() {  
        return map.keySet().iterator();  
        }  
      
        /** 
         * 返回此set中的元素的数量（set的容量）。 
         * 
         * 底层实际调用HashMap的size()方法返回Entry的数量，就得到该Set中元素的个数。 
         * @return 此set中的元素的数量（set的容量）。 
         */  
        public int size() {  
        return map.size();  
        }  
      
        /** 
         * 如果此set不包含任何元素，则返回true。 
         * 
         * 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。 
         * @return 如果此set不包含任何元素，则返回true。 
         */  
        public boolean isEmpty() {  
        return map.isEmpty();  
        }  
      
        /** 
         * 如果此set包含指定元素，则返回true。 
         * 更确切地讲，当且仅当此set包含一个满足(o==null ? e==null : o.equals(e)) 
         * 的e元素时，返回true。 
         * 
         * 底层实际调用HashMap的containsKey判断是否包含指定key。 
         * @param o 在此set中的存在已得到测试的元素。 
         * @return 如果此set包含指定元素，则返回true。 
         */  
        public boolean contains(Object o) {  
        return map.containsKey(o);  
        }  
      
        /** 
         * 如果此set中尚未包含指定元素，则添加指定元素。 
         * 更确切地讲，如果此 set 没有包含满足(e==null ? e2==null : e.equals(e2))
         * 的元素e2，则向此set 添加指定的元素e。 
         * 如果此set已包含该元素，则该调用不更改set并返回false。 
         * 
         * 底层实际将将该元素作为key放入HashMap。 
         * 由于HashMap的put()方法添加key-value对时，当新放入HashMap的Entry中key 
         * 与集合中原有Entry的key相同（hashCode()返回值相等，通过equals比较也返回true）， 
         * 新添加的Entry的value会将覆盖原来Entry的value，但key不会有任何改变， 
         * 因此如果向HashSet中添加一个已经存在的元素时，新添加的集合元素将不会被放入HashMap中， 
         * 原来的元素也不会有任何改变，这也就满足了Set中元素不重复的特性。 
         * @param e 将添加到此set中的元素。 
         * @return 如果此set尚未包含指定元素，则返回true。 
         */  
        public boolean add(E e) {  
        return map.put(e, PRESENT)==null;  
        }  
      
        /** 
         * 如果指定元素存在于此set中，则将其移除。 
         * 更确切地讲，如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e， 
         * 则将其移除。如果此set已包含该元素，则返回true 
         * （或者：如果此set因调用而发生更改，则返回true）。（一旦调用返回，则此set不再包含该元素）。 
         * 
         * 底层实际调用HashMap的remove方法删除指定Entry。 
         * @param o 如果存在于此set中则需要将其移除的对象。 
         * @return 如果set包含指定元素，则返回true。 
         */  
        public boolean remove(Object o) {  
        return map.remove(o)==PRESENT;  
        }  
      
        /** 
         * 从此set中移除所有元素。此调用返回后，该set将为空。 
         * 
         * 底层实际调用HashMap的clear方法清空Entry中所有元素。 
         */  
        public void clear() {  
        map.clear();  
        }  
      
        /** 
         * 返回此HashSet实例的浅表副本：并没有复制这些元素本身。 
         * 
         * 底层实际调用HashMap的clone()方法，获取HashMap的浅表副本，并设置到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();  
            }  
        }  
    }  

2.HashMap的底层实现原理

2.1HashMap的介绍

HashMap是基于Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

2.2HashMap的底层是什么（个人理解，若有不对，请大佬指点）

HashMap的底层是一个（基于）哈希表（实现的）。

很多文章里都说HashMap的底层是数组+链表+红黑树，为什么这里说是一个哈希表？
因为哈希表是数组+链表的结合体（为什么没红黑树，因为红黑树是链表转换的）

• 什么是数组

数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。

• 什么是链表

链表是由一系列节点组成的元素集合。每个节点包含两部分，数据域item和指向一下个节点的指针next。通过节点之间相互连接，最终串联成一个链表

数组的特点：查询效率高，插入，删除效率低。
链表的特点：查询效率低，插入删除效率高。

• 什么是哈希表

是否有一种查询（寻址）容易，插入删除也容易的数据结构，
哈希表就是一个通过哈希函数来计算数据存储位置的数据结构

HashMap底层就是一个数组，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。

    /** 
     * The table, resized as necessary. Length MUST Always be a power of two. 
     */  
    transient Entry[] table;  
      
    static class Entry<K,V> implements Map.Entry<K,V> {  
        final K key;  
        V value;  
        Entry<K,V> next;  
        final int hash;  
        ……  
    }  
    
    Entry就是数组中的元素，每个Map.Entry就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

2.3HashMap的实现原理

首先有一个每个元素都是链表的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。

当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中

2.3.1代码学习

    public V put(K key, V value) {  
        // HashMap允许存放null键和null值。  
        // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。  
        if (key == null)  
            return putForNullKey(value);  
        // 根据key的hashCode重新计算hash值。  
        int hash = hash(key.hashCode());  
        // 搜索指定hash值所对应table中的索引。  
        int i = indexFor(hash, table.length);  
        // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。  
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
            Object k;  
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
                V oldValue = e.value;  
                e.value = value;  
                e.recordAccess(this);  
                return oldValue;  
            }  
        }  
        // 如果i索引处的Entry为null，表明此处还没有Entry。  
        // modCount记录HashMap中修改结构的次数  
        modCount++;  
        // 将key、value添加到i索引处。  
        addEntry(hash, key, value, i);  
        return null;  
    }  

hashmap代码中的重要字段

/**实际存储的key-value键值对的个数*/
transient int size;

/**阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，
threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/
int threshold;

/**负载因子，代表了table的填充度有多少，默认是0.75
加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。
所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
*/
final float loadFactor;

/**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，
如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
需要抛出异常ConcurrentModificationException*/
transient int modCount;

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了（这就是哈希冲突），那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。
HashMap通过链表来解决冲突。

HashMap 中定义了几个常量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 1 * 2^4 = 16
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

• DEFAULT_INITIAL_CAPACITY: 初始容量，也就是默认会创建 16 个箱子，箱子的个数不能太多或太少。如果太少，很容易触发扩容，如果太多，遍历哈希表会比较慢。
• MAXIMUM_CAPACITY: 哈希表最大容量，一般情况下只要内存够用，哈希表不会出现问题。
• DEFAULT_LOAD_FACTOR: 默认的负载因子。因此初始情况下，当键值对的数量大于 16 * 0.75 = 12 时，就会触发扩容。
• TREEIFY_THRESHOLD: 上文说过，如果哈希函数不合理，即使扩容也无法减少箱子中链表的长度，因此 Java 的处理方案是当链表太长时，转换成红黑树。这个值表示当某个箱子中，链表长度大于 8 时，会转化成树。
• UNTREEIFY_THRESHOLD: 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表。
• MIN_TREEIFY_CAPACITY: 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。

为什么需要扩容，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率

2.4.红黑树

红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树

• 性质1. 节点是红色或黑色。
• 性质2. 根节点是黑色。
• 性质3.所有叶子都是黑色。（叶子是NUIL节点）
• 性质4. 每个红色节点的两个子节点都是黑色。（从每个叶子到根的所有路径上- 不能有两个连续的红色节点）
• 性质5… 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

大家也可以看看这个文章: https://blog.csdn.net/yinbingqiu/article/details/60965080.