集合图解
ArrayList 扩容规则
-
ArrayList() 会使用长度为零的数组
-
ArrayList(int initialCapacity) 会使用指定容量的数组
-
public ArrayList(Collection<? extends E> c) 会使用 c 的大小作为数组容量
-
add(Object o) 首次扩容为 10，再次扩容为上次容量的 1.5 倍（实际是右移一位然后再跟之前的相加，例如
15>>>1 = 7 所以扩容后大小为15+7=22 -
addAll(Collection c) 没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量 1.5 倍, 实际元素个数)
其中第 4 点必须知道，其它几点视个人情况而定
Iterator
Fail-Fast 与 Fail-Safe
-
ArrayList 是 fail-fast 的典型代表，遍历的同时不能修改，尽快失败
-
CopyOnWriteArrayList 是 fail-safe 的典型代表，遍历的同时可以修改，原理是读写分离
解析：1.在ArrayList中
在遍历的时候会首先创建一个Iterator对象，对象中会讲在循环前操作数组的次数给记录下来，例如add四个数据，就会将4给传递过来，然后渎职给一个常量（后续不在改变）、然后再每次遍历前都会将记录下来的数与操作数据的若在遍历的中，集合内容发生了改变则也会将修改次数进行传递过来。跟常量比较发现不同就会抛出异常。
2.在CopyOnWriteArrayList 中
与ArrayList前面大致相同，但是在操作数据的时候，会继续便利的是旧的原来的集合，我们在添加的时候添加到新的集合。遍历结束还是原来的集合。牺牲了一定的一致性来保证遍历的进行。例如原来集合是1,2,3,4在遍历中插入5，遍历结束仍是1234.但是本次遍历结束再次输出集合就为12345了
LinkedList
要求
- 能够说清楚 LinkedList 对比 ArrayList 的区别，并重视纠正部分错误的认知
纠错：ArrayList 增删慢、查询快 LinkedList 增删快、查询慢
ArrayList 仅仅是在做头部插入时会稍微慢那么一丢丢，因为要将数组赋值往后移动一位然后再将值放在第一位的上面。在尾部插入就直接插入了。而LinkedList是基于链表结构的。一个数值只知道相邻链表的位置而不知道其他位置，所以要一个个的从头往下查找只有在插入头时候快
LinkedList
- 基于双向链表，无需连续内存
- 随机访问慢（要沿着链表遍历）
- 头尾插入删除性能高
- 占用内存多
ArrayList
- 基于数组，需要连续内存
- 随机访问快（指根据下标访问）
- 尾部插入、删除性能可以，其它部分插入、删除都会移动数据，因此性能会低
- 可以利用 cpu 缓存，局部性原理
对于第四点解析：CPU在进行计算是，若直接采用读取数值的方式，则需要等待数值传过来，然后再进行计算，计算完成再写出才完成一次计算。如下图：
所以加入了缓存机制，ArrayList是基于数组全部是连续的，可以很好的进行计算，但是如果是链表的话不能很好的利用，可能缓存进来的没有下个数值
HashMap
问题一底层存储结构，1.7 与 1.8 有何不同？
1.7 数组 + 链表，1.8 数组 + （链表 | 红黑树）
HashMap的实现原理
hash存储是通过计算字符的二次哈希值然后与数组的容量进行mod运算，计算出桶下标。然后就能存储到链表中的相应的位置。
利用此特性，可以从链表中快速的找到我们相同的值，不用循环链表。直接进行mod运算找到相应的值，不用考虑其他的值。
扩：HashMap的扩容机制
HashMap的底层有数组 + 链表(红黑树)组成，数组的大小可以在构造方法时设置，默认大小为16，数组中每一个元素就是一个链表，jdk7之前链表中的元素采用头插法插入元素，jdk8之后采用尾插法插入元素，由于插入的元素越来越多，查找效率就变低了，所以满足某种条件时，链表会转换成红黑树。随着元素的增加，HashMap的数组会频繁扩容，如果构造时不赋予加载因子默认值，那么负载因子默认值为0.75,数组扩容的情况如下:
1:当添加某个元素后，数组的总的添加元素数大于了 数组长度 * 0.75(默认,也可自己设定),数组长度扩容为两倍。(如开始创建HashMap集合后，数组长度为16，临界值为16 * 0.75 = 12，当加入元素后元素个数超过12，数组长度扩容为32，临界值变为24),数组长度为2ⁿ
问题二：为何要用红黑树，为何一上来不树化，树化阈值为何是 8，何时会树化，何时会退化为链表？
-
红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略(Dos会攻击时数组的链表都非常长，使查询都非常慢)
-
hash 表的查找，更新的时间复杂度是 O ( 1 ) O(1) O(1)，而红黑树的查找，更新的时间复杂度是 O ( l o g 2 n ) O(log_2n ) O(log2n)，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表
-
hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小(6以上的都很少了正常情况)
-
树化两个条件：链表长度超过树化阈值；数组容量 >= 64
-
退化情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表
-
退化情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表（左右儿子和左儿子的做儿子）
注意此处是在remove前的状态为准例如下图，如果移出3，则数组不退化，
问题三：索引如何计算？hashCode 都有了，为何还要提供 hash() 方法？数组容量为何是 2 的 n 次幂？
-
①先计算对象的 hashCode()，再进行调用 HashMap 的 hash() 方法进行二次哈希，最后 & (capacity – 1) 得到索引（按位与计算，capacity为数组容量 ）
注意当数组容量不是2ⁿ的时候，mod运算不能与&（按位与）计算进行等价
-
②二次 hash() 是为了综合高位数据，让哈希分布更为均匀（哈希列表越均匀，链表长度就不会过长）
-
③ 计算索引时，如果是 2 的 n 次幂可以使用位与运算代替取模，效率更高；扩容时 hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap
但 ①、②、③ 都是为了配合容量为 2 的 n 次幂时的优化手段，例如 Hashtable 的容量就不是 2 的 n 次幂，并不能说哪种设计更优，应该是设计者综合了各种因素，最终选择了使用 2 的 n 次幂作为容量
注意
- 二次 hash 是为了配合 容量是 2 的 n 次幂 这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash
- 容量是 2 的 n 次幂 这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable(由于容器是质数，分散性好，不需要二次hash)
问题四：介绍一下 put 方法流程，1.7 与 1.8 有何不同？
put 流程
- HashMap 是懒惰创建数组的，首次使用才创建数组
- 计算索引（桶下标）
- 如果桶下标还没人占用，创建 Node 占位返回
- 如果桶下标已经有人占用
- 已经是 TreeNode 走红黑树的添加或更新逻辑
- 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑
- 返回前检查容量是否超过阈值，一旦超过进行扩容
1.7 与 1.8 的区别
-
链表插入节点时，1.7 是头插法，1.8 是尾插法
-
1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容
-
1.8 在扩容计算 Node 索引时，会优化
问题五：加载因子为何默认是 0.75f
- 在空间占用与查询时间之间取得较好的权衡
- 大于这个值，空间节省了，但链表就会比较长影响性能
- 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多
上图是加载因子过大情况，下图是加载因子过小情况，0.75只是一个均衡的数值
问题六：多线程下会有啥问题？
答：扩容死链（1.7）
数据错乱（1.7，1.8）
扩容死链（1.7 会存在）
1.7 源码如下：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
-
e 和 next 都是局部变量，用来指向当前节点和下一个节点
-
线程1（绿色）的临时变量 e 和 next 刚引用了这俩节点，还未来得及移动节点，发生了线程切换，由线程2（蓝色）完成扩容和迁移
-
线程2 扩容完成，由于头插法，链表顺序颠倒。但线程1 的临时变量 e 和 next 还引用了这俩节点，还要再来一遍迁移
- 第一次循环
- 循环接着线程切换前运行，注意此时 e 指向的是节点 a，next 指向的是节点 b
- e 头插 a 节点，注意图中画了两份 a 节点，但事实上只有一个（为了不让箭头特别乱画了两份）
- 当循环结束是 e 会指向 next 也就是 b 节点
- 第二次循环
- next 指向了节点 a
- e 头插节点 b
- 当循环结束时，e 指向 next 也就是节点 a
- 第三次循环
- next 指向了 null
- e 头插节点 a，a 的 next 指向了 b（之前 a.next 一直是 null），b 的 next 指向 a，死链已成
- 当循环结束时，e 指向 next 也就是 null，因此第四次循环时会正常退出
数据错乱（1.7，1.8 都会存在）
举例：有两个线程都要进行put操作，在计算出hash与容器大小进行&运算后得到的余数值相同，例如都为1。存在同一个链表的同一个位置，若一个线程在进行put操作时，会先判断该位置是否有值，判断没有值后进行插入。此时在此过程中出现了另一个线程，也操作这个这个链表的这个位置。若第一个线程比较慢，刚判断结束还没放入数据，第二个线程直接判断put。此时第一个线程put 操作就会将第二个链表的值给覆盖。会导致数据错乱
问题七：key 能否为 null，作为 key 的对象有什么要求？
- HashMap 的 key 可以为 null，但 Map 的其他实现则不然
- 作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）
- key 的 hashCode 应该有良好的散列性
如果 key 可变，例如修改了 age 会导致再次查询时查询不到
public class HashMapMutableKey {
public static void main(String[] args) {
HashMap<Student, Object> map = new HashMap<>();
Student stu = new Student("张三", 18);
map.put(stu, new Object());
System.out.println(map.get(stu));
stu.age = 19;
System.out.println(map.get(stu));
}
static class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
}
问题八：String 对象的 hashCode() 如何设计的，为啥每次乘的是 31
目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特
- 字符串中的每个字符都可以表现为一个数字，称为 S_i，其中 i 的范围是 0 ~ n - 1
- 散列公式为： S_0∗ 31^n−1+ S_1∗ 31^n−2+ … S_i ∗ 31^n−1−i+ … S_n−1∗31^0
- 31 代入公式有较好的散列特性，并且 31 * h 可以被优化为
即 32 ∗ℎ −ℎ
即 2^5 ∗ℎ −ℎ
即 ℎ≪5 −ℎ
移位运行效率高
1465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
