java学习笔记——容器(一)
参考 ：
《java核心技术》
https://mp.weixin.qq.com/s/SHJzWpZ0MscuJhPLRwWQxg
https://github.com/LRH1993/android_interview/blob/master/java/basis/hashmap.md
- HashSet 与 TreeSet
在JAVA中，有Abstract 开头的基类，用于给程序员开发自己的容器。 例如 HashSet 就继承自 AbstractSet,
而其实AbstractSet只是实现了 Collection 和 Set 接口，没有实际内容，只是为了扩展。
- HashSet
HashSet 内部是一个 HashMap, 添加元素，迭代器，尺寸等常用函数，内部是直接调用map 的相关函数。
- TreeSet与HashSet 的不同之处，它是有序存储的。 其内部是使用红黑树实现的。其查找时复杂度为 Log2N ，要稍慢于 散列查找。
PS： 要使用排序树集，存储的元素必须能够比较， 元素必须实现 Comparable 接口，或者构造集时提供一个 Comparator 。
- HashMap
用散列存储键/值对，根据键 计算出hash值，然后将 键值对存储在合适的位置。
强大之处在于，会根据存储元素的增多扩容数组，和在相同hash值的元素过多时将链表存储改为红黑树存储，大大提高了搜索效率。
构造方法重载了四个，参数分别是 initialCapacity 初始化容量， LoadFactor 加载因子
会通过两个参数计算出一个阈值， threshold = initialCapacity*loadFactor , 含义是超过了阈值（即最大容量的一定比例），就会对数组就行扩容。
如不给出具体参数，默认情况下初始容量为 16， 加载因子为0.75
在给定大小之后，会将数组的大小设定成 大于等于给定值的 第一个2 的整数幂
HashMap 的数组 （源码中为 table） 并不是在构造函数中完成初始化，而是在put 方法中才初始化，这样也可以避免不使用的Map 浪费内存
- hash() 函数
计算哈希值时， 先调用 Object 的hashCode() 拿到一个哈希值，之后无符号右移，让高16位与低16位进行混合，都能参与到运算，让hash分布更加均匀。
在确定hash值时，需要对容量进行取模运算，但位运算效率更高，容量大小 n 又都是2的整数幂，所以可用 (n-1) & hash 更高效地完成取模运算。
-常用方法
get(Object key) 获取key键对应的值，如果映射中没有则返回null , 键可以为null
getOrDefault(Object key, V value) 返回key 对应的值，如果没有，则返回默认值 value.
put(K key, V value) 插入一个键值对，如果键已存在，则会覆盖之前的数据。
方法会返回之前的value ，如果之前没有，则返回null 。 方法的键 和值 可以为null
putAll(Map< ? exdtends K, ? extends V> entries) 把映射中所有条目添加进来
containsKey(Object key) containsValue(Object value) 返回映射中是否有查询的键或值
remove(Object key) 删除key 键对应的键值对元素
- 番外 ： 单词计数器
用单词对应的字符串作key， 每次出现 值+1。但是这样会有问题，当单词第一次出现时，值对应的是null,不能完成加一操作。有以下三种解决办法：
（1） map.put(word,map.getOrDefault(word,0)+1); 用getOrDefault 函数，将默认值设为0，就可以避免出现空指针异常
（2） { map.putIfAbsent(word,0); map.put(word,map.get(word)+1);} 每次都进行一次“空则设为0”操作，但这样效率也很低。
（3） map.merge(word,1, Integer::sum); 这个方法的含义，是用特定规则对前两个参数进行操作。此处的含义为对word的值和 1 进行和操作。
- HashMap 部分源码
- put() 方法
put方法内部调用的是putVal 方法，参数 onlyIfAbsent 为true时，不允许同键覆盖操作。
putVal 的逻辑如下：
如果 table 尚未初始化，则通过 resize() 进行初始化
如果 table 已经初始化，并且对应hash 位置上没有元素，就插入到对应位置
如果 table 已经初始化，并且对应 hash位置上已有元素，发生冲突。
如果 键与已有元素相同，将会进行覆盖操作，但此处先只是取得了原有键值对
否则，如果是树结构下，则调用 putTreeVal 方法完成添加。
否则，是链表结构下，通过循环找到链表末尾，将元素添加。
此时我们持有“被覆盖的键值对”，如果不为Null，则返回其value
在put 的最后，要判断映射中元素是否超出了阈值，超过则需要进行 resize() 扩容
在链表结构下的插入时，会记录链表中元素个数，如果大于 TREEIFY_THRESHOLD （值为8），则会通过 treeifyBin() 方法尝试转换成红黑树结构
在 treeifyBin() 方法中，如果数组长度小于 MIN_TREEIFY_CAPACITY （值为64） 则对数组扩容。如果长度超过了64，则转化成红黑树结构存储。
在 树结构中 若节点数少于6 ，将变回链表结构
- resize() 方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//1、table已经初始化，且容量 > 0
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//如果旧的容量已近达到最大值，则不再扩容，阈值直接设置为最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果旧的容量不小于默认的初始容量，则进行扩容，容量扩张为原来的二倍
newThr = oldThr << 1; // double threshold
}
//2、阈值大于0 threshold 使用 threshold 变量暂时保存 initialCapacity 参数的值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3 threshold 和 table 皆未初始化情况，此处即为首次进行初始化
//也就在此处解释了构造方法中没有对threshold 和 初始容量进行赋值的问题
else { // zero initial threshold signifies using defaults
//如果阈值为零，表示使用默认的初始化值
//这种情况在调用无参构造的时候会出现，此时使用默认的容量和阈值
newCap = DEFAULT_INITIAL_CAPACITY;
//此处阈值即为 threshold=initialCapacity*loadFactor
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr 为 0 时，按阈值计算公式进行计算，容量*负载因子
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;
//如果之前的数组桶里面已经存在数据，由于table容量发生变化，hash值也会发生变化，需要重新计算下标
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果指定下标下有数据
if ((e = oldTab[j]) != null) {
//1、将指定下标数据置空
oldTab[j] = null;
//2、指定下标只有一个数据
if (e.next == null)
//直接将数据存放到新计算的hash值下标下
newTab[e.hash & (newCap - 1)] = e;
//3、如果是TreeNode数据结构
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//4、对于链表，数据结构
else { // preserve order
//如果是链表，重新计算hash值，根据新的下标重新分组
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;
}
resize() 函数主要逻辑如下：
如果数组已初始化过，并且元素数量大于0
如果容量已经到了最大值，不能再扩容了。就将 threshold 阈值改为 Integer.MAX_VALUE ，之后都不再扩容了
否则，如果容量的二倍还没到最大值 并且 容量超过了默认初始容量（16），就将容量和阈值都乘2.
如果元素数量不大于0，阈值大于0，则用阈值 threshold 取代原本的容量
如果以上都不成立，则说明映射还未初始化。用默认的 16 和0.75 进行容量初始化。
如果扩容，数组长度变化，hash值也会发生变化，对所有元素进行遍历，重新计算hash值，并根据其是在链表中还是红黑树中采取不同的操作将其
放入到对应位置。
ps:在重新计算hash值时，因为容量是2的整数次幂，扩容也是原有容量乘二，所以可以知道，新的hash值，要么和原来相同，要么是加上oldCap
（图摘自https://github.com/LRH1993/android_interview/blob/master/java/basis/hashmap.md）
所以不用再次使用hash()函数计算，而是用原哈希值 & oldCap ,只判断新增的最高位变化即可。
- get() 方法
get 方法内部调用了 getNode() 方法
getNode() 方法的逻辑如下：
找到key 的 hash值对应的位置，如果数组中对应位置处没有元素，则返回null
如果第一个元素就是要找的元素，就返回第一个元素
如果第一个元素不是所查元素， 考虑元素结构
如果是树结构， 用 getTreeNode() 方法进行红黑树查找
如果是链表结构，则依次查找，直到找到或找遍链表。
- remove() 方法
其中根据key 找到元素的过程与 get 中一致
在删除操作中，如果是树结构 还是链表结构，进行不同操作
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//根据key和key的hash值，查找到对应的元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果查找的了元素node，移除即可
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是TreeNode，通过树进行移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是第一个节点，移除第一个节点，将index下标的位置指向第二个节点
else if (node == p)
tab[index] = node.next;
else
// 如果不是链表头， p 存储的就是 欲删除节点的前一个
// 将 p 的 next 指向 node 的next，就完成了node 的删除
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
- 映射视图
集合框架不认为映射本身是一个集合。
Map 的三个方法：
Set<Map.Entry<K,V>> entrySet() 返回映射中键值对的一个 集视图
Set<K> keySet() 返回所有键的 集视图
Collection<V> values() 返回所有值的集视图
以上三个方法返回的集，可以删除元素，映射中对应的元素也会删除。但不能添加元素，会抛出 UnsupportedOperationException
除了以上三种得到的集存在限制，将Collection 用 toArray() 转换的数组 也存在一定限制：
数组类型只能为 Object ,即时知道具体类型，也不能通过强制转换得到对应数组，会抛出 ClassCastException
如果想要返回具体类型的数组，需要使用变式， toArray(new String[0]) ，提供一个具体类型的数组，长度可以为0也可以指定具体长度。
