一、概述
1. Set接口的框架：
Collection接口：单列集合，用来存储一个一个的对象
Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”
HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
TreeSet：可以按照添加对象的指定属性，进行排序。
Set：存储无序的、不可重复的数据
以HashSet为例说明：
1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据
数据的哈希值决定的。
2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true.即:相同的元素只能添加一个。
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相
等，并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object
obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。二、HashSet的源码分析
private transient HashMap<E,Object> map;
public HashSet() {
map = new HashMap<>();
}
public int size() {
return map.size();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public V put(K key, V value) {
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) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
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;
}
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}说明：
1、添加元素的过程：以HashSet为例：
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
数组此位置上是否已经有元素：
如果此位置上没有其他元素，则元素a添加成功。 --->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。--->情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。--->情况2
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的结构。
底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）
就会扩大容量为原来的2倍。（16扩容为32，依次为64,128....等）因set底层HashMap，具体看HashMap源码分析。
重写 hashCode() 方法的基本原则
1.在程序运行时,同一个对象多次调用hashCode()方法应该返回相同的值。
2.当两个对象的equals()方法比较返回true时,这两个对象的hashCode()方法的返回值也应相等。
3.对象中用作equals()方法比较的Field，都应该用来计算 hashCode 值。重写 equals() 方法的基本原则
1.当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，
根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，
根据Object.hashCode()方法，它们仅仅是两个对象。
2.因此，违反了“相等的对象必须具有相等的散列码”。
3.结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的
对象的属性也应该参与到equals()中进行计算。Eclipse/IDEA工具里hashCode()的重写
为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？
1.选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越
少，查找起来效率也会提高。（减少冲突）
2.并且31只占用5bits,相乘造成数据溢出的概率较小。
3.31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
4.31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被
素数本身和被乘数还有1来整除！(减少冲突)三、LinkedHashSet的源码分析
