Collection之Set

Collection之List：点击打开链接

同List集合一样，Set集合继承了了Collection接口。

HashSet同TreeSet是我们经常使用的两个类。

HashSet跟TreeSet都继承了 AbstractSet这个抽象类：但是TreeSet实现了SortedSet这个接口：

所以TreeSet是有序的（因为它是一个红黑树的数据结构，是一种平衡二叉树（AVL树），下面会说到）

HashSet

我所知道Set一大特征是去重，集合中不会有相同的对象（如果存储在HashSet中的两个对象hashCode方法的值相同equals方法返回的结果是true，那么HashSet认为这两个元素是相同元素，只存储一个（重复元素无法存入））

add方法：

这里e是我们要存放的数据，PRESENT是一个对象，在HashSet中套了一个Map,使用Map的Key存值,Value存放一个固定的Object,这是适配器模式(理解为Set的操作是适配到Map上完成的。设计模式我最了解还是单例模式，适配器模式只是看过一点，那就不说太多).

进入到map.put方法：

 public V put(K key, V value) {
        //对于key进行hash
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node[] tab; HashMap.Node p; int n, i;
           //rable在开始被定义：transient Node[] table;
        if ((tab = table) == null || (n = tab.length) == 0)
            //resize是扩容方法，下面有resize的说明
            n = (tab = resize()).length;
            //根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            HashMap.Node e; K k;
            //判断传入对象是否相等，相等则取代
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
                //判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对
            else if (p instanceof HashMap.TreeNode)
                e = ((HashMap.TreeNode)p).putTreeVal(this, tab, hash, key, value);
                // 该链为链表，就用链地址法
            else {
                //遍历table[i]，判断链表长度是否大于TREEIFY_THRESHOLD(默认值为8)，大于8的话把链表转换为红黑树，
                // 在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

 final Node[] resize() {
        //resize方法就是对hashmap扩容,它默认长度是 1<<4 最大是 1 << 30。自行点击进去看一下，这里大致说一下：
        
        Node[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            //  如果oldCap> 0,而且map最大容量大于等于 1<<30 返回oldTab,也就是n等于原来容器长度,不在扩容了，直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果oldCap> 0,而且oldCap扩大两倍小于 1<<30并且oldCap 大于等于 1<<4,那么扩容两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //如果容器不大于0，oldThr>0,说明此次不是初始化，这里新的容器容量等于oldThr
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //DEFAULT_LOAD_FACTOR是加载因子0.75 
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //if newThr == 0也就是如果两倍扩容大于 1<<30的情况 重新计算容量的上限 newNode[newCap]
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node[] newTab = (Node[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            //这里就不解释了，把oldTab都移动到newTab中
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

这样下来，重复的对象就不会添加进去。但是有些时候我们我们new 两个相同的对象出来

这种情况下我们应该重写JavaObject的hashCode跟equals方法

这时候就会覆盖掉。

TreeSet

可以进行去重并且排序，对于数据结构，我懂得也是皮毛而已，平衡二叉树的时间复杂度O(log n)，我自己以前也写过，每次添加元素的时候都会左旋或者右旋已达到平衡的目的（树的左右深度大于等于2就表示失衡）：

点击打开链接

既然TreeSet可以自然排序,那么TreeSet必定是有排序规则的。
1:让存入的元素自定义比较规则。
2:给TreeSet指定排序规则。
方式一：元素自身具备比较性
元素自身具备比较性，需要元素实现Comparable接口，重写compareTo方法，也就是让元素自身具备比较性，这种方式叫做元素的自然排序也叫做默认排序。
方式二：容器具备比较性
当元素自身不具备比较性，或者自身具备的比较性不是所需要的。那么此时可以让容器自身具备。需要定义一个类实现接口Comparator，重写compare方法，并将该接口的子类实例对象作为参数传递给TreeMap集合的构造方法。
注意：当Comparable比较方式和Comparator比较方式同时存在时，以Comparator的比较方式为主；
注意：在重写compareTo或者compare方法时，必须要明确比较的主要条件相等时要比较次要条件。（假设姓名和年龄一直的人为相同的人，如果想要对人按照年龄的大小来排序，如果年龄相同的人，需要如何处理？不能直接return 0，因为可能姓名不同（年龄相同姓名不同的人是不同的人）。此时就需要进行次要条件判断（需要判断姓名），只有姓名和年龄同时相等的才可以返回0.）

通过return 0来判断唯一性。

方式一实现：元素自身具备比较性

方式二实现：容器具备比较性