🏆🏆🏆教程全知识点简介：基础篇 1. 二分查找 2. 冒泡排序 7. ArrayList 8. Iterator 9. LinkedList 10. HashMap 1）基本数据结构 2）树化与退化 3）索引计算 4）put 与扩容 5）并发问题 11. 单例模式 并发篇 1. 线程状态 3. wait vs sleep 4. lock vs synchronized 虚拟机篇 1. JVM 内存结构 4. 内存溢出 5. 类加载 6. 四种引用 7. finalize 框架篇 1. Spring refresh 流程 2. Spring bean 生命周期 6. Spring 注解 7. SpringBoot 自动配置原理 数据库篇 1. 隔离级别 2. 快照读与当前读 3. InnoDB vs MyISAM 4. 索引 索引基础 5. 查询语句执行流程 6. undo log 与 redo log 7. 锁 缓存篇 1. Redis 数据类型 2. keys 命令问题 3. 过期 key 的删除策略 5. 缓存问题 6. 缓存原子性 7. LRU Cache 实现 分布式篇 1. CAP 定理 2. Paxos 算法 4. Gossip 协议 5. 分布式通用设计 6. 一致性 Hash（补充）

📚📚👉👉👉code git仓库：   https://gitee.com/xiaoshuai112/Backend/blob/master/Java/Java面试七大专题/note.md 直接get🍅🍅

✨ 本教程项目亮点

🧠 知识体系完整：覆盖从基础原理、核心方法到高阶应用的全流程内容
💻 全技术链覆盖：完整前后端技术栈，涵盖开发必备技能
🚀 从零到实战：适合 0 基础入门到提升，循序渐进掌握核心能力
📚 丰富文档与代码示例：涵盖多种场景，可运行、可复用
🛠 工作与学习双参考：不仅适合系统化学习，更可作为日常开发中的查阅手册
🧩 模块化知识结构：按知识点分章节，便于快速定位和复习
📈 长期可用的技术积累：不止一次学习，而是能伴随工作与项目长期参考

🎯🎯🎯全教程总章节

🚀🚀🚀本篇主要内容

基础篇

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

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 设置为左边界，重新查找

1. 当 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 的结点时，查找成功需要比较的次数

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

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

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

其中 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. 选择排序

[Java Concurrency in Practice]

要求

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

算法描述

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));
    }
}

[Apache HttpClient 文档]

[IntelliJ IDEA 文档]

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

与冒泡排序比较

[JUnit 5 用户指南]

1. 二者平均时间复杂度都是

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

[Apache Commons Lang]

[Leiningen 文档]

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

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

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

稳定排序与不稳定排序

[JDK 17 API 文档]

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));

[Spring Security 文档]

都是先按照花色排序（♠♥♣♦），再按照数字排序（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);
    }
}

[Log4j 2 文档]

与选择排序比较

1. 二者平均时间复杂度都是

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

3. 有序集合插入的时间复杂度为

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

提示

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

5. 希尔排序

要求

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

算法描述

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

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

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

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

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

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

算法实现

[Feign 文档]

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);
        }
    }
}

[QueryDSL 文档]

参考资料

6. 快速排序

要求

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

算法描述

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

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

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

[Swagger/OpenAPI]

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

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

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

4. 最后基准点与 i 交换，i 即为分区位置 ```java public static void quick(int[] a, int l, int h) { if (l >= h) { return; } int p = partition(a, l, h); // p 索引