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<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
//rable在开始被定义：transient Node<K,V>[] 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<K,V> 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<K,V>)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<K,V>[] resize() {
//resize方法就是对hashmap扩容,它默认长度是 1<<4 最大是 1 << 30。自行点击进去看一下，这里大致说一下：
Node<K,V>[] 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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//这里就不解释了，把oldTab都移动到newTab中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> 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<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> 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来判断唯一性。
方式一实现：元素自身具备比较性
方式二实现：容器具备比较性
