基础篇

基础篇要点：算法、数据结构、基础设计模式

1. 二分查找

要求

• 能够用自己语言描述二分查找算法
• 能够手写二分查找代码
• 能够解答一些变化后的考法

算法描述

1. 前提：有已排序数组 A（假设已经做好）

2. 定义左边界 L、右边界 R，确定搜索范围，循环执行二分查找（3、4两步）

3. 获取中间索引 M = Floor((L+R) /2)

4. 中间索引的值 A[M] 与待搜索的值 T 进行比较

   ① A[M] == T 表示找到，返回中间索引

   ② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找

   ③ A[M] < T，中间值左侧的其它元素都小于 T，无需比较，中间索引右边去找， M + 1 设置为左边界，重新查找

5. 当 L > R 时，表示没有找到，应结束循环

更形象的描述请参考：binary_search.html

算法实现

public static int binarySearch(int[] a, int t) {
    int l = 0, r = a.length - 1, m;
    while (l <= r) {
        m = (l + r) / 2;
        if (a[m] == t) {
            return m;
        } else if (a[m] > t) {
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return -1;
}

测试代码

public static void main(String[] args) {
    int[] array = {1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 50};
    int target = 47;
    int idx = binarySearch(array, target);
    System.out.println(idx);
}

▲解决整数溢出问题

当 l 和 r 都较大时，l + r 有可能超过整数范围，造成运算错误，解决方法有两种：

int m = l + (r - l) / 2;

还有一种是：

int m = (l + r) >>> 1;

其它考法

1. 有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数 (4)

2. 使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（ ）次比较

3. 在拥有128个元素的数组中二分查找一个数，需要比较的次数最多不超过多少次

对于前两个题目，记得一个简要判断口诀：奇数二分取中间，偶数二分取中间靠左。对于后一道题目，需要知道公式：

$$n=lo{g}_{2}N=lo{g}_{10}N/lo{g}_{10}2$$

其中 n 为查找次数，N 为元素个数

2. 冒泡排序

要求

• 能够用自己语言描述冒泡排序算法
• 能够手写冒泡排序代码
• 了解一些冒泡排序的优化手段

算法描述

1. 依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
2. 重复以上步骤，直到整个数组有序

更形象的描述请参考：bubble_sort.html

算法实现

public static void bubble(int[] a) {
    for (int j = 0; j < a.length - 1; j++) {
        // 一轮冒泡
        boolean swapped = false; // 是否发生了交换
        for (int i = 0; i < a.length - 1 - j; i++) {
            System.out.println("比较次数" + i);
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                swapped = true;
            }
        }
        System.out.println("第" + j + "轮冒泡"
                           + Arrays.toString(a));
        if (!swapped) {
            break;
        }
    }
}

• 优化点1：每经过一轮冒泡，内层循环就可以减少一次
• 优化点2：如果某一轮冒泡没有发生交换，则表示所有数据有序，可以结束外层循环

进一步优化

public static void bubble_v2(int[] a) {
    int n = a.length - 1;
    while (true) {
        int last = 0; // 表示最后一次交换索引位置
        for (int i = 0; i < n; i++) {
            System.out.println("比较次数" + i);
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                last = i;
            }
        }
        n = last;
        System.out.println("第轮冒泡"
                           + Arrays.toString(a));
        if (n == 0) {
            break;
        }
    }
}

• 每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有序，直接退出外层循环即可

3. 选择排序

要求

• 能够用自己语言描述选择排序算法
• 能够比较选择排序与冒泡排序
• 理解非稳定排序与稳定排序

算法描述

1. 将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集

2. 重复以上步骤，直到整个数组有序

更形象的描述请参考：selection_sort.html

算法实现

public static void selection(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        // i 代表每轮选择最小元素要交换到的目标索引
        int s = i; // 代表最小元素的索引
        for (int j = s + 1; j < a.length; j++) {
            if (a[s] > a[j]) { // j 元素比 s 元素还要小, 更新 s
                s = j;
            }
        }
        if (s != i) {
            swap(a, s, i);
        }
        System.out.println(Arrays.toString(a));
    }
}

• 优化点：为减少交换次数，每一轮可以先找最小的索引，在每轮最后再交换元素

与冒泡排序比较

1. 二者平均时间复杂度都是 $O(n^2)$

2. 选择排序一般要快于冒泡，因为其交换次数少

3. 但如果集合有序度高，冒泡优于选择

4. 冒泡属于稳定排序算法，而选择属于不稳定排序

   • 稳定排序指，按对象中不同字段进行多次排序，不会打乱同值元素的顺序
   • 不稳定排序则反之

稳定排序与不稳定排序

System.out.println("=================不稳定================");
Card[] cards = getStaticCards();
System.out.println(Arrays.toString(cards));
selection(cards, Comparator.comparingInt((Card a) -> a.sharpOrder).reversed());
System.out.println(Arrays.toString(cards));
selection(cards, Comparator.comparingInt((Card a) -> a.numberOrder).reversed());
System.out.println(Arrays.toString(cards));

System.out.println("=================稳定=================");
cards = getStaticCards();
System.out.println(Arrays.toString(cards));
bubble(cards, Comparator.comparingInt((Card a) -> a.sharpOrder).reversed());
System.out.println(Arrays.toString(cards));
bubble(cards, Comparator.comparingInt((Card a) -> a.numberOrder).reversed());
System.out.println(Arrays.toString(cards));

都是先按照花色排序（♠♥♣♦），再按照数字排序（AKQJ…）

• 不稳定排序算法按数字排序时，会打乱原本同值的花色顺序

  [[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
  [[♠7], [♠5], [♥5], [♠4], [♥2], [♠2]]
  

  原来 ♠2 在前 ♥2 在后，按数字再排后，他俩的位置变了

• 稳定排序算法按数字排序时，会保留原本同值的花色顺序，如下所示 ♠2 与 ♥2 的相对位置不变

  [[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
  [[♠7], [♠5], [♥5], [♠4], [♠2], [♥2]]
  

4. 插入排序

要求

• 能够用自己语言描述插入排序算法
• 能够比较插入排序与选择排序

算法描述

1. 将数组分为两个区域，排序区域和未排序区域，每一轮从未排序区域中取出第一个元素，插入到排序区域（需保证顺序）

2. 重复以上步骤，直到整个数组有序

更形象的描述请参考：insertion_sort.html

算法实现

// 修改了代码与希尔排序一致
public static void insert(int[] a) {
    // i 代表待插入元素的索引
    for (int i = 1; i < a.length; i++) {
        int t = a[i]; // 代表待插入的元素值
        int j = i;
        System.out.println(j);
        while (j >= 1) {
            if (t < a[j - 1]) { // j-1 是上一个元素索引，如果 > t，后移
                a[j] = a[j - 1];
                j--;
            } else { // 如果 j-1 已经 <= t, 则 j 就是插入位置
                break;
            }
        }
        a[j] = t;
        System.out.println(Arrays.toString(a) + " " + j);
    }
}

与选择排序比较

1. 二者平均时间复杂度都是 $O(n^2)$

2. 大部分情况下，插入都略优于选择

3. 有序集合插入的时间复杂度为 $O(n)$

4. 插入属于稳定排序算法，而选择属于不稳定排序

提示

插入排序通常被同学们所轻视，其实它的地位非常重要。小数据量排序，都会优先选择插入排序

5. 希尔排序

要求

• 能够用自己语言描述希尔排序算法

算法描述

1. 首先选取一个间隙序列，如 (n/2，n/4 … 1)，n 为数组长度

2. 每一轮将间隙相等的元素视为一组，对组内元素进行插入排序，目的有二

   ① 少量元素插入排序速度很快

   ② 让组内值较大的元素更快地移动到后方

3. 当间隙逐渐减少，直至为 1 时，即可完成排序

更形象的描述请参考：shell_sort.html

算法实现

private static void shell(int[] a) {
    int n = a.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // i 代表待插入元素的索引
        for (int i = gap; i < n; i++) {
            int t = a[i]; // 代表待插入的元素值
            int j = i;
            while (j >= gap) {
                // 每次与上一个间隙为 gap 的元素进行插入排序
                if (t < a[j - gap]) { // j-gap 是上一个元素索引，如果 > t，后移
                    a[j] = a[j - gap];
                    j -= gap;
                } else { // 如果 j-1 已经 <= t, 则 j 就是插入位置
                    break;
                }
            }
            a[j] = t;
            System.out.println(Arrays.toString(a) + " gap:" + gap);
        }
    }
}

参考资料

• https://en.wikipedia.org/wiki/Shellsort

6. 快速排序

要求

• 能够用自己语言描述快速排序算法
• 掌握手写单边循环、双边循环代码之一
• 能够说明快排特点
• 了解洛穆托与霍尔两种分区方案的性能比较

算法描述

1. 每一轮排序选择一个基准点（pivot）进行分区
   1. 让小于基准点的元素的进入一个分区，大于基准点的元素的进入另一个分区
   2. 当分区完成时，基准点元素的位置就是其最终位置
2. 在子分区内重复以上过程，直至子分区元素个数少于等于 1，这体现的是分而治之的思想 （divide-and-conquer）
3. 从以上描述可以看出，一个关键在于分区算法，常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

更形象的描述请参考：quick_sort.html

单边循环快排（lomuto 洛穆托分区方案）

1. 选择最右元素作为基准点元素

2. j 指针负责找到比基准点小的元素，一旦找到则与 i 进行交换

3. i 指针维护小于基准点元素的边界，也是每次交换的目标索引

4. 最后基准点与 i 交换，i 即为分区位置

public static void quick(int[] a, int l, int h) {
    if (l >= h) {
        return;
    }
    int p = partition(a, l, h); // p 索引值
    quick(a, l, p - 1); // 左边分区的范围确定
    quick(a, p + 1, h); // 左边分区的范围确定
}

private static int partition(int[] a, int l, int h) {
    int pv = a[h]; // 基准点元素
    int i = l;
    for (int j = l; j < h; j++) {
        if (a[j] < pv) {
            if (i != j) {
                swap(a, i, j);
            }
            i++;
        }
    }
    if (i != h) {
        swap(a, h, i);
    }
    System.out.println(Arrays.toString(a) + " i=" + i);
    // 返回值代表了基准点元素所在的正确索引，用它确定下一轮分区的边界
    return i;
}

双边循环快排（不完全等价于 hoare 霍尔分区方案）

1. 选择最左元素作为基准点元素
2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i，j 相交
3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置

要点

1. 基准点在左边，并且要先 j 后 i

2. while( i < j && a[j] > pv ) j–

3. while ( i < j && a[i] <= pv ) i++

private static void quick(int[] a, int l, int h) {
    if (l >= h) {
        return;
    }
    int p = partition(a, l, h);
    quick(a, l, p - 1);
    quick(a, p + 1, h);
}

private static int partition(int[] a, int l, int h) {
    int pv = a[l];
    int i = l;
    int j = h;
    while (i < j) {
        // j 从右找小的
        while (i < j && a[j] > pv) {
            j--;
        }
        // i 从左找大的
        while (i < j && a[i] <= pv) {
            i++;
        }
        swap(a, i, j);
    }
    swap(a, l, j);
    System.out.println(Arrays.toString(a) + " j=" + j);
    return j;
}

快排特点

1. 平均时间复杂度是 $O(nlo{g}_{2}n)$，最坏时间复杂度 $O(n^2)$

2. 数据量较大时，优势非常明显

3. 属于不稳定排序

洛穆托分区方案 vs 霍尔分区方案

• 霍尔的移动次数平均来讲比洛穆托少3倍
• https://qastack.cn/cs/11458/quicksort-partitioning-hoare-vs-lomuto

补充代码说明

• day01.sort.QuickSort3 演示了空穴法改进的双边快排，比较次数更少
• day01.sort.QuickSortHoare 演示了霍尔分区的实现
• day01.sort.LomutoVsHoare 对四种分区实现的移动次数比较

7. ArrayList

要求

• 掌握 ArrayList 扩容规则

扩容规则

1. ArrayList() 会使用长度为零的数组

2. ArrayList(int initialCapacity) 会使用指定容量的数组

3. public ArrayList(Collection<? extends E> c) 会使用 c 的大小作为数组容量

4. （初始为空时）add(Object o) 首次扩容为 10，再次扩容为上次容量的 1.5 倍

5. addAll(Collection c) 没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量 1.5 倍, 实际元素个数)

其中第 4 点必须知道，其它几点视个人情况而定

提示

• 测试代码见 day01.list.TestArrayList ，这里不再列出
• 要注意的是，示例中用反射方式来更直观地反映 ArrayList 的扩容特征，但从 JDK 9 由于模块化的影响，对反射做了较多限制，需要在运行测试代码时添加 VM 参数 --add-opens java.base/java.util=ALL-UNNAMED 方能运行通过，后面的例子都有相同问题

代码说明

• day01.list.TestArrayList#arrayListGrowRule 演示了 add(Object) 方法的扩容规则，输入参数 n 代表打印多少次扩容后的数组长度

7.1 初始化:

其实看构造方法源码就行了：

7.2 add扩容

初始为空
第一次加入元素： 扩容10
以后每次扩容到原来的1.5倍，但是计算规则用的移位+加法:
    假设上次容量为 n
    这次插入第n+1个元素，会扩容: n+n>>1
    也就是新申请一块长度为n+n>>1的新空间，将原来的n个元素原样复制到新空间，再插入第n+1个元素

插入第11个元素时: 扩容到: 10+10>>1 = 10+5 = 15
插入第16个元素时: 扩容到: 15+15>>1 = 15+7 = 22   (并不是15*1.5=22.5 并不是乘法计算出来的)

反射报错：

java.lang.reflect.InaccessibleObjectException: Unable to make field transient java.lang. Object[] java.util.ArrayList.elementData accessible: module java. base does not "opens java. util" to unnamed module @5ef04b5

解决1：切换到jdk8
解决2：

工具类：反射获取ArrayList里数组的长度

public static int capcity(ArrayList<Object> list) {
    try {
        Field field = ArrayList.class.getDeclaredField("elementData");
        field.setAccessible(true);
        return ((Object[]) field.get(list)).length;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}

测试main:

public static void main(String[] args) {
    ArrayList<Object> arrayList = new ArrayList<>();
    for (int i = 1; i <= 16; i++) {
        arrayList.add(i);
        System.out.println(i+" : "+ capcity(arrayList));
    }
}

1 : 10
2 : 10
3 : 10
4 : 10
5 : 10
6 : 10
7 : 10
8 : 10
9 : 10
10 : 10
11 : 15
12 : 15
13 : 15
14 : 15
15 : 15
16 : 22

7.3 addAll扩容

一句话：此次本该扩容量和批量添加元素个数之间取一个较大值

工具类:

public static int capcity(ArrayList<Object> list) {
    try {
        Field field = ArrayList.class.getDeclaredField("elementData");
        field.setAccessible(true);
        return ((Object[]) field.get(list)).length;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}

public static void main(String[] args) {
    ArrayList<Object> arrayList = new ArrayList<>();
    arrayList.addAll(List.of(1,2,3));
    System.out.println(capcity(arrayList));//10
}

刚开始容量是0
addAll(3个元素) 扩容到 Math.max(10,一次性添加元素个数) = max(10,3)=10

---

public static void main(String[] args) {
    ArrayList<Object> arrayList = new ArrayList<>();
    // 为空 再加
    arrayList.addAll(List.of(1,2,3,4,5,6,7,8,9,10,11,12));
    System.out.println(capcity(arrayList));//12
}

刚开始容量是0
addAll(3个元素) 扩容到 Math.max(10,一次性添加元素个数) = max(10,12) = 12 注意不是15

---

public static void main(String[] args) {
    ArrayList<Object> arrayList = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        arrayList.add(i);//装慢10个
    }
    // 原来有 再加
    arrayList.addAll(List.of(1,2,3));
    System.out.println(capcity(arrayList));//15
}

刚开始容量是10 也即非空有元素:
addAll(3个元素) 扩容到 Math.max(10+10>>1,10+一次性添加元素个数) = max(15,13) = 15

---

public static void main(String[] args) {
     ArrayList<Object> arrayList = new ArrayList<>();
     for (int i = 0; i < 10; i++) {
         arrayList.add(i);//装慢10个
     }
     // 原来有 再加
     arrayList.addAll(List.of(1,2,3,4,5,6,7));
     System.out.println(capcity(arrayList));//17
 }

刚开始容量是10 也即非空有元素:
addAll(3个元素) 扩容到 Math.max(10+10>>1,10+一次性添加元素个数) = max(15,17) = 17

---

8. Iterator

要求

• 掌握什么是 Fail-Fast、什么是 Fail-Safe

Fail-Fast 与 Fail-Safe

• ArrayList 是 fail-fast 的典型代表，遍历的同时不能修改，尽快失败

• CopyOnWriteArrayList 是 fail-safe 的典型代表，遍历的同时可以修改，原理是读写分离

提示

• 测试代码见 day01.list.FailFastVsFailSafe，这里不再列出

fail-fast 一旦发现遍历的同时其它人来修改，则立刻抛异常
fail-safe 发现遍历的同时其它人来修改，应当能有应对策略，例如牺牲一致性来让整个遍历运行完成

• 辅助类 Student

public class Student {
    private String name;
    //get/set 
    //无参，空参
    //toString()
}

• FailFast

// 普通 ArrayList 遍历同时不能修改 =》一旦修改 立刻抛出异常
public static void main(String[] args) {
    ArrayList<Student> list = new ArrayList<>();
    list.add(new Student("张三"));
    list.add(new Student("李四"));
    list.add(new Student("王五"));
    list.add(new Student("赵六"));

    for (Student student : list) {
        System.out.println(student);
        // 遍历的同时修改了 肯定报错 (哪怕在另一个线程里修改了他 还是会报错的)
        list.add(new Student(student.getName()+"丰"));
    }
    System.out.println(list);
}

• FailSafe

// 普通 CopyOnWriteArrayList 遍历同时可以修改 但是修改不会被遍历到 牺牲了一致性
public static void main(String[] args) {
    CopyOnWriteArrayList<Student> list = new CopyOnWriteArrayList<>();
    list.add(new Student("张三"));
    list.add(new Student("李四"));
    list.add(new Student("王五"));
    list.add(new Student("赵六"));

    for (Student student : list) {
        System.out.println(student);
        // 遍历的同时修改了 任然能遍历完 但是新的修改不会在本次被遍历到 牺牲了一致性
        list.add(new Student(student.getName()+"丰"));
        list.get(4).setName("赵666666666666");
    }
    System.out.println(list);
}

8.1 ArrayList 源码分析

注意需要Force step into 新版默认没有，工具栏右键添加 “customer toolbar”即可添加

说明增强for底层就用到了迭代器，迭代器也只是一个类而已，有自己的构造方法

8.2 CopyOnWriteArrayList 源码分析

迭代器迭代时会将list数组copy一份，实际迭代遍历的数组和list.add(x)作用的数组是两个数组

拓：Vector也是fail-fast 遍历时不允许修改

public static void main(String[] args) {
    Vector<Integer> vector = new Vector<>();
    for (int i = 0; i < 10; i++) {
        vector.add(i);
    }

    for (Integer i : vector) {
        System.out.println(i);
        vector.add(i*10);
    }
    System.out.println(vector);
}

9. LinkedList

要求

• 能够说清楚 LinkedList 对比 ArrayList 的区别，并重视纠正部分错误的认知

LinkedList

1. 基于双向链表，无需连续内存
2. 随机访问慢（要沿着链表遍历）
3. 头尾插入删除性能高(中间要先查找前驱，也不是很快)
4. 占用内存多

ArrayList

1. 基于数组，需要连续内存
2. 随机访问快（指根据下标访问）
3. 尾部插入、删除性能可以，其它部分插入、删除都会移动数据，因此性能会低
4. 可以利用 cpu 缓存，局部性原理

代码说明

• day01.list.ArrayListVsLinkedList#randomAccess 对比随机访问性能 （ArrayList远快于LinkedList）
• day01.list.ArrayListVsLinkedList#addMiddle 对比向中间插入性能 (ArrayList竟然远远远远快于LinkedList 更新指针远远慢于相邻位置移动元素)
• day01.list.ArrayListVsLinkedList#addFirst 对比头部插入性能 (LinkedList远快于ArrayList)
• day01.list.ArrayListVsLinkedList#addLast 对比尾部插入性能 (ArrayList反而更快 但是快得不是很明显，LinkedList肯定维护了尾部指针)
• day01.list.ArrayListVsLinkedList#linkedListSize 打印一个 LinkedList 占用内存 (24080B 远远高于ArrayLIst)
• day01.list.ArrayListVsLinkedList#arrayListSize 打印一个 ArrayList 占用内存 (4976B)

综上: 除了头部插入，ArrayList都要快于LinkedList，所以实际开发基本都用ArrayList，平均性能好多了
ArrayList还有一个非常非常好的特性，完美复合了空间局部性，CPU缓存命中率极高 （LinkedList看起来就太可怜了 几乎没有局部性，这就理解了为什么中间插入ArrayList要移动大量元素反而快，因为直接在缓存里面复制元素，LinkedList几乎没有局部性，没有缓存，查找前驱时需要经常读内存，一旦大量读内存，时间量就不是一个级别的了 （头部插入不需要查找，不需要经常读内存分散的指针，因为数组的局部性就没啥用了，移动元素就多了时间））

int类型每个元素占用4B, Integer每个元素本身也是4B, 但整个Integer在内存中占用16B （还有一些其他成员信息也占内存）

同理LinkedList基于双向链表，里面的东西肯定比ArrayList基于数组的数据结构成员要多得多，因此同样的元素内容，LinkedList占用的内存远远高于ArrayList

• 比较1

ArrayList实现了RandomAccess接口 （随机访问接口）
LinkedList并没有实现

其实这个接口啥也没有，只是一个标志

底层类库实现时会看看你有没有实现RandomAccess接口，实现了的话，找元素时就会直接根据下标去找了。

开发基本都用ArrayList (平均性能比LinkedList好太多了)

10. HashMap

自定义类型需要重新hashCode方法和equals方法
hashCode方法是用来生成hashCode值的，然后mod capacity 得到映射下标
equals方法则直接判断两个元素是否相等，相等一定会映射到同一个下标位置了(不允许重复时很好去重)

要求

• 掌握 HashMap 的基本数据结构
• 掌握树化
• 理解索引计算方法、二次 hash 的意义、容量对索引计算的影响
• 掌握 put 流程、扩容、扩容因子
• 理解并发使用 HashMap 可能导致的问题
• 理解 key 的设计

1）基本数据结构

• 1.7 数组 + 链表
• 1.8 数组 + （链表 | 红黑树）

更形象的演示，见资料中的 hash-demo.jar，运行需要 jdk14 以上环境，进入 jar 包目录，执行下面命令

java -jar --add-exports java.base/jdk.internal.misc=ALL-UNNAMED hash-demo.jar

HashMap底层就是hash表+拉链法
当元素个数>容量的3/4时就会扩容，教程演示直接扩容了一倍。
扩容之后capacity变了，下标也就会重新计算了，会减少很多冲突

极端情况: 所有元素hashCode都一样，无论扩容多少，总会映射到同一个下标位置，或者说映射位置与容量无关
这种时候就只能进行红黑树 树化了

2）树化与退化

树化意义

• 红黑树用来避免 DoS 攻击(恶意构造一大堆hash值一样的对象)，防止链表超长时性能下降，树化应当是偶然情况，是保底策略
• hash 表的查找，更新的时间复杂度是 $O(1)$，而红黑树的查找，更新的时间复杂度是 $O(lo{g}_{2}n)$，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表 （因为也不会很长）
• hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小

树化规则

• 当链表长度超过树化阈值 8 时，先尝试扩容来减少链表长度，如果数组容量已经 >=64，才会进行树化(别扩容了吧，再扩也没用了 并不是容量小导致的冲突问题)

(数组容量扩容到64，还是有拉链长度 >8 ,说明扩容不好使了，他们可能就是HashCode值就完全一样的，这个时候就进行拉链的树化了)
（一开始容量默认16，元素个数超过3/4时开始扩容，依次扩容32,64…）
总之树化要满足两个条件： 1、拉链长度严格大于8 2、数组容量>=64

问： 为何不一上来就树化？
答：因为开始链表很短，线性查找已经很快了。如果变成红黑树，由于红黑树需要维护其红黑树的性质，这些开销反而使得性能降低了。（链表短:其性能大于红黑树 链表很长时：其性能才远远不如红黑树）

问：为何阈值是8
答：不要刻意设置，正常情况下，Hash映射冲突的概率是很低很低的，拉链长度超过8概率为1亿分之6 【树化意义：第3条】
23万个随机单词用HashMap来存，冲突如下，最大冲突为长度为6的拉链，也才2个桶(下标位置)

刻意指的就是DOS攻击，刻意构造一些HashCode值一样的对象到你系统中，导致拉链非常长，从而严重影响系统性能，随便找个元素都要花好长时间

退化规则

• 情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表
• 情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表

问：RBT何时会退化为链表？
答：情况1：扩容可能解除拉链里的一些冲突，导致树拆分 (扩容看节点个数决定要不要退化（不看那4个结点是否存在）)
情况2：移除之前看RBT的根，根的左孩子，根的右孩子，根的左孙子，这4个结点是否都存在，若至少一个不存在（为null）, 本次移除之后一定会退化为链表 （移除看4个结点是否在决定是否退化(不看结点个数)）

注意

并不是看这么多就够了，后期还要背，这只是基础，在此基础上查资料，拓展，查漏补缺~

3）索引计算

索引计算方法

• 首先，计算对象的 hashCode()
• 再进行调用 HashMap 的 hash() 方法进行二次哈希
  • 二次 hash() 是为了综合高位数据，让哈希分布更为均匀
• 最后 & (capacity – 1) 得到索引 （%capacity 和 & (capacity – 1) 都能映射到 0~capacity-1）
• （如果capacity == 2^n 那么 %capacity == & (capacity – 1) 大于等于capacity的所有高位的1是商，低位是余数，更简单一点%2^n就是截取二进制的低n位）

特殊情况相等：

一般情况也不会大于capacity – 1

%capacity 映射到 0~(capacity-1)
&(capacity-1) 其实也是映射到 0~(capacity-1) 【因为capacity-1高位全部是0，&之后不会比capacity-1大，最最大也就是全1的二进制和capacity-1的二进制相与，最大也就是capacity-1】
然后%是除法取余，&就是按位与。前者耗费的时钟周期>后者

数组容量为何是 2 的 n 次幂

1. 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模
2. 扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap
   (因为都是位运算嘛，扩容时变成 2⁽ⁿ⁺¹⁾-1 也有规律可循 不需要真的重新mod(2⁽ⁿ⁺¹⁾-1))

解释2：新capacity-1的二进制就是在原来capacity-1二进制的基础上高位多了一个1 高1位是0 多的一位没意义了
原始capacity=16 则capacity-1=15=1111B 扩容后capacity=32 capacity-1=31=11111B
1、hash & 16 =0 说明 hash第5位为0 : 0xxxx & 01111 == 0xxxx & 11111B , 映射到的下标位置不变
2、hash & 16 !=0 说明 hash第5位为1: 1xxxx & 01111 = 0xxxx & 11111B + 16 = 旧位置 + oldCap 。 判断过程也就是计算新位置过程，新位置计算突然变得很简单很快了

注意

• 二次 hash 是为了配合 容量是 2 的 n 次幂 这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash
• 容量是 2 的 n 次幂 这一设计计算索引效率更好，但 hash 的分散性就不好(完全没有考虑到高位，只考虑了低n位)，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable

二次Hash源码：

上面是1.8的实现
下面是1.7的实现，更复杂

最后说一个缺点: 人家选择容量为2ⁿ，是综合考虑的结果，计算映射位置简单高效，扩容重新计算位置，判断要不要移动，简单。
但是肯定有缺点，还记得否学数据结构Hash表时，数组容量（或者说mod的那个值）应该选取一个质数的，这样分布是最均匀的。 java HashMap这种做法，弊端就出来了，假设都是偶数，就只能映射一半了。偶数 偶数%(2^n)==偶数&(2^n-1) =偶数 （最低位 1&0=0 还是偶数） =》 所以才需要二次Hash来进行优化
而且，质数没有只取低n位的弊端，不需要二次Hash

Hashtable 数组容量就不是2ⁿ 而是:[0,11,23,47,95,191 … ] 上次容量翻倍+1 也不是严格的质数（eg: 95） 但一定不是偶数 （只要不是2ⁿ 就不需要二次Hash,也不需要那个扩容优化）

4）put 与扩容

问： 介绍HashMap Put方法流程， 1.7和1.8 有什么不同

put 流程

1. HashMap 是懒惰创建数组的，首次使用才创建数组
2. 计算索引（桶下标）
3. 如果桶下标还没人占用，创建 Node 占位返回
4. 如果桶下标已经有人占用
   1. 已经是 TreeNode 走红黑树的添加或更新逻辑
   2. 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑
5. 返回前检查容量是否超过阈值，一旦超过进行扩容

1.7 与 1.8 的区别

1. 链表插入节点时，1.7 是头插法，1.8 是尾插法 （拉链法冲突时）

2. 1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容

3. 1.8 在扩容计算 Node 索引时，会优化（hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap）

扩容是先加到旧数组对应位置（此时旧数组超量了一个），再扩容，再将超量一个的旧数组重新计算Hash，移动到新数组

1.7没有空位时才扩容是合理的，没有空位指的是，虽然有拉链过长，但是我新插入的元素映射在一个空位置啊，不增加你的冲突负担，不需要扩容哈。

扩容（加载）因子为何默认是 0.75f

1. 在空间占用与查询时间之间取得较好的权衡
2. 大于这个值，空间节省了，但链表就会比较长影响性能
3. 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

元素>阈值 就扩容 阈值=容量*扩容因子

5）并发问题

扩容死链（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 都会存在）

• 代码参考 day01.map.HashMapMissData，具体调试步骤参考视频

补充代码说明

• day01.map.HashMapDistribution 演示 map 中链表长度符合泊松分布
• day01.map.DistributionAffectedByCapacity 演示容量及 hashCode 取值对分布的影响
  • day01.map.DistributionAffectedByCapacity#hashtableGrowRule 演示了 Hashtable 的扩容规律
  • day01.sort.Utils#randomArray 如果 hashCode 足够随机，容量是否是 2 的 n 次幂影响不大
  • day01.sort.Utils#lowSameArray 如果 hashCode 低位一样的多，容量是 2 的 n 次幂会导致分布不均匀
  • day01.sort.Utils#evenArray 如果 hashCode 偶数的多，容量是 2 的 n 次幂会导致分布不均匀
  • 由此得出对于容量是 2 的 n 次幂的设计来讲，二次 hash 非常重要
• day01.map.HashMapVsHashtable 演示了对于同样数量的单词字符串放入 HashMap 和 Hashtable 分布上的区别

并发可能会丢失数据，多线程操作同一个HashMap，没有做同步互斥机制，会导致同一个HashMap位置写后写，后写覆盖先写，导致数据丢失。 也就是本身是线程不安全的

6）key 的设计

问：key能否为null

key 的设计要求

1. HashMap 的 key 可以为 null，但 Map 的其他实现则不然
2. 作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）
3. key 的 hashCode 应该有良好的散列性

如果 key 可变，例如修改了 age 会导致再次查询时查询不到

重写 hashCode 是为了有更好的散列性，分布更均匀
重写 equals 是万一 hashCode 计算出来一样，需要equals判断是否是同一个对象 （hashCode相同equals不一定true,但是equals是true, hashCode一定相同）

如下：修改了作为key的stu，再计算hashCode然后映射的位置肯定不对了，肯定就找不到了

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));//java.lang.Object@682a0b20

        stu.age = 19; // 修改了作为key的对象 (再计算hashCode肯定就不一样了)
        System.out.println(map.get(stu));// null   hashCode都不一样了，肯定就找错了呀
    }

    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() 设计

• 目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特
• 字符串中的每个字符都可以表现为一个数字，称为 $S_i$，其中 i 的范围是 0 ~ n - 1 （字符串长度为n）
• 散列公式为： $S_0\ast 31^{(n-1)}+S_1\ast 31^{(n-2)}+\dots S_i\ast 31^{(n-1-i)}+\dots S_{(n-1)}\ast 31^0$ (每个数组乘以不同个数个31，就把每个数字错开了，散列性就会非常好)
• 31 代入公式有较好的散列特性，并且 31 * h 可以被优化为
  • 即 $32\ast h-h$
  • 即 $2^5\ast h-h$
  • 即 $h\ll 5-h$

31*h = 32*h-h = 2^5*h-h = h<<5-h

11. 单例模式

要求

• 掌握五种单例模式的实现方式
• 理解为何 DCL 实现时要使用 volatile 修饰静态变量
• 了解 jdk 中用到单例的场景

1）饿汉式

私有化构造器
然后提供静态方法

public class Singleton1 implements Serializable {
    private Singleton1() {
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        System.out.println("private Singleton1()");
    }

    private static final Singleton1 INSTANCE = new Singleton1();

    public static Singleton1 getInstance() {
        return INSTANCE;
    }
	
	// 检验懒汉还是饿汉式的测试方法  (实际中完全不需要)
    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
    
    public Object readResolve() {
        return INSTANCE;
    }
}

1、反射就可以破坏单例 =》 解决： 抛异常
2、实现了Serializable 接口就有可能通过先序列化再反序列化破坏单例 =》 解决: 重写readResolve方法 （反序列化过程创建对象就是调用readResolve方法 且不用走构造方法）
3、Unsafe破坏单例 =》 目前没有找到解决方法

• 构造方法抛出异常是防止反射破坏单例
• readResolve() 是防止反序列化破坏单例

2）枚举饿汉式

public enum Singleton2 {
    INSTANCE; //其实天然就是一个单例对象了
	
	// 下面代码都可以不写 完全为了测试用
	// eg: 枚举类没有无参构造器，只有有参构造器， 非要写无参构造器默认也是private，也必须是private
    private Singleton2() {
        System.out.println("private Singleton2()");
    }
	
	//完全为了测试用 枚举类toString默认只打印名字，不打印hashCode
    @Override
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    public static Singleton2 getInstance() {
        return INSTANCE;
    }
	
	// 检验懒汉还是饿汉式的测试方法  (实际中完全不需要)
    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

• 枚举饿汉式能天然防止反射、反序列化破坏单例
• Unsafe还是能破坏单例，Unsafe谁也挡不住

其实这样,就是单例了：

enum Sex {
    MALE, FEMALE;
}

具体实现翻译为java代码就是：

final class Sex extends Enum<Sex> {
    public static final Sex MALE;
    public static final Sex FEMALE;

    private Sex(String name, int ordinal) {
        super(name, ordinal);
    }

    static {
        MALE = new Sex("MALE", 0);
        FEMALE = new Sex("FEMALE", 1);
        $VALUES = values();
    }

    private static final Sex[] $VALUES;

    private static Sex[] $values() {
        return new Sex[]{MALE, FEMALE};
    }

    public static Sex[] values() {
        return $VALUES.clone();
    }

    public static Sex valueOf(String value) {
        return Enum.valueOf(Sex.class, value);
    }
}

饿汉式：类一加载就会调用构造器创建对象（静态字段或者方法实现）
懒汉式：调用getInstance()方法获取单例时才创建

3）懒汉式

public class Singleton3 implements Serializable {
    private Singleton3() {
        System.out.println("private Singleton3()");
    }

    private static Singleton3 INSTANCE = null;

    // Singleton3.class
    public static synchronized Singleton3 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton3();
        }
        return INSTANCE;
    }
	
	// 检验懒汉还是饿汉式的测试方法  (实际中完全不需要)
    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

}

注意getInstance方法要加锁synchronized。否则多线程访问明显不安全，多个线程可能同时访问到INSTANCE = new Singleton3(); 导致创建了多个实例

但是synchronized直接加在getInstance方法上很不好，效率很低，因为：

• 其实只有首次创建单例对象时才需要同步，但该代码实际上每次调用都会同步
• 因此有了下面的双检锁改进

4）双检锁懒汉式

加锁之前先做一次判断，只会竞争一次了，以后创建好了实例之后，就再也不会进行竞争了
锁里面还是要做判断，因为第一个if可能同时多个线程成立，里面的代码好多线程都会执行，只能让第一个竞争到的线程创建实例
INSTANCE 变两需要加 volatile 修饰，解决变量有序性问题

public class Singleton4 implements Serializable {
    private Singleton4() {
        System.out.println("private Singleton4()");
    }

    private static volatile Singleton4 INSTANCE = null; // 可见性，有序性

    public static Singleton4 getInstance() {
        if (INSTANCE == null) { // 有了实例之后不需要竞争
            synchronized (Singleton4.class) { 
                if (INSTANCE == null) { // 首次需要竞争(因为第一个if可能同时好多线程成立)
                    INSTANCE = new Singleton4();
                }
            }
        }
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

为何必须加 volatile：

• INSTANCE = new Singleton4() 不是原子的，分成 3 步：创建对象、调用构造、给静态变量赋值，其中后两步可能被指令重排序优化，变成先赋值、再调用构造
• 如果线程1 先执行了赋值，线程2 执行到第一个 INSTANCE == null 时发现 INSTANCE 已经不为 null，此时就会返回一个未完全构造的对象（返回了一个构造方法没有被执行的实例对象 可能导致一些必要的成员没有被赋值，明显这是不合理的）
• 加上volatile就能解决这个问题，相当于给此行赋值指令加上了屏障，阻止了其他赋值指令越过屏障，跑到我后面去

饿汉式不需要考虑线程安全问题，因为给静态变量赋值其实是编译到静态代码块执行赋值的，静态代码块是类加载时jvm虚拟机保证了安全的。 （个人觉得类加载不是只加载一次吗，没有多线程问题吧）

5）内部类懒汉式

内部类可以直接访问外部类的私有成员
内部类被使用到时才会被加载：懒汉模式
内部类静态加载时实例化对象，不需要考虑线程安全问题
（于是 集合了 懒加载+天然线程安全 这两个优点 ）

public class Singleton5 implements Serializable {
    private Singleton5() {
        System.out.println("private Singleton5()");
    }

    private static class Holder {
        static Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return Holder.INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }
}

• 避免了双检锁的缺点 (直接给静态变量赋值，天然就是线程安全的)

JDK 中单例的体现

• Runtime 体现了饿汉式单例 （System.java）
• Console 体现了双检锁懒汉式单例 (System.java)
• Collections 中的 EmptyNavigableSet 内部类懒汉式单例 (有一些空集合对象 还有好多懒汉单例成员变量) (Collections.java)
• ReverseComparator.REVERSE_ORDER 内部类懒汉式单例 (Comparators.java)
• Comparators.NaturalOrderComparator.INSTANCE 枚举饿汉式单例 (Comparators.java)

单例模式都是在jdk中找到的
千万不要说自己在项目中用到了单例模式，很容易用错的

System.exit(i) —调用—> Runtime.getRuntime().exit(i)
System.gc() —调用—> Runtime.getRuntime().gc() 做一次垃圾回收

视频里讲了好多，没有一一做笔记了 可以再看看视频

---

好玩的工具类

import java.util.Random;

public class Utils {
    public static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    public static void shuffle(int[] array) {
        Random rnd = new Random();
        int size = array.length;
        for (int i = size; i > 1; i--) {
            swap(array, i - 1, rnd.nextInt(i));
        }
    }

    public static int[] randomArray(int n) {
        int lastVal = 1;
        Random r = new Random();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            int v = lastVal + Math.max(r.nextInt(10), 1);
            array[i] = v;
            lastVal = v;
        }
        shuffle(array);
        return array;
    }

    public static int[] evenArray(int n) {
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = i * 2;
        }
        return array;
    }

    public static int[] sixteenArray(int n) {
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = i * 16;
        }
        return array;
    }

    public static int[] lowSameArray(int n) {
        int[] array = new int[n];
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            array[i] = r.nextInt() & 0x7FFF0002;
        }
        return array;
    }
}