Posts on Creat

基础知识拓展

Tue, 03 Feb 2026 00:00:00 +0000

基本语法

Tue, 03 Feb 2026 00:00:00 +0000

数组

索引

int[] arr = {0, 1, 2, 3, 4};
System.out.println(arr);//[I@f6f4d33

地址符:

[ :表示当前是一个数组
I :表示当前数组里边的元素类型为int
@ :表示一个间隔符号
6f4d33 :16进制的数组 ‘地址值’

int len = arr.length; //获取数组长度
int[] arr = new int [3]; //格式：数据类型[] = new 数据类型[数组长度]

数组默认动态初始化值：

整数类型: 0;
浮点数类型: 0.0;
字符类型: ‘/u000’ (空格)
布尔类型: false
引用数据类型: none

Java内存分配

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中运行。
堆：存储对象或数组，new来创建的，都存储在堆内存
方法区：存储可以运行的class文件
本地方法栈： JVM在使用操作系统的时候使用，和开发无关
寄存器：给CPU使用，和开发无关

当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次询问的时候都是修改后的结果了。例如：

public static void main(String[] args){
	int[] arr1 = {11.22};
	int[] arr2 = arr1;//此时arr2与arr1共用一个内存
	sout(arr1[0]); //11
	sout(arr2[0]); //11
	
	arr2[0] = 33;
 
	sout(arr1[0]); //33
	sout(arr2[0]); //33
}

方法

方法是程序运行的最小执行单元(类似于c中的函数)

经典例题：需求：定义一个方法copyOfRange(int[] arr, int from ,int to)
功能：将数组arr从索引from(包含)开始,到索引to(不包含)的元素复制带一个新的数组中,将新数组返回

package test;
import java.util.Arrays;
import java.util.Scanner;

public class method_test {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int[] arr = {1,2,3,4,5};
 int[] num = copyOfRange(arr,0,4);
 //打印新数组num的元素
 System.out.println(Arrays.toString(num));
 }
 
 public static int[] copyOfRange(int[] arr, int from, int to){
 //设置数组长度为 from - to
 int[] num = new int [to - from];
 for (int i = from; i < to; i++){
 num[i-from] = arr[i];
 }
 return num;
 }
}

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

public class method_test {
 public static void main(String[] args) {
 int num = 100;
 System.out.println("调用change方法前" + num); //100
 change(num);
 System.out.println("调用change方法后" + num); //100
 }
 public static void change(int num){
 num = 200;
 }
}

上述代码并未改变number的值，因为方法change()与方法main()存储在栈内存中，两个num并不一样.

传递引用数据类型时，传递的是地址，形参的该百年，影响实际参数的值

public class method_test {
 public static void main(String[] args) {
 int[] arr = {10, 20, 30};
 System.out.println("调用change方法前" + arr[0]); //10;
 change(arr);
 System.out.println("调用change方法后" + arr[0]); //1000;
 }
 public static void change(int[] arr){
 arr[0] = 1000;
 }
}

上述代码中 arr 数组的值发生了改变，原因是数组属于引用数据类型，其引用(内存地址)存储在栈内存中，而实际数据存储在堆内存中。main 方法与 change 方法共享同一个数组引用(即指向堆内存中同一个数组对象)，因此在 change 方法中对数组内容的修改会影响到 main 方法中访问该数组时的结果

面向对象

Tue, 03 Feb 2026 00:00:00 +0000

面向对象

类和对象

类（设计图)：是对象共同特征的描述；
对象：是真实存在的具体东西
在Java中，必须先设计类，才能获得对象

public class 类名{ 
	1.成员变量
	2.成员方法
	3.构造器
	4.代码块
	5.内部类
}
public class Phone{
	//属性（成员变量）
	String brand;
	double price;
	
	//行为（方法）
	public void call(){
	}
	public void playGame(){
	}
}

定义类的注意事项

类名首字母建议大写，需要见名知意
一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须为代码文件名（实际开发中还是建议一个文件定义一个class类）
成员变量完整定义格式是：修饰符数据类型变量名称 = 初始化值；一般无需指定初始化值，存在默认值

封装

告诉我们如何正确设计对象的属性和方法

对象代表什么，就得封装对应的数据，并提供对应的行为

private关键字

是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被private修饰的成员只能在本类中才能访问 以下代码并不安全

public class GirlFriend{
	String name; //会出现负数等不合理的值
	int age;
	String gneder;
}

修改为以下代码

public class GirlFriend{
	//将类中的变量转换为私有
	private int age;
	// set 赋值
	public void setAge(int a){
		if(a >= 18 && a <= 50){
			age = a;
		}else{
			System.out.println("非法数据");
		}
	}
	// get 获取
	public int getAge(){
		return age;
	}
}

就近原则和this关键字

成员变量和局部变量

public class GrilFriend{
	private int age;	//成员变量
	public void method(){
		int age = 10;	//局部变量
		System.out.println(age);//输出 10
	}
}

修改为this后可以调用成员变量

public class GrilFriend{
	private int age;	//成员变量
	public void method(){
		int age = 10;	//局部变量
		System.out.println(this.age);
	}
}

构造方法

构造方法也叫做构造器，构造函数 作用：在创建对象的时候给成员变量进行初始化（赋值）。

public class Student(){
	修饰符 类名（参数）{
		方法体;
	}

特点：

方法名与类名相同，大小写也要一致
没有返回值类型，连void也没有
没有具体的返回值（不能由return带回结果数据）空参构造：

 public Student(){
	 System,out.println("执行空参构造")	
 }

空参调用：Student s = new Student()

带参构造：

	public Student(String name,int age){
		System.out.println("执行带参构造");
		this.name = name;
		this.age = age;
	}

带参调用：Student s = new Student("Jim"，18);

注意事项： 1.构造方法的定义

如果没有定义构造方法，系统将给出一个默认的无参数的构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

2.构造方法的重载

带参构造方法和无参构造方法，方法名相同，但是参数不同，这叫构造方法的重载

3.推荐使用方式

无论是否使用，都手动书写无参数构造方法和带全部参数的构造方法

标准JavaBean

标准的Javabean类

类名需要见名知意
成员变量使用private修饰
提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
成员方法
- 提供每一个成员变量对应的setXxx() / getXxx()
- 如果还有其他行为，也需要写上

Java内存分配

new 一个对象： 1.加载class文件 2.申明局部变量 3.在堆内存中开辟一个空间 4.默认初始化 5.显示初始化 6.构造方法初始化 7.将堆内存中的地址值赋值给左边的局部变量

this本质：代表方法调用者的地址值
this作用：区分局部变量和成员变量

一些实例…

键盘录入:

第一套体系 (遇到空格,制表符,回车就停止接收)

	nextInt(); 	 //接收整数
	nextDouble(); //接收小数
	next();		 //接收字符串

第二套体系(遇到回车停止接收)

	nextLine(); //接收字符串

字符串

Tue, 03 Feb 2026 00:00:00 +0000

字符串

String

字符串在内存中存储的是地址

创建String对象的两种方式

１．直接赋值 String name = "MyString"
2.使用new关键字构造

	//空参构造
	String s1 = new String(); 		// 空
	
	//传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
	String s2 = new String("abc"); 	//abc
	
	//*传递一个字符数组，根据一个字符数组的内容，创建一个新的字符串
	char[] ch = {'a','b','c','d'};
	String s3 = new String(ch);		//abcd
	
	//*传递一个字节数组，根据一个字节数组的内容，创建一个新的字符串
	byte[] bytes = {97,98,99,100}; //传递ASCII码
	String s4 = new String(bytes); //abcd

字符串的比较

先了解"==“比较的是什么，在~~基本数据类型~~中”==“比较的是具体的数据值，但是在~~引用数据类型~~中，"==“比的是地址值，所以在字符串的比较中不能用 “=="。

	String s1 = "abc";
	String s2 = "abc";
	sout(s1 == s2); // true
	
	String s1 = new String("abc");//记录堆里面的地址值
	String s2 = "abc";			 //记录串池中的地址值
	sout(s1 == s2); // false

equals 与 equalsIgnoreCase

boolean equals 方法：完全一样结果才是true
boolean equalsIgnoreCase方法：忽略大小写的比较
（忽略大小写只能是英文状态下的）
boolean bool = s1.equals(s2)

		Scanner sc = new Scanner(System.in);
		String str1 = sc.next(); //abc
		String str2 = "abc";	//赋值
		Souy(str1 == str2) //false

[!NOTE]

两者不一样，键盘录入得到的字符串其实是new出来的，两者的地址值不一样，因此一定要用equals比较字符串

遍历字符串

public charAt(int index) 根据索引返回字符
public int length() 返回此字符串的长度
String substring(int beginindex, int endlindex) 截取字符串

[!NOTE] 包头不包尾，包左不包右，对原字符拆没影响重构：String substring (int beginindex) 截取到末尾

替换字符串

String replace(旧值，新值) 替换

StringBulider

提高字符串的操作效率

StringBuilder 常用方法

public StringBulider() 创建一个空白可变的字符串对象，不含有任何内容

[!NOTE] StringBuilder 是 Java 已经写好的类 Java在底层对他做了一些特殊处理 打印对象不是地址值而是属性值

public StringBuilder append(任意类型) 添加数据，返回对象本身
public StringBuilder reverse() 反转容器中的内容
public int length() 返回长度（字符出现的个数）
public String toString() 通过toString()就可以实现把 StringBuilder 转化为 String

~~以下是对于StringBuilder 和 toString的演示~~

		// 此时并不是字符串
 	StringBuilder sb = new StringBuilder("abc");

 sb.append("111");
 sb.append("222");

 //再将 StringBuilder 变回字符串
 String str = sb.toString();
 System.out.println(str);

[!TIP] 补充链式编程：当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法。

例如：int len getString().substring(1).replace("A","Q").length()

StringJoiner

StringJoiner 跟 StringBuilder 一样，也可以看成是一个容器，创建之后里边的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简介，但是目前市场很少有人用
JDK8才出现

StringJoiner 的构造方法

public StringJoiner(间隔符号) 创建一个StringJoiner对象,指定拼接时的间隔符号
public StringJoiner(间隔符号,开始符号,结束符号) 创建一个StringJoiner对象，指定拼接时的间隔符号,开始符号,结束符号

StringJoiner 的成员方法

public StringJoiner add(添加的内容) 添加数据，并返回数据本身
public int length() 返回长度（字符出现的个数）
public String toString() 返回一个字符串（该字符串就是拼接之后的效果）

字符串原理

1.字符串存储的原理 - 直接赋值会复用字符串常量池中的 - new 出来的不会复用，而是开辟一个新的空间

2.==号比较的到底是什么？ - 基本数据类型 比较数据值 - 引用数据类型 比较地址值

3.字符串拼接的底层原理

 public class Test2 {
 public static void main(String[] args) {
 String ss = "abc"; // 记录串池中的地址值
 String s = "a" + "b" + "c"; //拼接时没有变量,会复用串池中的字符串
 
 System.out.println(s); //abc
 }
 }

[!NOTE] 拼接的时候没有变量，都是字符串触发字符串的优化机制在编译的时候就已经是最终结果了。

在编译的时候，就会将"a”+“b”+“c” 拼接为 “abc”…

public class Test2 {
 public static void main(String[] args) {
 String s1 = "a";
 String s2 = s1 + "b"; 
 String s3 = s2 + "c";
 System.out.println(s3);
 }
}

[!NOTE] 相当于先创建了一个new StringBuilder 对象做完一系列操作后在使用 toString 转化为字符串 new StringBuilder().append(s1).qppend(“b”).toString();

 public class Test2 {
 public static void main(String[] args) {
 String s1 = "a";
 String s2 = "b"; 
 String s3 = "c";
 String s4 = s1 + s2 + s3 ; //创建了四个SB对象
 System.out.println(s3);
 }
 }

[!NOTE] JDK8 之前：每次以上的字符串相加都会创建两个SB对象 JDK8 及之后，编译器会对连续的字符串拼接操作进行优化，通过一个StringBuilder完成所有拼接，并预先计算和分配合适的容量，从而减少对象创建和数组扩容的开销。

总结：

如果没有变量参与，都是字符串直接相加，编译之后就是拼接的结果，会复用字符串池
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存

4.StringBuilder 提高效率原理图

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用空间，节约内存

5.StringBuilder 源码分析

默认创建一个长度为16的字节数组
添加的内容长度小于16，直接存
添加的内容大于16 会扩容（原来的容量*2+2）
如果扩容后还不够，以实际长度为准

补充内容

startsWith("String") 或 startsWith("String",begin,end)检测字符串（范围）开头

ArrList集合

Tue, 03 Feb 2026 00:00:00 +0000

集合

类似于vector

[!NOTE] 集合的每个位置存储的是地址值

ArrayList

成员方法（增删改查）

boolean add(E e) 添加元素，返回值表示是否添加成功一般直接用list.add(E e)，因为只要添加就会返回true
boolean add(E e) 删除指定元素，返回值代表是否删除成功优先删除索引小的元素
E remove(int index 删除指定索引的元素，返回被删除的元素
E set(int index,E e) 修改指定索引下的元素，返回原来的元素
E get(int index) 获取指定索引的元素
int size() 集合的长度

基本数据类型对应的包装类

byte —> Byte
short —> Short
char —> Character
int — > Integer
long —> Long
float —> Float
double —> Double
boolean —> Boolean

面向对象进阶

Tue, 03 Feb 2026 00:00:00 +0000

static（静态）

静态变量

在JavaBean中，不加static只能供一个对象使用

被 static 修饰的变量属于类，所有实例共享同一个变量值
在内存中只存在一份，当类被加载时初始化
通常用于表示所有对象共有的属性

public class Student {
 // 静态变量（类变量）
 public static String schoolName = "阳光中学";
 // 实例变量
 private String name;
 
 public Student(String name) {
 this.name = name;
 }
 
 public static void main(String[] args) {
 // 直接通过类名访问静态变量
 System.out.println(Student.schoolName); // 输出：阳光中学
 
 Student s1 = new Student("张三");
 Student s2 = new Student("李四");
 
 // 也可以通过实例访问（不推荐）
 System.out.println(s1.schoolName); // 输出：阳光中学
 
 // 修改静态变量，所有实例都会受到影响
 Student.schoolName = "星光中学";
 System.out.println(s2.schoolName); // 输出：星光中学
 }
}

[!NOTE] JDK8之前，静态区处于方法区里面。 JDK7之后，静态区处于堆空间之中。

静态方法

多用在测试类和工具类当中
JavaBean中很少用

[!NOTE] JavaBean类：用来描述一类事物的类测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口工具类：不是用来描述一类事物的，而是帮我们做一些事情的类

工具类

1.类名见名知意 2.私有化构造方法

 public class ArrUtil{
 private ArrUtil(){}
 }

private ArrayUtil() {} 是一个私有构造方法
由于构造方法被声明为 private（私有），这意味着在类的外部无法调		用这个构造方法，也就无法创建 ArrayUtil 类的对象实例。

防止这个工具类被意外地实例化

[!NOTE] 如果不写这个私有构造方法，Java 会默认提供一个公共的无参构造方法这样别人就可能误将其当作普通 JavaBean，写出new ArrayUtil()这样的代码（虽然创建了对象也没用，但不符合设计意图）

3.方法定义/为静态

static的注意事项

静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字

public class Student{
	String name;
	int age;
	static String teachername;
	
	//this:表示当前方法调用者的地址值
	//这个this:是由虚拟机赋值的
	public void show1(Student this){//此处的this是虚拟机暗加的
		sout("this:" + this);//地址值
		sout(name+","+age+","+teachername);
		//实际上是this.name和this.age和this.teachername
		
		show2();
		//实际上是this.show2();
		//意思是当前show1调用的对象继续调用show2
		
	}
	
	public void show2(){}
	poublic static void method(){//此处的静态方法却不会有this关键字
		//不可调用非静态的成员变量和成员方法
		sout("静态方法");
	}
	

}

public class StudentTest(){		
	public static void main(String[] args){
		Student.teachername = "老师姓名";
		
		Student s1 = new Student();
		sout("s1:" + s1);//地址值
		s1.name = "张三";
		s1.age = 23;
		s1.show1(); //此处的s1对应this
		
		Student s2 = new Stduent();
 sout("s2:" + s2);//地址值
		s2.name = "李四";
		s2.age = 24;
		s2.show1();//此处的s2对应this
		
	}
}

打印后，s1与this的地址值相同，s2与this的地址相同。

内存的加载

静态：随着类的加载而加载
非静态：与对象有关

main方法

	public class HelloWorld{
		public static void main(String[] args){
			//[]：数组
			//String:数据类型
			//args：数组名
			sout("HelloWorld");
		}
	}

public：被JVM调用，访问权限足够大
static：被JVM调用，不用创建对象，直接类名访问。
因为main方法是静态的，所以测试类中的其他方法也需要是静态的
void：被JVM调用，不需要给JVM返回值
main：一个通用的名称，不是关键字，但是被JVM识别
String[] args：以前用于接受键盘录入数据，现在没用

继承

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系
public class Student extends Person{}
Studet成为子类（派生类），Person称为父类（基类或超类）。 使用继承的好处：
- 可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性
- 子类可以在父类的基础上，增加其他的功能，使子类更强大。

？什么时候用继承： 当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种，就可以考虑用继承，来优化代码。

继承特点

Java只支持单继承，不支持多继承，但支持多层继承。

单继承：一个子类只能继承一个父类
不支持多继承：子类不能继承多个父类

[!NOTE] 每一个类都直接或间接继承于Object

[!WARNING]

构造方法不可被继承

成员变量私有和非私有都能被继承（私有不可直接使用）

成员方法只有非私有非static非final（能被加入虚方法表）能被继承

在继承中成员变量的访问特点

就近原则

public class Fu{
	String name = "Fu";
}
public class Zi extends Fu{
	String name = "Zi";//若没有此语句会打印Fu
	public void ziShow(){		
		String name = "ziShow";//若没有此语句会打印Zi
		sout(name); //ziShow...依次向上找name
	}
}

public class Fu{
	String name = "Fu";
}
public class Zi extends Fu{
	String name = "Zi";
	public void ziShow(){		
		String name = "ziShow";
		//局部->本类->父类
		sout(name); //ziShow
		sout(this.name);//Zi
		//this:本类
		sout(super.name);//Fu
		//super:父类
 }
}

[!IMPORTANT] name：从局部位置开始往上找… 局部 –> 本类 –> 父类 this.name：从本类成员位置开始往上找… 本类 –> 父类 super.name：从父类成员位置开始往上找…父类

在继承中成员方法的访问特点

直接调用满足就近原则，super调用直接访问父类 方法的重写： 当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式： 在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。 @Override重写注解 @Override是放在重写后的方法上，校验子类重写时语法是否正确。

方法重写的本质

A类——-继承——>B类—继承—>C类

子类覆盖了从父类继承下来的虚方法表里的方法

写入方法	A（method2）	B（method2）	C（method1，method2）
虚方法表	C：method1	C：method1	C：method1
	A：method2（）重写	B：method2（重写）	C：method2

[!NOTE] 1.重写方法的名称、形参列表必须与父类中的一致 2.子类重写父方法时.，访问权限子类必须大于等于父类（空 < protected < public） 3.子类重写父类方法时，返回值类型必须小于等于父类 4.重写的方法尽量和父类保持一致 5.只有被添加到虚方法表中的方法才能被重写

在继承中构造方法的访问特点

父类中的构造方法不会被子类继承，但是可以使用super调用。
子类中所有的构造方法默认先访问父类中的无参构造，在执行自己。（子类构造方法第一句默认是super()，不写也存在，若想调用父类有参构造，则必须使用super）
如果想要访问父类的有参构造，必须手动书写

this 与 super

this:理解为一个变量，表示当前方法调用者的地址值。 super:代表父类存储空间。

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量—访问本类成员变量	this.成员方法—访问本类成员方法	this(…)—访问本类构造方法
super	super.成员变量—访问父类成员变量	super.成员方法—访问父类成员方法	super(…)—访问父类构造方法

this()：

[!NOTE] 在子类中可以直接快捷使用构造函数

class Student{
 String name;
 int age;
 String school;
 Student(){
 	//表示调用本类的其他构造方法
 	//虚拟机不会再添加super();
 this(null,0,"默认大学");
 }

 public Student(String name, int age, String school) {
 	//因为调用之后此处有一个super();
 this.name = name;
 this.age = age;
 this.school = school;
 }
}

多态

同类型的对象，表现出不同的形态 表现形式：父类类型对象名称 = 子类对象; 前提： 1.有继承/实现关系
2.有父类引用指向子类对象
3.有方法重写
好处：使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

public class Test {
 public static void main(String[] args) {
 Student s = new Student("张三",18);
 Teacher t = new Teacher("王建国",22);
 Admin a = new Admin("管理员",20);

 register(s);
 register(t);
 register(a);
 }
 //接收老师，学生，管理员
 public static void register(Person p){
 	//在每一个子类中都重写了show方法
 	//p.show()，会直接指向子类的方法
 p.show();
 }
}

多态调用成员变量的特点

`父类类型 对象名称 = 子类对象;`

变量调用：编译看左边，运行也看左边

	//Animal 默认name为"动物"
	//Dog 默认name为"狗"
	Animal a = new Dog();
	//编译看左边：Javac编译代码的时候，会看左边的父类有没有这个变量，如果有，编译成功，反之失败
	//运行也看左边：Java运行代码的时候，实际获取的就是左边父类中成员变量的值
	sout(a.name);//动物

方法调用：编译看左边，运行看右边

	Animal a = new Dog();
	//编译看左边：Javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，反之失败
	//运行看右边：Java运行代码的时候，实际上运行的是子类中的方法
	a.show();//Dog---show方法

[!NOTE] 成员变量：在子类的对象中，会把父类的成员变量也继承下来。父：name，子：name（本质上时在内存中开辟了一个地址空间存储两个name） 成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖。

优点：使用父类型作为参数，可以接收所有子类对象
弊端：不能调用子类的特有功能（方法），但是可以通过强制转换解决

	Animal a = new Dog();
	Dog d = (Dog)a;//大范围 -> 小范围	
	
	//判断对象是不是某一个类中的 instanceof
	if(a instanceof Dog){
		Dog d = (Dog)a;
		d.lookHome();
	}else if{
		Cat c = (Dog)a;
		c.catchMouse();
	}else{
		sout("没有这个类型，无法转换");
	}
	
	//新特性
	if(a instanceof Dog d){
//		Dog d = (Dog)a;
		d.lookHome();
	}else if(a instanceof Cat c){
//		Cat c = (Dog)a;
		c.catchMouse();
	}else{
		sout("没有这个类型，无法转换");
	}

包

包就是文件夹，用来管理不同类的Java类，方便后期代码维护 ~~包名一般都用小写~~ 使用其他类的规则： 1.使用同一个包中的类时，不需要导包
2.使用Java.lang包中的类时，不需要导包
3.其他情况都需要导报
4.如果同时使用两个包的同名类，需要用全类名

全类名：包名 + 类名

final

方法：表明该方法时最终方法，不能被重写
类：表明该类是最终类，不能被继承
变量：叫做常量，只能被赋值一次 (c/c++中的const)

[!TIP] 常量的命名规范单个单词：全部大写多个单词：全部大写，单词之间用下划线隔开

[!NOTE] final修饰的变量是基本类型：那么变量存储的数据值不能发生改变
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变（静态指针）

	//记录的地址值不能发生改变
	final Student S = new Student("张三",23);
	//	S = new Student(); ！报错
	S.setName("李四"); // 对象内部可以改变

补充：字符串不可变的原因是String是由final和private存储的数组

权限修饰符

控制一个成员能够被访问的范围
可以修饰成员变量，方法，构造方法，内部类。

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
空着不写（默认）	√	√
protected	√	√	√
public	√	√	√	√

代码块

构造代码块：从多个构造方法中抽取重复代码，而且会先于构造方法的执行

静态代码块

格式：static{} 特点：需要static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次。

	static{
		sout("执行静态代码块");
		//随着类的加载而加载，并且只执行一次。
	}

应用：数据初始化

 //sattic里面只能用static
	static ArrayList<Student>list = new ArrayList<>();
	static{
		sout("初始化");
	}
	
	public staic void main(String[] args){
		...
	}

抽象类和抽象方法

抽象类: 是一种不能被实例化的类，它主要用于定义其他类（子类）的共同接口和部分实现.

抽象方法一定在抽象类中
抽象类不一定含有抽象方法.

抽象类的主要特点： 1.不能实例化：抽象类本身不能创建对象，只能作为父类被继承
2.可以包含抽象方法：抽象方法只有声明，没有具体实现，必须由子类实现
3.可以包含具体方法：抽象类也可以有已实现的方法，供子类直接使用或重写
4.子类必须实现所有抽象方法：如果子类没有实现父类的所有抽象方法，那么子类也必须是抽象类

接口

接口用关键字**~~interface~~**来定义
public interface 接口名{}
接口不能实例化
接口和类之间是实现关系，通过**~~implements~~**关键字表示
public class 类名 implement 接口名{}
接口的子类（实现类）要么重写接口中的所有抽象方法要么是抽象类

[!NOTE] 1.接口和类的实现关系，可以单实现，也可以多实现。 public class 类名 implements 接口名1，接口名2{} 2.实现类还可以在继承一个类的同时实现多个接口。 public class 类名 extends 父类 inplements 接口名1，接口名2{}

成员特点和接口中的各种关系

接口中成员的特点

成员变量

只能是常量默认修饰符：public static final
构造方法：没有
成员方法只能是抽象方法默认修饰符：public abstract
JDK7以前：接口中只能定义抽象方法
JDK8的新特性：接口中可以定义有方法体的方法
JDK9的新特性：接口中可以定义私有方法

接口和类的关系

类和类的关系

继承关系，只能单继承，不能多继承，但是可以多层继承

类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类同时实现多个接口

接口和接口的关系

继承关系，可以单继承，也可以多继承

接口中的默认方法

格式： public default 返回值类型方法名（参数列表）{ }

接口中默认方法的注意事项

1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
2.public可以省略，default不能省略
3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写。

接口中的静态方法

JDK8以后允许在接口中国定义静态方法，需要用static修饰

接口中静态方法的额定义格式：
-　格式: public static 返回值类型　方法名（参数列表）{ }
-　范例: public static void show(){ }

注意事项：

静态方法只能通过接口名调用，不能同故宫实现类名或者对象名调用
public可以省略，static 不可以省略
JDK9以后接口中出现了私有方法

privbate 返回值类型方法名（参数列表）{} private void show(){ }
private static 返回值类型方法名（参数列表）{} private static void method(){ }

public interface InterA {
 public static void show1(){
 System.out.println("show1方法开始执行了");
 show3();
 }
 public static void show2(){
 System.out.println("show2方法开始执行了");
 show3();
 }
 public static void show3(){
 	//必须是static
 	//若上述show1,show2是default，则不需要static
 System.out.println("记录程序运行时的各种细节");
 }
}

[!NOTE] 静态的私有方法，为静态方法服务普通的私有方法，为默认方法服务

接口的应用（接口多态）

接口类型 j = new 实现类对象(); 编译看左，运行看右

适配器设计模式

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解，保证代码的可靠性、程序的重用性。（设计模式就是多种套路）
适配器设计模式：解决接口与接口实现类之间的矛盾问题

public interface Inter {
 public abstract void method1();
 public abstract void method2();
 ...
 public abstract void method10();
}

//在此创建父类来使InterImpl更加简洁
public abstract class InterAdapter implements Inter {
 //abstract 不让外界创建对象
 @Override
 public void method1() {}
 public void method2();
 ...
 @Override
 public void method10() {}
}

public class InterImpl extends InterAdapter{
 //需要用到哪个方法就重写哪个方法

 @Override
 public void method5() {
 System.out.println("第五个方法");
 }
}

Inter定义了多个抽象方法，但是测试类只需要调用其中的一个方法method5()，于是添加一个类（作为测试类的父类）去重写所有方法，这样测试类就可以按需重写方法了。其中添加的这个类就是适配器

内部类

类的五大成员：属性，方法，构造方法，代码块，内部类
内部类分为：成员内部类，静态内部类，局部内部类，匿名内部类
在A类的内部定义B类，B类就被成为内部类
内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

访问特点

内部类可以直接访问外部类的成员，包括私有private
外部类要访问内部类的成员，必须创建对象。

成员内部类

写在成员位置的，属于外部内部类
成员内部类可以被一些修饰符修饰，private、默认、protected、public、static等（用static修饰就是静态内部类了）

获取成员内部类对象的两种方式：
方式一：外部类编写方法，对外提供内部类对象
方式二：直接创建
格式 Outer.Inner oi = new Outer().new Inner();

成员内部类获取外部类的成员变量

public class Outer {
 private int a = 10;//<----sout(Outer.this.a)
 class Inner {
 private int a = 20;//<----sout(this.a)
 private void show() {
 int a = 30;//<----sout(a)
 System.out.println(a);
 System.out.println(this.a);
 System.out.println(Outer.this.a);//此处的Outer是类名
 }
 }
}

静态内部类

是用static修饰的成员内部类
静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象

创建静态内部类对象的格式： 外部类名.内部类名. 对象名 = new 外部类名.内部类名 ();
Outer.Inner oi = new Outer.Inner();

调用非静态方法的格式：
先创建对象，再对象调用

调用静态方法的格式：
外部类名.内部类名.方法名();

局部内部类（了解）

1.将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量
2.外界是无法直接使用，需要在方法内部创建对象使用
3.该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类**

匿名内部类本质上是隐藏了名字的内部类

	new 类名或接口名(){
		重写方法;
	};
	//注意有分号

接口（实现关系）

public class Student implements Swim(){	
	@Override
	public void swim(){
		sout("重写的swim方法");
	}
}
//1.把前面的class去掉，剩余的内容变成了一个没有名字的类
//2.这个没有名字的类想要实现Swim接口 
//把Swim写在了大括号的前面，表示这个没有名字的类实现了Swim接口，所以需要在类中重写接口里面的所有抽象方法。

	new Swim(){
		@Override
		public void swim(){
			sout("重写的swim方法")
		}
		//这一部分(匿名内部类的对象)是没有名字的类(Student)，他来实现Swim接口
	};

类名（继承关系）

	new Animal(){
		@Override
		public void eat(){
			sout()
		}
	}

应用/拓展

public class Test {
 public static void main(String[] args) {
 //整体理解为Swim接口的实现类对象
 //接口多态：接口类型 j = new 实现类对象();
 Swim s = new Swim(){
 @Override
 public void swim() {
 System.out.println("重写之后的swim方法");
 }
 };
 //编译看左边，运行看右边
 s.swim();


 new Swim(){
 @Override
 public void swim() {
 System.out.println("重写之后的swim方法");
 }
 }.swim();//自己调用自己

 }
}

格式的细节： 包含了继承或实现，方法重写，创建对象。整体就是一个类的子类对象或者接口的实现类对象 使用场景： 当方法的参数是接口或者类时。以接口为例，可以传递这个接口的实现类对象如果实现类只要使用一次，就可以用匿名内部类简化代码

API

Tue, 03 Feb 2026 00:00:00 +0000

API

应用程序编程接口
API就是别人写好的东西，我们不需要自己编写，直接使用即可例如： Random r = new Random();
Scanner sc = new Scanner();

Java API：JDK中提供的各种功能的Java类

System

public static void exit(int status) 终止当前运行的Java虚拟机 public static long currentTimeMillis() 返回当前系统的时间（毫秒） public static void arraycopy(数据源数组,起始索引,目的地数组,起始索引,拷贝个数) 数组拷贝（地址值）

Runtime

Runtime表示当前虚拟机的运行环境
public static Runtime getRuntime() 当前系统的运行环境对象
public void exit(int status) 停止虚拟机
public int availableProcessors() 获取CPU线程数
public long maxMemory() JVM能从系统中获取总内存大小byte
public long totalMemory()JVM已经从系统中获取总内存大小byte
public long freeMemory() JVM剩余内存大小byte public Process exec(String command) 运行cmd命令

Object

public boolean equals(Objects obj) 比较地址值
public String toString() 返回对象的字符串表示形式
protected object clone(int a) 对象克隆

		String s = "abc";
 StringBuilder sb = new StringBuilder("abc");
 System.out.println(s.equals(sb));//false
 
 *String中的equals方法会先判断参数是否为字符串*
 *是字符串再比较内部属性*
 
 System.out.println(sb.equals(s));//false
 *StringBuilder仅比较地址值*
 
 (String)
 public boolean equals(Object anObject) {
 if (this == anObject) {
 return true;
 }
 return (anObject instanceof String aString)
 && (!COMPACT_STRINGS || this.coder == aString.coder)
 && StringLatin1.equals(value, aString.value);
 	}
 
 (StringBuilder{Object的方法})
 public boolean equals(Object obj) {
 	return (this == obj);
 	}

克隆clone

对象克隆：把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制

第一种克隆方式（浅克隆）

不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
Cloneable
如果一个接口里面没有抽象方法，表示当前的接口是一个可标记接口，现在Cloneable表示一旦实现了那么当前的对象就可以被克隆
如果没有实现，当前类的对象就不能克隆

public static void main(String[] args) throws CloneNotSupportedException {
 Student s1 = new Student("zhangsan",18);
 Object s2 = (Student)s1.clone();
 System.out.println(s1);//@23fc625e
 System.out.println(s2);//@3f99bd52
 System.out.println(s1 == s2);//false
}

	@Override（写在JavaBean中）
 protected Object clone() throws CloneNotSupportedException {
 return super.clone();
}

	/*	1.重写Object中的clone方法
		2.让JavaBean类实现Cloneable接口
		3.创建原对象调用clone	*/

[!NOTE] 浅克隆（引用数据类型）用的是相同的地址值，当其中一个对象修改该引用类型字段的内容时另一个对象也会受到影响，可能导致数据不一致的问题。

第二种克隆方式（深克隆）

基本数据类型拷贝过来
字符串复用
引用数据类型会重新创建新的

[!NOTE] 基本数据类型：直接克隆对象引用数据类型：创建一个新的对象注：String 深克隆时用串池地址（原地址），只有在改变后才会创建新String对象，因为String本身不可变 此时的data记录新数据的地址值

Objects

public static boolean equals(Object a,Object b)先做非空判断，比较两个对象

public static boolean isNull(Object obj)判断对象是否为null，null->true

public static boolean nonNull(Object obj)判断对象是否为null，与isNull的结果相反

import java.util.Objects; 
public class TestDemo { 
 public static void main(String[] args) throws CloneNotSupportedException { 
 Student s1 = null; 
 var s2 = new Student("zhangsan",23); 
 boolean res = Objects.equals(s1,s2); 
 System.out.println(res); 
 //方法的底层会判断n1 ?= null，如果为null，直接返回false 
 //如果s1不为null，那么就利用s1再次调用equals方法 
 //此时s1是Student类型，所以最终还是会调用Student中的equals方法 
 //未重写->比较地址值 重写->比较属性值 
 } 
}

BigInteger和BigDecimal

BigInteger的构造方法

public BigInteger(int num,Random rnd)获取随机大整数，范围:[0~2的num次方-1]

public BigInteger(String val) 获取指定的大整数

public BigInteger(String val,int radix)获取指定进制的大整数

public static BigInteger valueOf(long val)静态方法获取BigInteger的对象，内部有优化(-1~~16,1~~16)

[!NOTE] 对象一旦创建，内部的数据不能发生改变

BigInteger bd1 = new BigInteger.valueOf(1);
BigInteger bd2 = new BigInteger.valueOf(2);
BigInteger res = bd1.add(bd2);//产生一个新对象
//res = 3;

BigInteger的成员方法

BigDemical

常用方法

表示的数字不大(没有超出double) -> 使用静态方法 public static BigDecimal valueOf(double val)
表示的数字比较大(超出double) -> 使用构造方法 BigDecimal bd = new BigDecimal(String val)

[!NOTE] 如果传递的是[0,10]之间的数，那么方法会返回已经创建好的对象（不会new）

[!NOTE] 注：divide除法方法必须除尽，否则会报错

舍入模式	说明
UP	远离0方向舍入的舍入模式(<- ->)
DOWN	靠近0方向舍入的舍入模式(-> <-)
CEILING	向正无穷大方向舍入（ -> ）
FLOOR	向负无穷大方向舍入 ( <- )
HALF_UP	四舍五入

正则表达式（regex）

(?i)abcd会忽略abcd的大小写
a(?i)bcd会忽略bcd的大小写
a((?i)b)cd会忽略b的大小写

Date时间类

	//简单时间类
	Date d1 = new Date();//获取当前时间
	Date d2 = new Date(0L)//获取初始时间+0ms后的时间Thu Jan 01 08:00:00 CST 1970
	d2.getTime().sout;//0
	Date d3 = new Date(1000L)//获取初始时间+1000ms后的时间Thu Jan 01 08:00:01 CST 1970
	d3.getTime().sout;//1000

SimpleDateFormat类

format格式化：把时间转换成指定格式
parse解析：把字符串表示的时间变成Date对象

构造方法

==public SimpleDateFormat() 使用默认格式==

	SimpleDateFormat sdf = new SimpleDateFormat(); 
	Date date = new Date(0L);
	String str = sdf.format(date); 
	System.out.println(str);
	
	默认格式：1970/1/1 08:00

==public SimpleDateFormat(String Pattern) 使用指定格式==

	SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEEE"); 
	Date date = new Date(0L); 
	String str = sdf.format(date); 
	System.out.println(str);
	
	指定格式：1970年01月01日 08:00:00 星期四

字母	描述 (Description)	示例 (Output)	备注 (Note)
G	年代标志 (Era)	AD (公元)	通常用于历史日期
y	年 (Year)	2026; 26	`yy` 是两位年，`yyyy` 是四位年
u	纪元年 (Year)	2026	在 `java.time` 中比 `y` 更严谨
M	月份 (Month)	07; Jul; July	大写；`MM` 为数字，`MMM` 为缩写
L	独立月份 (Month)	7; July	常用于特定语言环境的格式化
d	月中天数 (Day)	10; 05	小写；该月中的第几天
D	年中天数 (Day)	189	该年中的第几天 (1-366)
E	星期 (Day in week)	Tue; Tuesday	星期几的文本描述
e	星期数字 (Day of week)	2	1 (周一) 到 7 (周日)
a	上下午标记 (AM/PM)	PM	上午或下午
H	24小时制小时	0-23	大写；常用于服务器日志
h	12小时制小时	1-12	小写；需配合 `a` 使用
m	分钟 (Minute)	30	小写；不要和月份 `M` 搞混
s	秒 (Second)	55	秒数
S	毫秒 (Fraction)	978	毫秒或纳秒的零头
n	纳秒 (Nano)	500000	仅限 Java 8+ 的 `java.time`
z	时区 (Time Zone)	CST; PST	通用时区名称
Z	时区偏移 (Offset)	+0800	RFC 822 格式
X	ISO 8601 时区	Z; +08; +08:00	现代 API 推荐使用的时区格式

常用方法

==public final String format(Date date) 格式化（日期对象 -> 字符串)==
==public Date parse(String source) 解析（字符串 -> 日期对象）==

Calendar类

Calendar代表了系统当前时间的日历对象，可以单独修改、获取事件中的年月日
Calendar是一个抽象类，不能直接创建对象，需要通过一个静态方法获取到子类对象

get/set/add方法

	Calandar c = Calandar.getInstance();
	c.get(Calandar.YEAR);
	c.set(Calandar.YEAR,11)//实际为12月
	c.add(Calandar.YEAR,1)//实际为次年1月

数字	常量名	含义	注意事项
1	Calendar.YEAR	年	-
2	Calendar.MONTH	月	从 0 开始。0表示1月，11表示12月。
5	Calendar.DATE / DAY_OF_MONTH	日	两个常量效果一样。
10	Calendar.HOUR	小时	12小时制。
11	Calendar.HOUR_OF_DAY	小时	24小时制。
12	Calendar.MINUTE	分钟	-
13	Calendar.SECOND	秒	-
7	Calendar.DAY_OF_WEEK	星期	周日是1，周一是2，周六是7。

包装类

基本数据类型所对应的对象

Integer

Integer缓存

Java的Integer类内部实现了一个静态缓存池，用于存储特定范围内的整数值对应的Integer对象。
默认情况下，这个范围时-128至127。当通过Integer.valueOf(int)方法创建一个在这个范围内的整数对象时，并不会每次都生成新的对象实例，而是复用缓存中的现有对象，会直接从内存中取出，不需要新建一个对象。
目的：节约内存

JDK5以后

自动装箱、自动拆箱
直接赋值获取对象
计算时不需要new，不需要调用方法，直接赋值即可

	Integer i1 = 10;
	Integer i2 = 20;
	Integer i3 = i1 + i2;//底层：先拆箱 -> 计算 -> 再装箱赋值给i3

Integer成员方法

Arrays

Arrays.binarySearch()

查找的元素存在，就返回真实的索引
查找的元素不存在，就返回( -插入点 - 1 )

	int[] a = {1,2,3,4,5,6,7,8,9,10};
	Arrays.binarySearch(arr,10);//9
	Arrays.binarySearch(arr,100)//-11

Arrrays.copyOf()

if(新数组len < 老数组len) 会部分拷贝
if(新数组len = 老数组len) 会完全拷贝
if(新数组len > 老数组len) 会补上默认初始值(int[] 补0)

	int[] a = {1,2,3,4,5,6,7,8,9,10};
	int[] newa = Arrays.copyOf(a);

Arrrays.copyOfRange()

包左不包右（左闭右开）

	int[] a = {1,2,3,4,5,6,7,8,9,10};
	int[] newa = Arrays.copyOfRange(a,0,9);
	//1 2 3 4 5 6 7 8 9

Arrays.fill()

	int[] a = {1,2,3,4,5,6,7,8,9,10};	
	Arrays.fill(a,100);//100 100 100 ...

Arrays.sort()

对基本类型快速排序

	Arrays.sort(a);//升序

重载

只能对引用数据类型排序
o1：表示在无序序列中，遍历得到的每一个元素
o2：表示有序序列中的元素
返回值
- 负数：表示当前要插入的元素是小的，放在前面
- 正数：表示当前要插入的元素是大的，放在后面
- 0 ：一样大，放在后面

	Integer[] a = {2,7,5,4,5,6,7,8,9,31}; 
Arrays.sort(a,newComparator<Integer>() { 
	@Override 
	public int compare(Integer o1, Integer o2) { 
		return o1-o2; 
	} 
});

Lambda表达式

( )对应方法的形参
-> 固定格式
{ } 对应方法体

 Integer[] a = {2,7,5,4,5,6,7,8,9,31}; 
 Arrays.sort(a,(Integer o1, Integer o2) -> { 
 	return o1-o2; 
 } 
 );

>[!NOTE]
>lambda 表达式可以用来简化匿名内部类的书写（不是所有）
>lambda 表达式只能简化函数式接口的匿名内部类写法
>
>函数式接口：
>- **有且仅有一个抽象方法的接口**，接口上方可以加@FunctionalInterface的注解

```Java
	Integer[] a = {2,7,5,4,5,6,7,8,9,31}; 
Arrays.sort(a,(Integer o1, Integer o2) -> { 
		return o1-o2; 
	} 
);

package MyTestDemo2; 
public class TestDemo{ 
 public static void main(String[] args){ 
 method(()->{ 
 System.out.println("lambda:"); 
 System.out.println("swimming"); 
 }); 
 } 
 public static void method(swim s){ 
 s.swimming(); 
 } 
} 
@FunctionalInterface
interface swim{ 
 public void swimming(); 
}

可推导，可省略

	Integer[] a = {2,7,5,4,5,6,7,8,9,31}; 
	Arrays.sort(a,(o1,o2) -> o1-o2);//升序
	Arrays.sort(a,(o1,o2) -> o2-o1);//倒序

基本算法

Tue, 03 Feb 2026 00:00:00 +0000

插值查找

前提是数据有顺序

	int[] list = {7,23,79,81,103,127,131,147}; 
	int l = 0; 
	int r = list.length - 1; 
	int x = sc.nextInt(); 
	int mid;
	while (l <= r && x >= list[l] && x <= list[r]) {
	// 先乘后除
		mid = l + (x - list[l]) * (r - l) / (list[r] - list[l]);

		if (x == list[mid]) {
			System.out.println("找到了，索引为：" + mid);
			break;
		} else if (x > list[mid]) {
			l = mid + 1;
		} else {
			r = mid - 1;
		}
	}

插值查找优点：对于均匀分布的数组，速度极快（时间复杂度接近 $O(\log(\log n))$）。
插值查找缺点：如果数据分布极不均匀（比如：{1, 2, 3, 100, 1000, 10000}），插值查找的性能可能还不如二分查找。

冒泡排序

相邻的数据两两比较
if(a[i] > [j]) swap(a[i],a[j])

选择排序

从0索引开始，拿着每一个索引上的元素跟后面的元素一一比较，小的放前面，大的放后面。
第一轮循环，确定确定了最小元素

插入排序

分为有序组和无序组
将无序组逐个插入有序组中

public class TestDemo { 
 public static void main(String[] args) { 
 int[] arr = {4,16,5,9,12,21,18, 
 32,23,37,26,45,34, 
 50,48,61,52,73,66}; 
 int startIndex = -1; 
 for (int i = 0; i < arr.length; i++) { 
 if(arr[i] > arr[i+1]){ 
 startIndex = i + 1; 
 break; 
 } 
 } 
 if(startIndex == -1){ 
 return ; 
 } 
 for(int i = startIndex; i < arr.length; i++){ 
 int j = i; 
 while(j > 0 && arr[j] < arr[j-1]) {//寻找正确的位置
 int temp = arr[j]; 
 arr[j] = arr[j - 1]; 
 arr[j - 1] = temp; 
 j--; 
 } 
 } 
 } 
}

递归

方法再次调用方法本身
递归一定要有出口，否则就会内存溢出

快速排序

第一轮：将0索引数字作为基准数，确定基准数在数组中的正确位置

// 快速排序主方法：递归分治 
private static void quickSort(int[] a, int l, int r) { 
 if(l < r){ 
 int mid_index = find(a,l,r); // 分区，返回基准值的正确索引 
 quickSort(a,l,mid_index-1); // 排序左子数组（小于基准） 
 quickSort(a,mid_index+1,r); // 排序右子数组（大于基准） 
 } 
} 
 
// 分区函数：选a[l]为基准，返回基准值的最终索引 
private static int find(int[] a, int l, int r) { 
 int pivot = a[l]; // 基准值（保存副本，避免被修改） 
 int left = l + 1; // 左指针：从基准下一位开始找大于pivot的元素 
 int right = r; // 右指针：从右边界开始找小于pivot的元素 
 
 while (true) { 
 // 右指针找小于基准值的元素（left<=right 防止越界） 
 while (left <= right && a[right] >= pivot) { 
 right--; 
 } 
 // 左指针找大于基准值的元素（left<=right 防止越界） 
 while (left <= right && a[left] <= pivot) { 
 left++; 
 } 
 
 // 左指针超过右指针，分区结束 
 if (left > right) { 
 break; 
 } 
 
 // 交换左右指针指向的元素（真正修改数组） 
 int temp = a[left]; 
 a[left] = a[right]; 
 a[right] = temp; 
 } 
 
 // 把基准值放到正确位置（right是小于基准区域的最后一位） 
 int temp = a[l]; 
 a[l] = a[right]; 
 a[right] = temp; 
 
 return right; // 返回基准值的最终索引 
}

集合进阶

Tue, 03 Feb 2026 00:00:00 +0000

Collection 接口（单列集合根接口）

	├─ List 接口（有序、可重复）
	│ ├─ ArrayList（实现类）：动态数组，查询快、增删慢
	│ ├─ LinkedList（实现类）：双向链表，增删快、查询慢
	│ └─ Vector（实现类）：动态数组，线程安全、性能差
	└─ Set 接口（无序、不可重复）
	 ├─ HashSet（实现类）：哈希表，无序去重
	 ├─ TreeSet（实现类）：红黑树，排序去重
	 └─ LinkedHashSet（实现类）：哈希表+链表，有序去重

 flowchart TD
 A[Collection<br/>（单列集合根接口）] --> B[List<br/>（有序、可重复）]
 A --> C[Set<br/>（无序、不可重复）]
 
 B --> B1[ArrayList<br/>（动态数组）]
 B --> B2[LinkedList<br/>（双向链表）]
 B --> B3[Vector<br/>（线程安全数组）]
 
 C --> C1[HashSet<br/>（哈希表）]
 C --> C2[TreeSet<br/>（红黑树）]
 C1 --> C3[LinkedHashSet<br/>（哈希表+链表）]
 
 %% 样式优化
 A:::root
 B:::subInterface
 C:::subInterface
 B1:::impl
 B2:::impl
 B3:::impl
 C1:::impl
 C2:::impl
 C3:::impl
 classDef root fill:#f9f,stroke:#333,stroke-width:2px
 classDef subInterface fill:#9ff,stroke:#333,stroke-width:2px
 classDef impl fill:#ff9,stroke:#333,stroke-width:1px

Collection

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的
Collectio是一个接口，不能直接创建它的对象，只能创建实现类的对象

[!WARNING] contains方法在底层依赖equals方法

如果是自定义对象，那么必须在JavaBean重写equals方法

遍历

迭代器遍历

Iterator<E> iterator() 返回迭代器对象，默认指向当前集合的0索引
boolean hasNext() 判断当前位置是否有元素
E next() 获取当前位置元素，并将迭代器对象移向下一个位置

	Iterator<String> it = list.iterator();
	while(it.hasNext()){
		String str = it.next();
		System.out.println(str);
	}

[!NOTE]

报错NoSuchElementException

迭代器遍历完毕，指针不会复位（第二次遍历集合需重新获取iterator）

迭代器遍历时，不能用集合的方法进行增加或者删除，只能用it.remove()

增强for遍历

底层就是一个迭代器
修改增强for中的变量，不会改变集合中原本的数据

	Collection<String> coll = new ArrayList<>();
	for(String s : coll){
		System.out.println(s);
	}

lambda表达式遍历

	coll.forEach(s -> System.out.println(s));

List

元素有序，可重复，有索引

add/remove

	List<String> L = new ArrayList<>(); 
	L.add("aaa"); 
	L.add("bbb"); 
	L.add("ccc"); 
	 
	L.add(1,"ddd");//在指定位置插入元素，原位置以后的元素依次往后移
	//aaa ddd bbb ccc
	
	String remove = L.remove(0);//aaa
	boolean remove = L.remove("aaa");//true

[!NOTE] 当List存储对象为Integer时，使用remove(1),会优先删除索引为1的元素由于 int 是基本数据类型，编译器会优先匹配参数类型最精确的方法

解决方法：

手动装箱list.remove(Integer.valueOf(1));

向上转型list.remove((Object) 1);

set/get

set(int index,E element) 修改索引处的元素，返回修改前的元素
get(int index)返回索引上的元素

遍历方式

迭代器遍历
增强for遍历
lambda表达式遍历
普通for循环遍历
列表迭代器遍历

列表迭代器遍历

ListIterator<E> extends Iterator<E>

列表迭代器方法

add<E e>
hasNext()
next()
remove()
hasPrevious()与hasNext()相反
previous()与next()相反
在遍历的过程中可以添加元素

 ListIterator<String> it = L.listIterator(); 
 while(it.hasNext()){ 
 if("aaa".equals(it.next())){ 
 it.add("qqq"); 
 }
 //aaa qqq bbb ccc
 }

ArrayList底层原理

底层是数组结构的
利用空参创建的集合，在底层创建一个默认长度为0得分数组
添加第一个元素，底层会创建一个新的==长度为10==的数组（elementData），初始化为null
存满时，会扩容==1.5倍==（向下取整）
如果一次添加多个元素，1.5倍放不下，则新创建数组的长度以实际为准。

public boolean add(E e) { 
 modCount++; 
 add(e, elementData, size);
 return true; 
}

private void add(E e, Object[] elementData, int s) { 
 if (s == elementData.length) 
 elementData = grow(); 
 elementData[s] = e; 
 size = s + 1; 
}

private Object[] grow() { 
 return grow(size + 1); 
}

[!NOTE]

对于if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)

oldCapacity > 0 负责处理已经长大的数组；

elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA 负责处理被用户手动指定为 0 的数组。

只有这两个条件都不满足（即：既是 0 又是默认空数组），才会触发“初始 10”的逻辑。

private Object[] grow(int minCapacity) { 
 int oldCapacity = elementData.length; 
 if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
 int newCapacity = ArraysSupport.newLength(oldCapacity, 
	 minCapacity - oldCapacity, /* minimum growth */ 
		 oldCapacity >> 1 /*默认新增容量*/); 
 return elementData = Arrays.copyOf(elementData, newCapacity);
 } else { 
 return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)]; 
 } 
}

public static int newLength(int oldLength, int minGrowth, int prefGrowth) { 
 // 由于内嵌原因未勾选前提条件
 // assert oldLength >= 0 // assert minGrowth > 0 
 int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // 可能会溢出来 
 if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) { 
 return prefLength; 
 } else { 
	 // 用另一个方法冷处理代码
 return hugeLength(oldLength, minGrowth); 
 } 
}

 graph TD
 A[开始添加元素] --> B[modCount自增]
 B --> C{所需容量超过数组长度?}
 
 %% 扩容分支
 C -- 是 --> D[调用grow方法]
 D --> E[计算新容量：旧容量1.5倍]
 E --> F{新容量满足最小需求?}
 F -- 否 --> G[新容量设为最小需求]
 G --> H[检查是否超JVM限制]
 F -- 是 --> H
 H --> I[迁移数据到新数组]
 I --> J[更新elementData引用]
 
 %% 插入分支
 C -- 否 --> K[元素放入数组对应位置]
 J --> K
 K --> L[size自增]
 L --> M[返回true]
 M --> N[结束]

LinkedList集合

底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快

Iterator迭代器

modCount (Modification Count)：属于 ArrayList 对象。只要列表结构发生变化（add, remove, clear 等），这个计数器就会 +1。
expectedModCount：属于 Itr（迭代器）对象内部。在创建迭代器的那一刻，它会把当时的 modCount “拍照”存下来：expectedModCount = modCount

Set

添加的元素无序，不重复，无索引
Set接口中的方法基本上与Collection一致（remove方法只能根据对象删除，不能根据索引删）

HashSet 哈希表

JDK8之前：数组+链表
JDK8之后：数组+链表+红黑树

哈希值

应该存入的位置 int index = (数组长度 - 1) & 哈希值
该方法定义在Object类中，所有对象都可以调用，默认使用地址值进行计算
一般情况下，会重写hashCode方法，利用对象内部的属性值计算哈希值

对象哈希值的特点

如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
如果已经重写hashCode方法，不同对象只要属性值相同，计算出的哈希值就是一样的
在小部分情况下，不同属性值或者不同的地址值计算出来的哈希值也有可能一样（哈希冲突）

	System.out.println("abc".hashCode()); //96354
	System.out.println("acD".hashCode()); //96354

底层原理

先创建一个默认长度为16，默认加载因子为0.75的数组table
加载因子：存入第 16 * 0.75 = 12 个元素时，会触发扩容
0.75 是在频繁扩容的开销与查询延迟之间找到的黄金平衡点。
根据元素的哈希值跟数组长度计算出应存入的位置
判断当前的位置是否为null

 if null -> 存入
 else -> 调用equals方法比较属性值

 if true -> 不存
 else -> 存入数组，形成链表 
 JDK8以前：新元素存入数组，老元素挂在新元素下面
 JDK8之后：新元素直接挂在老元素下面

JDK8以后，当链表长度超过8，而且数组长度大于等于64时，自动转换为红黑树

如果集合中存储的是自定义对象，必须要重写hashCode () 和equals () 方法(默认比较用的是地址值)

HashSet的三个特点

HashSet为什么存和取的顺序不一样？

HashSet 存取顺序不一致，是因为它根据元素内容的 Hash 值经计算后直接存放在内部数组的随机位置，而非按时间先后排队；
读取时则是按数组下标从头到尾扫描，所以输出顺序取决于元素在内存中的分布位置，而非输入顺序

HashSet为什么没有索引？

HashSet 没有索引是因为它采用哈希表结构，元素是根据内容计算出的哈希值“随机”散落在数组位置上的，中间存在大量空位且位置会随扩容改变，这种非连续、非固定的存储方式使得通过物理位置（索引）定位元素变得毫无意义

HashSet是利用什么机制保证数据去重的？

HashSet 通过 hashCode() 快速定位存储位置，若位置冲突再利用 equals() 进行内容“肉搏”比对，只有当两个方法都判定相同时，才会触发去重机制拒绝存入。

LinkedHashSet

有序，不重复，无索引
这里的有序指的是保证存储和去除的元素顺序一致
原理：底层数据机构依然是哈希表，知识每个元素有额外多了一个==双链表==的机制记录存储的数据
如果要求去重且存取有序，则选择LinkedHashSet

TreeSet

可排序，不重复，无索引
可排序：按照元素的默认规则（由小到大）排序
TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好

TreeSet默认的规则

对于数值类型：Integer，Double，默认按照从小到大的顺序进行排序
对于字符、字符串类型：按照字符在ASCII码表中的数字升序进行排序

@Override 
public int compareTo(Student o) { 
 return this.getAge()-o.getAge(); 
}
	this:表示当前要添加的元素
	o :表示已经在红黑树存在的元素
返回值：
	负数：认为要添加的元素是小的，存左边
	正数：认为要添加的元素是大的，存右边
	0：要添加的元素已存在，舍弃

TreeSet的两种比较方式

方式一

默认排序/自然排序：JavaBean类实现Comparable接口指定比较规则

方式二

比较器排序：创建TreeSet对象的时候，传递比较器Comparator制定规则

使用规则

默认使用第一种，如果第一种不能满足当前需求，就使用第二种

List与Set的使用场景

如果想要集合中的元素*可重复：
- 用ArrayList集合，==基于数组的==（用的最多）
如果想要集合中的元素可重复，而且当前的增删操作明显多于查询：
- 用LinkedList集合，==基于链表的==
如果想对集合中的元素去重：
- 用HashSet，==基于哈希表的==（用的最多）
如果相对集合的元素去重，而且保证存取顺序
- 用LinkedHashList集合，==基于哈希表和双链表，效率低于HashSet==

泛型

可以在编译阶段约束操作的数据类型，并进行检查
格式：<数据类型>
泛型只能支持引用数据类型
==统一数据类型==，把运行时期的问题提前到了编译期间，避免了强制类型转化可能出现的异常
==Java中的泛型是伪泛型==

注意！

泛型中不能写基本数据类型
指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
如果不写泛型，类型默认是Object

泛型类

public class MyArrayList<E>{ 
 Object[] obj = new Object[10]; 
 int size; 
 public boolean add(E e){ 
 obj[size++] = e; 
 return true; 
 } 
 public E get(int index){ 
 return (E)obj[index]; //存入ArrayList的数据都会变成Object
 } 
 @Override 
 public String toString(){ 
 return Arrays.toString(obj); 
 } 
}
	//此处的E可以理解为变量，但是不是用来记录数据的，是用来记录数据类型的,一般用：K、T、V、E

泛型方法

方法中形参不确定时
- 1.使用类名后面定义的泛型 -> 所有方法都能用
- 2.在方法申明上定义自己的泛型 -> 只有本方法能用

public <T> boid show(T t){
	|此处的E可以理解为变量，但是不是用来记录数据的，是用来记录数据类型的,一般用：K、T、V、E|
}

public class ListUtil{ 
 private ListUtil() {} 
 /* 
 * 参数一：集合 
 * 参数二：要添加的元素 
 * */ 
 public static<E> void addAll(ArrayList<E> list,E...e){ 
 for (E element : e) { 
 list.add(element); 
 } 
 } 
}

泛型接口

实现类给出具体类型

public class MyArrayList implements List<String> {
}

实现类延续泛型，创建对象时再确定

public class MyArrayList<E> implements List<E> {
}

泛型的继承和通配符

==泛型不具备继承性，但数据具备继承性==

	通配符
	<? extends E> 表示可以传递E或者E所有的子类类型
	
	<? super E> 表示可以传递E或者E所有的父类类型

Map

 flowchart TD
 A[Map<br/>（双列集合根接口）] --> B[HashMap<br/>（哈希表）]
 A --> C[TreeMap<br/>（红黑树）]
 A --> D[Hashtable<br/>（线程安全哈希表）]
 A --> E[LinkedHashMap<br/>（哈希表+链表）]
 
 D --> D1[Properties<br/>（属性集）]
 
 %% 保持和Collection流程图一致的样式
 A:::root
 B:::impl
 C:::impl
 D:::impl
 E:::impl
 D1:::impl
 classDef root fill:#f9f,stroke:#333,stroke-width:2px
 classDef subInterface fill:#9ff,stroke:#333,stroke-width:2px
 classDef impl fill:#ff9,stroke:#333,stroke-width:1px

常见API

遍历

通过键k找值v

	Set<String> keys = map.keySet();
	
	//遍历单列集合，得到每一个键
	for (String key : keys) { 
 System.out.println(map.get(key)); 
	}
	
	//迭代器遍历
	Iterator it = keys.iterator(); 
	while(it.hasNext()){ 
	 String key = (String)it.next(); 
	 System.out.println(key+":"+map.get(key)); 
	}
	
	//lambda表达式遍历
	keys.forEach(key -> System.out.println(map.get(key)));

键值对对象遍历

	//Set存储键值对
	Set<Map.Entry<String, String>> es = map.entrySet();
	//Entry是Map的内部接口
	
	//遍历每一个键值对对象
	for (Map.Entry<String, String> e : es) { 
	
	 String key = e.getKey(); 
	 String value = e.getValue(); 
	 
	 System.out.println(key + ":" + value); 
	}
	
	//遍历迭代器
	Iterator <Map.Entry<String,String>> it = es.iterator(); 
	while(it.hasNext()){ 
	 Map.Entry<String,String> entry = it.next(); 
	 String key = entry.getKey(); 
	 String value = entry.getValue(); 
	 System.out.println(key+":"+value); 
	}
	
	//lambda表达式
	es.forEach(e -> System.out.println(e.getKey()+":"+e.getValue()));

lambda表达式遍历

	map.forEach(new BiConsumer<String, String>() { 
	 @Override 
	 public void accept(String k, String v) { 
	 System.out.println(k+ ":" +v); 
	 } 
	});
	-----------------------
	map.forEack((key,value) -> System.out.println(k+":"+v));

HashMap

HashMap 是 Map 的一个实现类
特点都是由键决定的：无序，不重复，无索引
HashMap 与 HashSet 的底层原理是一样的，都是哈希表
HashMap的键位置如果存储的是自定义对象，需要重写hashCode和equals

样例

	默认的hashCode和equals方法
	@Override 
	public boolean equals(Object obj) { 
	 if(this == obj) return true; 
	 if(obj == null || getClass() != obj.getClass() ) return false; 
	 Student student = (Student)obj; 
	 return name.equals(student.name) && age == student.age; 
	} 
	
	@Override 
	public int hashCode() { 
	 return Objects.hash(name,age); 
	}

LinkedHashMap

由键决定：有序、不重复、无索引
这里的有序值得是保证存储和去除的元素一致
原理：底层数据结构依然是哈希表，只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序

TreeMap

TreeMap跟TreeSet的底层原理一样，都是红黑树结构的
由键决定特性：不重复，无索引，可排序
可排序：**对键进行排序
注意：默认按照键的从小到大进行排序，也可以自己规定键的排序规则

代码两种书写排序规则

创建Comparable接口，指定比较规则
创建集合时传递Comparator比较器对象，指定比较规则

		TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() { 
		 @Override 
		 public int compare(Integer o1, Integer o2) { 
		 //o1 : 当前要添加的元素 
		 //o2 : 当前要添加的元素 
		 //升序
				return o1 - o2;
		 } 
		});

HashMap源码分析

HashMap里面每一个对象包含以下内容

1.1链表中的键值对对象
	包含：
			int hash;
			final K key;
			V value;
			Nodfe<K,V> next;
1.2红黑树中的键值对对象
	包含：
			int hash;
			final K key;
			V value;
			Node<K,V> right;
			boolean red;
2.添加元素
	HashMap<String,Integer> hm = new HashMap<>();
	hm.put("aaa",111);
	hm.put("bbb",222);
添加元素的时候至少考虑三种情况
2.1 数组位置为null
2.2 数组位置不为null，键重复，元素覆盖
2.3 数组位置不为null，键不重复，挂在下面形成链表或者红黑树


//参数一：键
//参数二：值
//返回值：被覆盖元素的值，如果没有覆盖，返回value
public V put(K key, V value) { 
	
	//参数一：
	return putVal(hash(key), key, value, false, true); 
} 
//利用键计算出对应的哈希值，再把哈希值进行一些处理
static final int hash(Object key) { 
 int h; 
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 
}

//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果键重复了是否保留 
// true->表示老元素的值保留，不会覆盖 
// false->表示老欧元素的值不会保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) { 
	Node<K,V>[] tab; //定义一个局部变量，用来记录哈希表数组的地址值，用于优化（方法在栈里，变量在堆里，直接在栈里找地址值） null
	Node<K,V> p; //临时第三方变量，记录键值对对象的地址值
	int n, i; //当前数组的的长度与索引
	
	//将哈希表中数组的地址值赋值给局部变量tab
	//将数组长度赋值给n
	
	if ((tab = table) == null || (n = tab.length) == 0) //true
		//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
		//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容条件
		//如果没有达到扩容条件 -> 无操作
		//如果达到了 -> 底层会把数组扩容为原先的 两倍 ，并把数据全部转移到新的哈希表中
		n = (tab = resize()).length; 
	
	//拿着数组的长度跟键的哈希值进行计算得到 -> 在数组中应存入的位置
	//获取数组中对应元素的数据（第一次为null）	
	if ((p = tab[i = (n - 1) & hash]) == null)
		添加第一个元素 
		//底层会创建一个键值对对象，直接放到数组当中
		tab[i] = newNode(hash, key, value, null); 
	else { 
		添加其他元素
		Node<K,V> e; 
		K k; 
		
		//p.hash:数组中键值对的哈希值
		//hash:当前要添加键值对的哈希值
		//如果键不一样，此时返回false
		if (p.hash == hash && 
			((k = p.key) == key || (key != null && key.equals(k)))) 
			e = p; 
		else if (p instanceof TreeNode) 
			//判断数组中获取出来的键值对是不是红黑树的节点
			//如果是，则调用putTreeVal，把当前的节点按照红黑树的规则添加到树当中
			e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); 
		else { 
			//如果数组中获取出来的键值对不是红黑树的节点
			//表示此时下面挂的是链表 
			for (int binCount = 0; ; ++binCount) { 
				if ((e = p.next) == null) { //下一个元素为null
					//此时就会创建一个新的节点，挂在下面，形成链表
					p.next = newNode(hash, key, value, null); 
					//判断当前链表长度是否超过8，如果超过，会调用treeifyBin
					//treeifyBin方法的底层还会继续判断，判断数组的长度是否大于等于64
					//如果同时满足这两个条件，就会把这个链表转成红黑树
					if (binCount >= TREEIFY_THRESHOLD - 1) //7，插入后长度为8
						treeifyBin(tab, hash); 
					break; 
				} 
				if (e.hash == hash && 
					((k = e.key) == key || (key != null && key.equals(k)))) 
					break; 
				p = e; 
			} 
		} 
		//下一个节点不为空
		//如果e为null，表示当前不需要覆盖任何元素
		if (e != null) { 
			V oldValue = e.value; //保存旧值
			//是否保留
			if (!onlyIfAbsent || oldValue == null) 
				//当前要添加的值
				e.value = value; //覆盖值
			afterNodeAccess(e); //后置处理
			return oldValue; //都返回旧值
		} 
	} 
	
	
	/*与并发修改异常有关，暂时忽略*/++modCount; 
	//threshold:记录数组的长度*0.75，哈希表的扩容时机
	//
	if (++size > threshold) 
	//扩容
		resize(); 
	
	/*与LinkedHashMap有关，暂时忽略*/afterNodeInsertion(evict);
	
	return null; //表示当前没有覆盖任何元素，返回null
}

哈希冲突处理逻辑

1.hash不等 -> 绝对不是同一个Key
2.hash相等 -> 可能是同一个（冲突了），继续比较 == 或 equals
3.equals相等 -> 确定是同一个元素，执行覆盖
	因为冲突不可避免，所以 HashMap 才需要用 equals() 再次确认身份，并用链表/红黑树来安置多出来的“鸽子”。
	
扩展：为什么 `HashMap` 里的 `TREEIFY_THRESHOLD`（树化阈值）定为 8？
	根据泊松分布，在哈希函数设计合理的情况下，同一个桶位冲突达到 8 个的概率只有千万分之6

TreeMap源码分析

无哈希：完全不使用hashCode和equals，只看compare的结果
强约束：Key必须实现Comparable或提供Comparator，且不能为null（因为要调用比较方法）

	Comparable<? super K> k = (Comparable<? super K>) key;
	//将键Key强转为Comparable接口类型
	//若无外部比较器，Key 必须实现Comparable接口，
	//否则在put时会报ClassCastException（强转失败）

有序挂载：

	addEntry(key, value, parent, cmp < 0);
	//true:左
	//false:右

自动平衡：插入后通过fixAfterInsertion（变色/旋转）维持红黑树平衡

可变参数

本质上是一个数组
在方法的形参中只能写一个可变参数
在方法当中，可变参数需要写到最后

Collections集合工具类

场景	核心方法（脑子里有个印象即可）	重点注意
排序/乱序	`sort()`, `reverse()`, `shuffle()`	必须实现 `Comparable` 或传 `Comparator`
找最值	`max()`, `min()`	同样依赖比较逻辑
线程安全	`synchronizedList()`, `synchronizedMap()`	面试重点：它是如何把非线程安全的集合变安全的？（包装了一层锁）
不可变集合	`unmodifiableList()`，`unmodifiableMap()`	防止别人修改你的集合（保护数据）

问：synchronizedList 是如何把非线程安全集合变安全的？

它是一个「包装类」（内部持有原集合的引用）
重写了原集合的所有方法（add/get/iterator 等）
在每个方法内部加 synchronized (this) 锁，保证方法级别的线程安全
注意：遍历（iterator）时需要手动加锁（因为 iterator 是迭代器方法，包装类没给迭代过程加锁）

不可变集合

写法：List.of(),Set.of(),Map.of()(JDK9+)
List<String> list = List.of("1","2");
特性： 一旦创建，长度和内容都不可变
注意： Set/Map里的元素不能重复；of()不允许存null
价值： 为了安全和并发性能

数据结构

Tue, 03 Feb 2026 00:00:00 +0000

栈Stack

后进先出，先进后出
压栈/进栈：数据进入栈模型的过程
弹栈/出栈：数据离开栈模型的过程

队列Queue

先进先出，后进后出
入队列：数据从后端进入队列模型的过程
出队列：数据从前端离开队列模型的过程

数组

==查询速度快==：查询数据通过地址值和索引定位，查询任意数据耗时相同（元素在内存中是连续存储的）
==删除效率低==：要将原始数据删除，同时后面每个数据前移
==添加效率低==：添加位置后的每个数据后移，再添加元素

链表

链表中的结点是独立的对象，在内存中是不连续的，每个节点包含数据值和下一个结点的地址
链表==查询慢==，无论查询哪个数据都从头开始找。
链表的==增删快==（对比数组）

树

	 [父节点地址值，值，左子节点地址值，右子节点地址值]
	 度：每一个节点的 子节点 数量
	 树高：树的总层数
	 
	 
	 10 <-- 根节点
 / \
 5 15 <-- 第二层
 / \ \
 3 7 20 <-- 第三层
 /
 6 <-- 第四层

二叉树的遍历方式

前序遍历

从根节点开始，按照当前节点，左子节点，右子节点的顺序遍历

中序遍历

从最左边的子节点开始，然后按照左子节点，当前节点，右子节点的顺序遍历

后序遍历

从最右边的子节点开始，然后按照左子节点，右子节点，当前节点的顺序遍历

层序遍历

从根节点开始一层一层遍历

二叉查找树

每一个节点上最多有两个子节点
任意节点左子树上的值都小于当前节点
任意节点右子树上的值都大于当前节点

添加节点

小的存左边，大的存右边，一样的不存

弊端

左子树全部为空，从形式上看，更像一个==单链表==
插入速度没有影响
查询速度明显降低

解决弊端：平衡二叉树

平衡二叉树也叫 平衡二叉搜索树（Self-balancing binary search tree），又被称为 AVL 树，可以保证 查询效率较高。它是解决 二叉排序 可能出现的查询问题。

二叉查找树
规则：==任意节点左右子树高度差不超过1==

保持平衡的旋转机制

左旋
右旋
当添加一个节点时，该树不再是一颗平衡二叉树 -> 旋转

左旋

确定支点：从添加的节点开始，不断的往父节点找不平衡的节点
步骤：
- 以不平衡的点作为支点
- 把支点左旋降级，变成左子节点
- 晋升原来的右子节点

步骤：
- 以不平衡的点作为支点
- 将根节点的右侧往左拉
- 原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右子节点

需要旋转的四种情况

左左LL

当==根结点左子树的左子树==有节点插入，导致二叉树不平衡
一次右旋

左右LR

当==根结点左子树的右子树==有节点插入，导致二叉树不平衡
先局部左旋 -> 左左LL
再整体右旋

右右RR

当==根结点右子树的右子树==有节点插入，导致二叉树不平衡
一次左旋

右左RL

当==根结点右子树的左子树==有节点插入，导致二叉树不平衡
先局部右旋 -> 右右RR
再整体左旋

红黑树

平衡二叉树的弊端：在添加节点的时候，旋转次数太多，造成添加节点的时间浪费
红黑树刚开始被称为平衡二叉B树
是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色
每一个节点可以是红或者黑；红黑树不是高度平衡的，他的平衡是通过“红黑规则“进行实现的
是一个二叉查找树
==但是不是高度平衡的==
条件：特有的红黑规则

红黑规则

每一个节点是红色或黑色
根节点必须是黑色的
如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil被视为叶节点，每个叶节点 (Nil) 是黑色的
如果某一个节点是红色的，那么它的子节点必须是黑色（不能出现两个红色节点相连的情况）
对每一个节点，从该接待你到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点

添加节点

添加的节点默认是红色的（红色效率高）
查找、插入、删除的时间复杂度最坏为O(log n)

Stream流与方法引用

Tue, 03 Feb 2026 00:00:00 +0000

Stream流的思想和获取Stream流

比喻： Stream 是流水线，不存数据
作用： 结合Lambda表达式，简化集合、数组操作

类型	获取Stream流
List	`.stream()`
Map	`.entrySet().stream()`
数组	`Arrays.stream(数组)`
Set	`.stream()`
零散数据（同种类型）	`Stream.of(数据)`

	//List-------------------------//
	ArrayList<String> list = new ArrayList<>(); 
	Collections.addAll(list, "Java", "Python", "C++", "JavaScript", "Ruby"); 
	list.stream() 
	 .filter(s -> s.length() > 4) 
	 .forEach(System.out::println); 
	 
	//Map--------------------------//
	HashMap<String, Integer> map = new HashMap<>(); 
	map.put("aaa", 111); 
	map.put("bbb", 222); 
	map.put("ccc", 333); 
	 
	map.entrySet().stream() 
	 .filter(e -> e.getValue() == 333) 
	 .forEach(e -> System.out.println(e.getKey() + " = " + e.getValue())); 
	 
	map.keySet().stream() 
 .filter(k -> map.get(k) == 333) 
 .forEach(k -> System.out.println(k + " = " + map.get(k))); 
 
	//数组---------------------------//
	int[] arr = {1,2,3,4,5,6,7,8,9,10}; 
	Arrays.stream(arr) 
	 .filter(n-> n==1) 
	 .forEach(System.out::println);
	 
	//零散数据-----------------------//
	Stream.of(1,2,3,4,5,6,7,8,9,10) 
 .filter(n-> n==1) 
 .forEach(System.out::println);

Stream.of的注意事项

数组必须是引用数据类型！！！

String[] sArr = {"a", "b"};
Stream.of(sArr); // 得到流 [a, b]，长度 2

int[] iArr = {1, 2};
Stream.of(iArr); // 得到流 [[1, 2]]，长度 1！它把整个数组当成了一个元素

中间方法和终结方法

中间方法

返回值还是 Stream（可以继续 .filter()、.map() 下去）

常用方法	功能	备注
`filter`	过滤	接收 `Predicate`，返回 true 的留下。修改Stream中的数据，不会影响原来的数据
`map`	类型转换	把一种对象换成另一种（如把 `Student` 转成 `String` 姓名）`.map(s -> Integer.parseInt(s.split("-")[1]))`
`distinct`	去重	依赖对象的 `hashCode` 和 `equals`
`limit(n)`	截取前 n 个`	获取前几个元素（短路）
`skip(n)`	跳过前 n 个	经常和 `limit` 组合做分页
`sorted`	排序	自然排序或传 `Comparator`
`concat`	合并	将a和b两个流合并成一个集合。`Stream.concat(list1.stram(),list2.stream())`

终结方法

返回值不是 Stream（变成 void、long、List、Optional 等），一旦调用，流彻底关闭

常用方法	功能	备注
`forEach`	遍历	打印或消费数据	`.forEach()`
`count`	统计个数	返回 `long`	`.count`
`collect`	收集转集合	最重要！把流转回 `List`, `Set`, `Map`	`.collect(Collectors.toList())` `.collect(Collectors.toSet())`
`toArray`	收集转数组	收集流中的数据，放到数组中	`.toArray(n -> String[n])` `.toArray(String[]::new)`
`reduce`	聚合	把所有数据累加/合成一个结果
`anyMatch`	匹配	只要有一个满足条件就返回 true

collect收集到Map中

	/*
		toMap()：参数一表示键的生成规则
				 参数二表示值的生成规则
		
		Function：泛型一表示流中每一个数据的类型
				 泛型二表示Map集合中 键/值 的数据类型
				 
		apply形参：依次表示流里面的每一个数据
			 方法体：生成 键/值 的代码
			 返回值：已经生成的 键/值
	*/
	例：数据格式为 name - gender - age
	Map<String, Integer> map = 
		list.stream()
			.filter(s -> "男".equals(s.spilt("-")[1]))
			.collect(Collectors.toMap(new Function<流的类型,键的类型>(){
					@Override
					public String apply(String s){
						return s.split("-")[0];//name
						//return null;
					}
				},new Function<流的类型,值的类型>(){
						@Override
						public Integer apply(String s){
							return Integer.parseInt(s.split("-")[2]);//age
							//return null;
						}
					}));
	//----------lambda-----------//				
	Map<String, Integer> map = list.stream() 
 .filter(s -> "男".equals(s.split("-")[1])) 
 .collect(Collectors.toMap(s->s.split("-")[0],
					s-> Integer.parseInt(s.split("-")[2])));

[!WARNING] 如果要收集到Map集合当中，键不能重复

方法引用

方法引用前提：

接口对路：必须是函数式接口。

坑位对齐：参数、返回值必须和接口方法一模一样。

现成逻辑：逻辑已存在(被引用方法满足当前需求),且 Lambda 内部只有这一行调用。

类型	格式	例子 (Lambda -> 方法引用)
静态方法引用	`类名::静态方法`	`s -> Integer.parseInt(s)` $\rightarrow$ `Integer::parseInt`
实例方法引用	`对象名::成员方法`	`s -> System.out.println(s)` $\rightarrow$ `System.out::println`
特定类型实例方法	`类名::成员方法`	`(s1, s2) -> s1.compareTo(s2)` $\rightarrow$ `String::compareTo`
构造方法引用	`类名::new`	`name -> new Student(name)` $\rightarrow$ `Student::new`

引用成员方法的多种情况

其他类： 其它类对象::方法名
本类： this::方法名
父类： super::方法名

[!WARNING] 当本类,父类的引用处为静态方法时，不可用this/super，应当先创建本类对象

public class Daily { 
 public static void main(String[] args) { 
 ArrayList<String> list = new ArrayList(); 
 Collections.addAll(list, "张三", "李四", "王五", "张六一", "孙而七"); 
 
	 //当方法在本类中，方法为static，创建本类对象
 list.stream().filter(new Daily()::stringJudge) 
 .forEach(System.out::println); 
 } 
	public boolean stringJudge(String s) {...} 
}

class Parent { 
 public boolean stringJudge(String s) { 
 return s.startsWith("张"); 
 } 
} 
 
class Daily extends Parent { 
 @Override 
 public boolean stringJudge(String s) { 
 return s.startsWith("张") && s.length() == 3; 
 } 
 
 public void test(List<String> list) { 
 // 调子类重写后的方法 
	 list.stream().filter(this::stringJudge)
		 .forEach(System.out::println); 
 
 // 强制调父类版本 
	 list.stream().filter(super::stringJudge)
		 .forEach(System.out::println); 
 } 
}

构造方法的引用


	ArrayList<String> list = new ArrayList(); 
	Collections.addAll(list, "张三,13", "李四,46", "王五,15"); 
	List<Student> list1 = 
		list.stream() 
			//这里必须在Student中新建一个构造方法
			.map(Student::new) 
			.collect(Collectors.toList());
 /*在Student中
	* public Student(String s){ 
	*	 this.name = s.split(",")[0]; 
	*	 this.age = Integer.parseInt(s.split(",")[1]);
	*	 }
 */

其他调用方式

类名引用成员方法 `类名::成员方法`

独有的规则

被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致

抽象方法形参的详解： 第一个参数： 表示被引用方法的调用者，决定了可以引用那些类中的方法在Stream流当中，第一个参数一般都表示流里面的每一个数据假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法

第二个参数到最后一个参数： 跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要时无参的成员方法

例子：String::substring(int beginIndex)

这个方法括号里只有 1 个 参数。
但它是一个成员方法，需要 1 个 调用者。
所以这个方法引用，要求 Lambda 必须提供 2 个 参数：
- 第一个参数：必须是 String（调用者）。
- 第二个参数：必须是 int（对应 beginIndex）。
Lambda 原型：(String s, int i) -> s.substring(i)

总结： “类名::成员方法”之所以看起来参数少了一个，是因为第一个参数被拿去“点”那个方法了。

	ArrayList<String> list = new ArrayList(); 
	Collections.addAll(list, "aaa", "bbb", "ccc", "ddd"); 
	list.stream() 
			//拿着流里面的每一个数据，去调用String类中的方法
	 .map(String::toUpperCase) //s -> s.toUpperCase()
	 .forEach(System.out::println);

引用数组的构造方法 `数据类型[]::new`

	Integer[] array = list.stream()
		.toArray(Integer[]::new);//v -> new Integer[v]

[!IMPORTANT] 数组的类型，需要跟流中数据一致

常犯错误

Stream 中的参数分配法则： 流里的数据总得有个去处。

要么当参数：喂给静态方法或构造器（如 Student::new）。
要么当主人：自己调用成员方法（如 Student::getName）。

报错的原因：通常是因为你既提供了一个主人（new Student()），又想让流里的数据当参数，结果方法不收参数，数据就“没地方放”了。

异常和File

Fri, 20 Mar 2026 00:00:00 +0000

异常

Throwable（所有异常/错误的根类）
|
├─ Error（系统级致命错误，程序无法恢复）
│ ├─ OutOfMemoryError（内存溢出，如创建超大对象/无限集合）
│ └─ StackOverflowError（栈溢出，如无限递归调用）
│
└─ Exception（程序可处理的异常）运行时异常+编译时异常
 |
 ├─ RuntimeException（运行时异常/非检查型，编译器不强制捕获）
 | |
 │ ├─ NullPointerException（空指针，调用null对象的方法/属性）
 │ ├─ IndexOutOfBoundsException（下标越界，如数组/集合下标超出范围）
 │ ├─ ClassCastException（类型转换异常，如String强转Integer）
 │ ├─ IllegalArgumentException（参数非法，如传入不符合规则的参数）
 │ └─ ArithmeticException（算术异常，如整数除以0）
 │
 |
 └─ CheckedException（检查型异常，编译器强制捕获/声明抛出）
	 |
 ├─ IOException（IO操作异常）
 │ └─ FileNotFoundException（文件未找到，如读取不存在的文件）
 ├─ SQLException（数据库操作异常，如SQL语法错误/连接失败）
 └─ InterruptedException（线程中断异常，如休眠线程被打断）

捕获异常`try-catch`

	int[] arr = {1,2,3}; 
	try{ 
		//程序创建异常，与catch（）中的异常对比，可捕获 -> 执行catch{..}
		//当catch{..}执行完毕，继续向下执行
	 System.out.println(arr[10]); 
	}catch (ArrayIndexOutOfBoundsException e){ 
	 System.out.println("数组越界了"); 
	} 
	System.out.println("执行！");

常见问题

如果`try`中没有遇到问题，怎么办？

会把try中的所有代码全部执行完毕，不会执行catch中的代码

注意： 只有出现了异常，才会执行catch

如果`try`中可能遇到多个问题，怎么办？

写多个catch与之对应

注意： 如果捕获多个异常，父类一定要写在下面

JDK7以后，可以用catch捕获多个异常，中间用|隔开

如果`try`中遇到的问题没有被捕获，怎么办？

JVM虚拟机默认处理异常，会停止程序

如果`try`中遇到了问题，那么`try`下面的其他代码块还会执行吗？

不会执行 ，会直接跳转到对应的catch

常用方法

方法名	返回值	作用
`e.getMessage()`	`String`	简报：只告诉你最简单的错误原因（如 “By zero”）。
`e.toString()`	`String`	中报：异常类型 + 错误原因（如 `java.lang.ArithmeticException: / by zero`）
`e.printStackTrace()`	`void`	详报：在控制台打印完整的堆栈信息，最常用

抛出处理

关键字	位置	作用	后面跟什么
`throws`	方法声明处	向上抛	异常类名（可以跟多个）
`throw`	方法体内	制造异常	异常对象（只能跟一个）

运行时异常不需要throws声明

自定义异常

定义异常类
写继承关系
空参构造
带参构造

类型	继承 `Exception`（检查型）	继承 `RuntimeException`（非检查型）
强制要求	必须用 try-catch 捕获，或声明 throws	无需强制捕获，按需处理
适用场景	必须处理的严重业务异常（比如文件读写失败）	普通业务异常（比如余额不足、用户不存在）
代码复杂度	高（到处加 try-catch）	低（只在需要处理的地方捕获）

File

常用方法

类别	方法名	返回值	核心功能	备注
获取	`getName()`	`String`	获取文件或文件夹名称	带后缀名（如 `a.txt`）
	`length()`	`long`	获取文件大小，文件夹为`0`	单位是字节 (Byte)，UTF-8一个汉字三个字节
	`lastModified()`	`long`	最后修改时间	毫秒值，需转换日期
路径	`getPath()`	`String`	获取构造时传入的路径	怎么 `new`的就给什么
	`getAbsolutePath()`	`String`	获取绝对路径	从盘符开始的全路径
判断	`exists()`	`boolean`	路径是否存在	最常用，防报错必备
	`isFile()`	`boolean`	是否为文件	路径不存在则返回 false
	`isDirectory()`	`boolean`	是否为文件夹	路径不存在则返回 false
创建	`createNewFile()`	`boolean`	创建新文件	文件夹不存在会创建失败
	`mkdirs()`	`boolean`	递归创建文件夹	建议永远用带 s 的这个
删除	`delete()`	`boolean`	删除文件/空文件夹	不走回收站，直接消失

综合练习： 统计各种文件的数量


 /**
 * 递归方法：统计指定目录下所有文件的后缀名数量（包含子目录）
 * @param src 要统计的目标目录File对象
 * @return 后缀名-数量的HashMap，键为后缀名/无后缀，值为对应数量
 */
public static HashMap<String,Integer> getCount(File src){
	HashMap<String,Integer>hm = new HashMap<>();
	File[] fs = src.listFiles();
	// 判空：避免目录为空/无访问权限导致空指针
	
	if (fs != null) {
		for (File f : fs) {
			if (f.isFile()) {
				// 按"."分割文件名，用于提取后缀名（注意转义符\\.）
				String[] split = f.getName().split("\\.");
				
				// 分割后长度>=2说明有后缀名（如test.txt分割后是[test,txt]）
				if(split.length >= 2){
					// 取分割数组最后一个元素作为后缀名
					String endName = split[split.length-1];
					
					if(!hm.containsKey(endName))
						hm.put(endName,1);
					else
						hm.put(endName,hm.get(endName)+1);

				}else{
					// 分割后长度<2说明无后缀名（如readme、.gitignore）
					// 首次统计"无后缀"：初始化为1
					
					if(!hm.containsKey("无后缀"))
						hm.put("无后缀",1);
					else
						hm.put("无后缀",hm.get("无后缀")+1);
				}
			}else{
				// 当前File是子目录：递归调用getCount统计子目录的后缀名
				HashMap<String,Integer> dfs = getCount(f);
				// 遍历子目录的统计结果，合并到当前目录的HashMap中
				
				for (String k : dfs.keySet()){
					// 当前目录未统计过该后缀：直接赋值子目录的统计数
					if(!hm.containsKey(k))
						hm.put(k,dfs.get(k));
					// 当前目录已统计过该后缀：累加子目录的统计数
					else
						hm.put(k,hm.get(k)+dfs.get(k));
				}

			}
		}

	}
	// 返回当前目录（含子目录）的最终统计结果
	return hm;
}

IO流

Sat, 21 Mar 2026 00:00:00 +0000

程序是在“内存”里跑的，所以永远以内存为原点。

参照物：程序/内存
Input (输入)：数据从硬盘/网络流进内存。—— 读（Read）
Output (输出)：数据从内存流出到硬盘/网络。—— 写（Write）

维度	字节流 (万能，图片/视频/文本)	字符流 (仅限纯文本，自带编码)
输入 (Read)	InputStream	Reader
输出 (Write)	OutputStream	Writer

字节流

`FileOutputStream`

操作本地文件的字节输出流，可以把程序中的数据写到本地文件中

核心步骤：

创建对象：FileOutputStream fos = new FileOutputStream("a.txt");
- 细节1：如果文件不存在，会自动创建，但是要保证父级路径是存在的。
- 细节2：如果文件存在，会清空原内容
写出数据：fos.write(97); // 写出的是 ASCII 码，文件中显示 ‘a’。
释放资源：fos.close(); // 极其重要！ 不关流，文件会被程序锁死。

写出数据的三种方式

方法名	说明	适用场景
`write(int b)`	一次写一个字节	极少用，效率太低
`write(byte[] b)`	一次写一个字节数组	常用，适合写出大量数据
`write(byte[] b, off, len)` `off:offset`	写出数组的一部分	最常用，配合循环读取时能精确控制写出的量

`FileOutputStream`写数据的问题

换行

Windows: \r\n 回车 + 换行，java在底层会补全
Linux/Unix: \n
Mac: \r

System.lineSeparator() 获取操作系统的换行符

续写

public FileOutputStream(File file, boolean append) true则续写

`FileInputStream`

功能：硬盘 $\rightarrow$ 内存 (读取字节)。
结束标志：读取到 -1。
性能优化：定义 byte[] 数组作为缓冲区，一次读取多个字节。
适用场景：文件拷贝（图片、音视频）、不需要处理文本内容的场景。

核心步骤：

创建对象：FileIutputStream fis = new FileIutputStream("a.txt");
- 细节1：如果文件不存在，会直接报错
读取数据：int b = fis.read(97); // 读出的是 ASCII 码，读出来显示 ‘a’。
- 细节1：读到文件末尾，read返回-1
释放资源：fis.close();

读入数据的方法

方法名	返回值类型	含义
`read()`	`int`	读取一个字节(效率低)，返回该字节的值；读完返回 -1
`read(byte[] buffer)`	`int`	读取字节填充进数组，返回实际读取个数；读完返回 -1
`available()`	`int`	返回文件剩余的可读字节数（慎用，大文件会爆内存）

文件拷贝

	FileInputStream fis = new FileInputStream(PATH+"b.txt"); 
	FileOutputStream fos = new FileOutputStream(PATH+"copy.txt"); 
	byte[] buffer = new byte[1024];//1KB 
	int len; 
	while ((len = (fis.read(buffer))) != -1) { 
	 fos.write(buffer, 0, len); 
	} 
	fos.close(); 
	fis.close();

[!NOTE] close关闭顺序：先开的后关，后开的先关

异常处理`try-with-resources`

`try-catch-finally`

finally代码块一定会执行，除非虚拟机退出

当流对象实现了AutoCloseable接口时，可以使用小括号

修正后的文件拷贝

	FileInputStream fis = new FileInputStream(PATH + "b.txt"); 
	FileOutputStream fos = new FileOutputStream(PATH + "copy.txt"); 
	 
	try (fis;fos){ 
	 byte[] buffer = new byte[1024];//1KB 
	 int len; 
	 while ((len = (fis.read(buffer))) != -1) { 
	 fos.write(buffer, 0, len); 
	 } 
	} catch (IOException e) { 
	 e.printStackTrace(); 
	}

字符集

编码格式	中文占位	字节流读取过程	结果
GBK	2 字节	`fis.read()` 一次拿 1 字节	拿到了半个字 $\rightarrow$ 乱码
UTF-8	3 字节	`fis.read()` 一次拿 1 字节	拿到了三分之一个字 $\rightarrow$ 乱码

字符流 = 字节流 + 字符集

特性	字节流 (Stream)	字符流 (Reader/Writer)
数据单位	字节 (8 bit)	字符 (16 bit)
处理对象	所有文件（图片、视频、文本）	仅限纯文本（txt, java, html）
读中文	会乱码	不会乱码
拷贝图片	完美拷贝	文件会损坏（千万别用字符流拷图片）

核心步骤：

创建对象：FileReader fr = new FileReader("a.txt");
- _细节_1：
读取数据：while((ch = fr.read() )!= -1){}
- 细节1：按字节读取，遇到中文，一次会读多个字节，读取后解码。返回整数
- 细节2：读到文件末尾返回-1
  - read()的细节：
  - 在读取之后，方法的底层还会进行解码并转成十进制，最终会把这个十进制作为返回值，这个十进制的数据也表示在字符集上的数字。
释放资源：fr.close();

缓冲流

	IO流体系
	├─ 字节流
	│ ├─ InputStream（字节输入流）
	│ │ ├─ FileInputStream（基本字节输入流）
	│ │ └─ BufferedInputStream（字节缓冲输入流）
	│ └─ OutputStream（字节输出流）
	│ ├─ FileOutputStream（基本字节输出流）
	│ └─ BufferedOutputStream（字节缓冲输出流）
	└─ 字符流
	 ├─ Reader（字符输入流）
	 │ ├─ FileReader（基本字符输入流）
	 │ └─ BufferedReader（字符缓冲输入流）
	 └─ Writer（字符输出流）
	 ├─ FileWriter（基本字符输出流）
	 └─ BufferedWriter（字符缓冲输出流）

1.为什么它快？

普通流：每读写一个字节，就要调用一次操作系统的 API，直接操作硬盘。硬盘 IO 是计算机最慢的操作。
缓冲流：在内存中开辟了一个 8KB (8192 byte) 的字节数组（缓冲区）。
- 输入缓冲：一次性从硬盘读 8KB 进来，你调 read() 时，它是从内存数组里拿。
- 输出缓冲：你调 write() 时，数据先存在内存数组里，攒满 8KB 后，一次性“喷”向硬盘。

2.家族结构与包装模式

缓冲流属于装饰者模式（Decorator Pattern），它不具备读写文件的能力，必须依托于“基本流”。

语法模板：

// “套娃”式创建：外层关了，内层自动关
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.mp4"));

类型	缓冲流名称	包装的基本流
字节输入	`BufferedInputStream`	`FileInputStream`
字节输出	`BufferedOutputStream`	`FileOutputStream`
字符输入	`BufferedReader`	`FileReader`
字符输出	`BufferedWriter`	`FileWriter`

字符缓冲流的特殊方法

① `BufferedReader` -> `readLine()`

功能：读取一整行，直到遇到换行符（\r 或 \n）。
返回值：返回 String。注意：不包含换行符本身。
结束标志：读到文件末尾返回 null（注意：不再是 -1）。

② `BufferedWriter` -> `newLine()`

功能：写出一个换行符。
优势：跨平台性。它会根据当前操作系统自动切换 \r\n (Win) 或 \n (Linux)。

性能对比

方式	性能	评价
基本流 + 单字节	极慢	可能需要几分钟
基本流 + 数组 (8KB)	快	常用，性能已经很好了
缓冲流 + 单字节	快	缓冲流弥补了单字节的频繁 IO
缓冲流 + 数组 (8KB)	极快	推荐使用

[!WARNING] 1.缓冲区溢出：输出流写完后，如果程序突然崩溃且没关流，缓冲区里没满 8KB 的那部分数据会丢失。所以必须 close()

2.刷新缓冲区：flush() 只能清空缓冲区（强制写出），close() 会先调 flush() 再关流

3.内存占用：虽然缓冲流快，但每个流都会占 8KB 内存。如果同时开启几万个流，要注意内存溢出

带缓冲的字符流读取模板

	try (BufferedReader br = new BufferedReader(new FileReader("config.txt"));
	 BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"))) {
	 
	 String line;
	 // 1. 读一行
	 while ((line = br.readLine()) != null) {
	 // 2. 写一行
	 bw.write(line);
	 // 3. 必须手动补换行，因为 readLine 不读换行符
	 bw.newLine(); 
	 }
	} catch (IOException e) {
	 e.printStackTrace();
	}

转换流

转换流名称	构造参数	作用方向	常用场景
`InputStreamReader`	`InputStream`, `Charset`	字节 $\rightarrow$ 字符 (解码)	读取非 UTF-8 编码的文本文件
`OutputStreamWriter`	`OutputStream`, `Charset`	字符 $\rightarrow$ 字节 (编码)	将文本以指定编码存入文件（如存为 GBK）

JDK11以后

// 底层其实就是封装了转换流
FileReader fr = new FileReader("gbk_file.txt", Charset.forName("GBK"));
BufferedReader br = new BufferedReader(fr);

如何实现字节流读一整行不出现乱码？ 字节流 -> 字符流(可以指定编码) -> 字符缓冲流（可以读一整行）

	//1. 创建文件字节输入流
	FileInputStream fis = new FileInputStream(PATH + "d.txt"); 
	// 2. 将字节流包装为字符流（默认使用系统编码）
	InputStreamReader isr = new InputStreamReader(fis); 
	//3. 将字符流包装为缓冲字符流，可以按行读取提高效率
	BufferedReader br = new BufferedReader(isr); 
	
	System.out.println(br.readLine()); 
	br.close();//关闭高级流

序列化流/对象操作流

维度	ObjectOutputStream	ObjectInputStream
动作	序列化 (Serialization)	反序列化 (Deserialization)
方向	内存 $\rightarrow$ 硬盘	硬盘 $\rightarrow$ 内存
构造方法	`oos(OutputStream out)`	`ois(InputStream in)`
方法	`writeObject(Object obj)`	`readObject()`
前提条件	`Javabean`必须实现 `Serializable`接口	类路径必须存在，ID 必须匹配

	//前提：实现Serializable（标记性）接口
	Student stu = new Student("张三", 20); 
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(PATH+"student.txt")); 
	
	oos.writeObject(stu); 
	oos.close(); 
	//--------------------------------------------//
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PATH+"student.txt")); 
	
	System.out.println(ois.readObject()); 
	ois.close();

细节一：`serialVersionUID` (版本号)

当你序列化一个对象后，如果修改了类的代码（比如加了个字段），再进行反序列化就会报 InvalidClassException。

解决：手动给类加一个固定的 ID。
private static final long serialVersionUID = 1L;
这样即使类改了，只要 ID 没变，Java 就会认为它们是同一个类。

细节二：`transient` (瞬态关键字)

如果你不希望某个成员变量被保存到硬盘（比如用户的密码），只需在变量前加 transient。

private transient String password;
反序列化回来后，该字段会变成默认值（如 null）。

细节三：

序列化时写入什么类型，反序列化时就必须用什么类型接收，类型必须完全一致。

	Student s1 = new Student("张三",23,"南京"); 
	Student s2 = new Student("李四",22,"重庆"); 
	Student s3 = new Student("王五",24,"上海"); 
	
	ArrayList<Student> list = new ArrayList<>(); 
	list.add(s1); list.add(s2); list.add(s3); 
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(PATH+"student.txt")); 
	//序列化使用Array List写入
	oos.writeObject(list); 
	oos.close();
	
	//---------反序列化---------//
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PATH+"student.txt")); 
	//同样使用ArrayList反序列化
	ArrayList<Student> list =(ArrayList<Student>)ois.readObject(); 
	for (Student s : list) { 
	 System.out.println(s); 
	}
	ois.close();

打印流

地位：最方便的只写流。
三大招：
1. println()：写啥都行，写完换行。
2. printf()：格式化打印（如保留两位小数 % .2f）。
3. System.setOut()：重定向输出。
注意：
- 打印流只有输出，没有输入。
- 它是对其他输出流的包装，可以配合缓冲流一起用：new PrintWriter(new BufferedWriter(new FileWriter("a.txt")))。

类别	名称	对应家族	常用场景
字节打印流	`PrintStream`	`OutputStream`	标准输出（控制台）、日志记录
字符打印流	`PrintWriter`	`Writer`	网页响应 (Servlet)、文本写入

字节打印流

	PrintStream ps = new PrintStream(new FileOutputStream(PATH + "c.txt"),true,Charset.forName("UTF-8")); 
	ps.println(97);//写出 + 自动刷新 + 自动换行 
	ps.printf("%s+%s = %s",1,1,2); 
	ps.close();

字符打印流

	PrintWriter pw = new PrintWriter(new FileWriter(PATH+"c.txt"), true); 
	pw.println("你好"); 
	pw.close();

核心区别

维度	字节打印流 (PrintStream)	字符打印流 (PrintWriter)
所属家族	`OutputStream` 的子类	`Writer` 的子类
处理单位	字节（即使你传的是字符，它也会先转成字节）	字符（直接按字符处理）
内部缓冲区	没有（它直接调底层的 OutputStream）	有（它内部维护了一个字符缓冲区）
自动刷新 (AutoFlush)	只要调了 `println` 就会自动刷新	必须在构造器手动开启 `true` 才会自动刷新
主要用途	标准输出 (`System.out`)、写原始字节数据	写纯文本、Web 开发 (Servlet 响应)

标准输出流 (System.out)

本质：一个预定义的 PrintStream 对象。
特点：
- 随 JVM 启动而产生，随 JVM 关闭而销毁。
- 专门用于向控制台输出数据。
核心功能：
- print() / println()：万能打印。
- printf()：格式化打印（如 %d, %f）。
- System.setOut(PrintStream)：修改输出目的地（常用于写简单的日志工具）。

解压缩流/压缩流

	InputStream（字节输入流）-> 解压缩流
	OutputStream（字节输出流）-> 压缩流

解压

什么是 ZipEntry？

一个 ZIP 文件就像一个大包裹，里面的每个文件或文件夹都是一个 ZipEntry。
解压过程：就是通过 getNextEntry() 方法，一个一个地把包裹里的东西（Entry）拿出来，然后用普通的字节流（FileOutputStream）把它们写到本地。

public static void unzip(File src,File dest) throws IOException { 
 ZipInputStream zip = new ZipInputStream(new FileInputStream(src)); 
 ZipEntry entry; 
 while ((entry = zip.getNextEntry()) != null) { 
 
 if(entry.isDirectory()){ 
 File f = new File(dest,entry.getName()); 
 f.mkdirs(); 
 }else{ 
 FileOutputStream fos = new FileOutputStream(new File(dest,entry.getName())); 
 int b; 
 while((b = zip.read()) != -1){ 
 fos.write(b); 
 } 
 fos.close(); 
 zip.closeEntry();//表示在压缩包中的一个文件处理完毕了 
 } 
 } 
 zip.close(); 
}

多线程和JUC

Sun, 22 Mar 2026 00:00:00 +0000

本文更新于 2026-03-22

多线程

1.进程 (Process)：运行中的程序（比如 IDEA、Chrome、QQ）。它是操作系统资源分配的最小单位。

2.线程 (Thread)：进程中的一个“执行路径”。一个进程可以包含多个线程（比如 Chrome 里一个线程下载文件，一个线程渲染网页）。

并发和并行

维度	并发 (Concurrency)	并行 (Parallelism)
核心特点	任务交替执行	任务同时执行
资源需求	单核 CPU 即可实现	必须多核 CPU
目的	提高 CPU 利用率，解决“阻塞”	提高计算速度，缩短处理时间
关系	并发不一定是并行	并行一定是并发的一种形式

实现方式

继承`Thread`类

public class MyThread extends Thread {
 @Override
 public void run() {
 for (int i = 0; i < 100; i++) {
 System.out.println(getName() + " 在运行: " + i);
 }
 }
}
	// 启动：new MyThread().start();
	优点:代码简单，直接 `this` 就能获取线程名。
	缺点：Java 是单继承，继承了 Thread 就不能继承别的类了。

实现`Runnable`接口

public class MyRun implements Runnable {
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " 执行中");
 }
}
	// 启动：new Thread(new MyRun()).start();
	优点：扩展性强，可以实现接口的同时继承别的类；适合多个线程处理同一个资源。

实现`Callable`接口

public class MyCallable implements Callable<Integer> {
 @Override
 public Integer call() throws Exception {
 return 100 + 200; // 返回计算结果
 }
}
	// 启动需配合 FutureTask
	特点：可以获取线程执行后的结果，还能抛出异常。

成员方法

方法名	说明	备注
`setName(String name)`	设置线程名称	默认是 `Thread-0,Thread-1` 等
`getName()`	获取线程名称	建议在构造时就起好名字
`getPriority()`	获取线程优先级	范围 1-10，默认 5
`setPriority(int p)`	设置线程优先级	优先级越高，抢到 CPU 时间片的概率越大
`currentThread()`	静态方法，获取当前线程	哪条线程执行这行代码，就返回谁

给线程设置名字： 可以用set也可以用构造方法

currentThread(): 当JVM虚拟机启动之后，会自动启动多条线程，其中一条是main线程，它的作用是调用main方法，并执行里面的代码。

状态控制方法

这些方法直接影响线程的运行节奏，是多线程编程的核心。

① `sleep(long ms)`：线程休眠

类型：静态方法。
作用：让当前线程进入“阻塞状态”指定的时间。
特点：不释放锁（如果你拿着钥匙睡觉，别人依然进不来）。
应用：在拼图游戏中，如果想制作一个“倒计时”或“动画间隔”，就用它。

② `yield()`：线程让步

类型：静态方法。
作用：暗示 CPU 当前线程愿意让出执行权。
特点：线程从“运行”回到“就绪”状态。CPU 可能会再次选中它，也可能选中别人。这是一种谦让，不是强制停止。

③ `join()`：线程插队

类型：成员方法。
作用：在 A 线程中调用 B.join()，意味着 A 必须等 B 执行完，A 才能继续。
类比：你在排队买饭，突然一个 VIP（B 线程）插到了你前面，你必须等他买完。

守护线程`（Daemon Thread）`

方法：setDaemon(true)
定义：当进程中所有的“用户线程”都结束了，守护线程即便没运行完，也会被 JVM 强制杀掉。(不是立马结束，而是 陆续结束)
比喻：用户线程是“国王”，守护线程是“保镖”。国王死了，保镖也就没存在的意义了。
应用：垃圾回收器（GC）就是一个经典的守护线程。

生命周期

线程安全

三大特性

原子性 (Atomicity)：一个操作要么全部执行成功，要么全部失败，中间不能被中断。
可见性 (Visibility)：一个线程修改了共享变量的值，其他线程能够立即看到。
有序性 (Ordering)：程序执行的顺序按照代码的先后顺序执行（防止指令重排）。

为什么会出现线程不安全？

线程安全问题发生的三个必要条件（缺一不可）：

多线程环境：至少有两个线程在跑。
共享资源：多个线程访问同一个变量（如成员变量、静态变量）。
写操作：至少有一个线程在修改这个变量。

解决方案1: 同步代码块 `(synchronized)`

在实例方法中，通常用 this；在静态方法中，通常用 类名.class。

public class MyThread extends Thread { 
 static int sum = 0; 
 //锁对象，一定要是唯一的
 static final Object obj = new Object(); 
 
 @Override 
 public void run() { 
 while (true) { 
 synchronized (obj) { 
 // 核心：在锁内部再次判断，保证原子性 
 if (sum < 100) { 
 try { 
 Thread.sleep(100); // 模拟网络延迟或出票时间 
 } catch (InterruptedException e) { 
 e.printStackTrace(); 
 } 
 sum++; 
 System.out.println(getName()+"正在卖第"+sum+"张票!"); 
 } else { 
 // 票卖完了，跳出死循环 
 break; 
 } 
 } 
 } 
 } 
}

🛠️ 卖票案例避坑指南

锁的唯一性：用了 static final Object obj，这确保了无论创建多少个 MyThread 对象，它们抢的都是同一把锁。
判断逻辑的位置：
- 如果判断在 synchronized 外面，会有“判断通过但由于抢锁延迟导致数据过期”的风险。
- 金律：对共享变量的判断和修改，必须包裹在同一个 synchronized 块内。
Sleep 的位置：
- sleep 放在同步块里会**“抱着锁睡觉”**，其他线程只能干等，效率低。
- 在这个练习中，它是为了放大问题。在实际开发中，应尽量缩短同步块的代码量。

解决方案2: 同步方法

同步方法的分类与锁对象

同步方法分为两种，它们的锁对象是 Java 自动指定的，不需要手动创建 obj。

① 同步实例方法（非静态）

格式：public synchronized void method() { ... }
锁对象：this（当前调用该方法的对象）。
适用场景：多个线程操作同一个对象的成员变量。

② 同步静态方法

格式：public static synchronized void method() { ... }
锁对象：类名.class（当前类的字节码文件对象）。
适用场景：多个线程操作类的静态变量（比如你代码里的 static int sum）。

[!IMPORTANT] StringBuffer、Vector、Hashtable 内部都是通过同步方法实现线程安全的，所以它们效率比 StringBuilder、ArrayList、HashMap 低

单线程用StringBuilder，多线程要考虑线程安全用StringBuffer

`Lock`锁(接口)

1.Static 关键字：因为是 extends Thread，所以 Lock 必须加 static。否则每个线程对象都有一把自己的锁，根本锁不住！

2.Lock 的位置：放在 try 块上方。

3.Unlock 的位置：必须在 finally 第一行。

4.死循环出口：在 break 之前，务必确保 finally 能被触发（Java 默认支持，不用担心）。

public class MyThread extends Thread {
 static int sum = 0;
 static Lock lock = new ReentrantLock();

 @Override
 public void run() {
 while (true) {
 // 1. 锁放在 try 外面
 lock.lock(); 
 try {
 if (sum < 100) {
 Thread.sleep(10); 
 sum++;
					sout(getName() + "正在卖第" + sum + "张票!");
 } else {
 // 2. 票卖完了，跳出循环
 break; 
 }
 } catch (InterruptedException e) {
 e.printStackTrace();
 } finally {
 // 3. 无论如何都会还锁
 lock.unlock(); 
 }
 }
 }
}

锁的权衡 (Trade-off)

synchronized：自动挡。适合 80% 的日常业务场景，JVM 帮你管，安全、省心。
Lock：手动挡。适合 20% 的高并发、高性能、复杂调度场景。能漂移、能极速，但操作不当容易熄火（死锁）。
结论：优先使用 synchronized，直到你发现它实现不了你的某个高级需求（如公平性、超时、尝试获取）时，再重构为 Lock。

等待唤醒机制

生产者 (Producer)：负责准备数据（比如从网络下载图片、计算游戏解法）。
消费者 (Consumer)：负责使用数据（比如把图片渲染到屏幕、执行步数）。
仓库 (Buffer)：中间存储数据的变量或容器。

方法名	作用	状态切换
`wait()`	让当前线程释放锁，进入等待池，直到被唤醒	运行 -> 等待
`notify()`	随机唤醒一个在该锁上等待的线程	等待 -> 就绪
`notifyAll()`	唤醒在这把锁上等待的所有线程（更安全）	等待 -> 就绪

//定义中间控制类（Buffer）
public class Desk {
 // 0: 没有饭, 1: 有饭
 public static int foodFlag = 0;
 // 锁对象
 public static final Object lock = new Object();
}

//消费者
public void run() {
 while (true) {
 synchronized (Desk.lock) {
 if (Desk.foodFlag == 0) {
 try { Desk.lock.wait(); } catch (Exception e) {} // 没饭就等
 } else {
 System.out.println("吃货：开炫！");
 Desk.foodFlag = 0; // 吃完了
 Desk.lock.notifyAll(); // 叫醒厨师再做点
 }
 }
 }
}

//生产者
public void run() {
 while (true) {
 synchronized (Desk.lock) {
 if (Desk.foodFlag == 1) {
 try { Desk.lock.wait(); } catch (Exception e) {} // 有饭就歇着
 } else {
 System.out.println("厨师：出锅一份回锅肉！");
 Desk.foodFlag = 1; // 饭好了
 Desk.lock.notifyAll(); // 叫醒吃货开饭
 }
 }
 }
}

阻塞队列

实现类	特点	适用场景
`ArrayBlockingQueue`	有界，底层是数组	必须指定大小，性能稳定，最常用。
`LinkedBlockingQueue`	可选界，底层是链表	默认大小是 `Integer.MAX_VALUE`（接近无限），容易 OOM。

//生产者
public class Cook extends Thread {
 private BlockingQueue<String> queue;
 public Cook(BlockingQueue<String> queue) { this.queue = queue; }

 @Override
 public void run() {
 while (true) {
 try {
 // put 方法自带阻塞逻辑：如果队列满了，就在这儿等
 queue.put("回锅肉");
 System.out.println("厨师放了一份回锅肉，当前库存：" + queue.size());
 } catch (InterruptedException e) { e.printStackTrace(); }
 }
 }
}

//消费者
public class Foodie extends Thread {
 private BlockingQueue<String> queue;
 public Foodie(BlockingQueue<String> queue) { this.queue = queue; }

 @Override
 public void run() {
 while (true) {
 try {
 // take 方法自带阻塞逻辑：如果队列空了，就在这儿等
 String food = queue.take();
 System.out.println("吃货炫了一份：" + food);
 } catch (InterruptedException e) { e.printStackTrace(); }
 }
 }
}

//测试类（连接两者）
// 创建一个只能装 1 份饭的阻塞队列
BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

new Cook(queue).start();
new Foodie(queue).start();

操作类型	抛出异常	返回特殊值	阻塞（推荐）	超时退出
插入	`add(e)`	`offer(e)`	`put(e)`	`offer(e, time, unit)`
移除	`remove()`	`poll()`	`take()`	`poll(time, unit)`
检查	`element()`	`peek()`	无	无

线程池

线程池的优点

降低资源消耗：通过重复利用已创建的线程，降低线程创建和销毁造成的开销。
提高响应速度：任务到达时，不需要等待线程创建就能立即执行。
提高线程的可管理性：线程是稀缺资源，如果无限制地创建，会降低系统稳定性。线程池可以进行统一分配、调优和监控。

API	问题
`Executors.newFixedThreadPool()`	使用无界队列，可能导致 OOM
`Executors.newCachedThreadPool()`	最大线程数为 Integer.MAX_VALUE，可能瞬间创建几十万线程
`Executors.newScheduledThreadPool()`	核心线程不会回收

核心元素

参数	对应比喻	官方定义
`corePoolSize`	正式员工	核心线程数（常驻线程）。
`maximumPoolSize`	全部员工	最大线程数（核心 + 临时）。
`keepAliveTime`	解雇等待期	临时线程闲置多久后被销毁。
`unit`	时间单位	对应上面的时间单位（秒、分钟等）。
`workQueue`	等候区	任务阻塞队列（放不下的活先排队）。
`threadFactory`	HR/招聘	线程工厂（给线程起名、设优先级）。
`handler`	拒单策略	拒绝策略（活太多实在干不完怎么办）。

具体实现

ThreadPoolExecutor pool = new ThreadPoolExecutor( 
 3, //核心线程数量 不能小于0 
 6, //最大线程数量 不能小于0 且>=核心线程数量 
 60, //空闲线程最大存活时间 
 TimeUnit.SECONDS, //空闲线程最大存活时间的单位 
 new ArrayBlockingQueue<>(3),//任务队列 不能为null 
 Executors.defaultThreadFactory(),//线程工厂 不能为null 
 new ThreadPoolExecutor.AbortPolicy()//拒绝策略 不能为null 
);
	任务 1~3：直接创建 3 个核心线程（正式工）开始干活
	
	任务 4~6：核心线程已满，3 个任务进入 ArrayBlockingQueue（等候区）排队
	
	任务 7~9：等候区已满，线程池开启 3 个临时线程（临时工），总线程数达到 maximumPoolSize 6 个并开始干活
	
	任务 10：核心线程、队列、临时线程均已满，触发 AbortPolicy 拒绝策略，程序抛出 RejectedExecutionException 异常

网络编程

Thu, 26 Mar 2026 00:00:00 +0000

本文更新于 2026-03-26

常见架构

维度	C/S (客户端模式)	B/S (浏览器模式)
硬件要求	较高（利用本地资源）	较低（主要靠服务器）
部署难度	困难（需逐个安装）	极易（地址一输即用）
升级维护	整体升级，成本高	无缝升级，用户无感
网络要求	部分功能可离线运行	必须全程联网
典型案例	英雄联盟、Photoshop	知乎、GitHub、1Panel

网络编程三要素

1. IP 地址 (Internet Protocol Address) —— “收货地址”

设备在网络中的唯一标识。 如果没有 IP 地址，数据包就不知道该发给哪台电脑。

IPv4：目前主流，如 192.168.1.1。它是 32 位地址，通常用“点分十进制”表fff示。
IPv6：为了解决 IPv4 地址枯竭问题，位数为 128 位，采用“冒分十六进制”。
特殊地址：127.0.0.1 或 localhost（回环地址，代表本机）。

方法名	作用	返回值示例
`getHostName()`	获取主机名	`www.baidu.com` 或 `LAPTOP-XXXX`
`getHostAddress()`	获取字符串格式的 IP 地址	`110.242.68.4`
`isReachable(int timeout)`	测试在指定时间内是否能连接上该地址	`true` / `false`（类似 ping）

2. 端口 (Port) —— “收货人姓名/房间号”

应用程序在设备中的唯一标识。 一台电脑上同时运行着微信、IDEA、拼图游戏和浏览器，IP 只能找电脑，而端口负责找到对应的程序。

范围：0 ~ 65535。
分类：
- 周知端口 (0~1023)：被系统协议占用，如 HTTP (80)、HTTPS (443)、FTP (21)。
- 注册端口 (1024~49151)：常用软件占用，如 MySQL (3306)、Tomcat (8080)、Redis (6379)。
- 动态端口 (49152~65535)：系统自动分配。
注意：同一个端口在同一时刻不能被两个程序同时占用。

3. 协议 (Protocol) —— “语言/交通规则”

数据传输的规则。 通信双方必须遵守相同的约定（如数据格式、重传机制），才能听懂对方在说什么。

在 Java 基础开发中，最核心的是 传输层 的两大协议：

协议	UDP (用户数据报协议)	TCP (传输控制协议)
连接性	面向无连接（直接发，不管对方在不在）	面向连接（必须先握手建立连接）
可靠性	不可靠（可能丢包、乱序）	可靠（保证数据准确、有序）
传输效率	极高（没有确认机制）	相对较低
传输限制	每个数据包限 64KB	无限制（流式传输）
典型应用	视频会议、直播、语音通话	浏览器网页 (HTTP)、文件传输、邮件

TCP/IP协议

层级	层名称	核心职责 (快递比喻)	常见协议
4	应用层 (Application)	内容制作：决定快递寄什么（信件、包裹、视频）。	HTTP, FTP, DNS, SMTP
3	传输层 (Transport)	运输方式：平邮（UDP）还是挂号信（TCP）。	TCP, UDP
2	网络层 (Internet)	地址路由：规划从上海到北京的最优路线。	IP, ICMP, ARP
1	网络接口层 (Link)	物理运输：实际上是走铁路、公路还是空运。	Ethernet (以太网), Wi-Fi

UDP发送数据

具体流程

找邮局：创建 DatagramSocket 对象（码头/发送端）。
装包裹：创建 DatagramPacket 对象，并打包数据、指定接收端 IP 和端口。
发快递：调用 send() 方法发送包裹。
关门走人：释放资源（close()）。

	DatagramSocket ds = new DatagramSocket(); 
	String s = "你好"; 
	byte[] bytes = s.getBytes(); 
	InetAddress address = InetAddress.getLocalHost(); 
	 
	int port = 10086; 
	 
	DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port); 
	 
	ds.send(dp); 
	ds.close();

UDP接收数据

具体流程

设信箱：创建 DatagramSocket 对象，并明确指定端口（必须和发送端指向的端口一致）。
准备空盘子：创建一个字节数组，用来存放接收到的数据。
造空包裹：创建 DatagramPacket 对象，作为接收数据的容器。
等快递：调用 receive() 方法。注意：这个方法是阻塞的，没收到货之前程序会一直停在这儿。

	DatagramSocket ds = new DatagramSocket(10086); 
	 
	byte[] bytes = new byte[1024]; 
	DatagramPacket dp = new DatagramPacket(bytes, bytes.length); 
	
	//receive是阻塞的
	ds.receive(dp); 
	
	byte[] data = dp.getData(); 
	int len = dp.getLength(); 
	InetAddress address = dp.getAddress(); 
	int port = dp.getPort(); 
	 
	System.out.println("接收到了来自" + address + ":" + port + "的数据:" + new String(data, 0, len));

UDP的三种通信方式

单播

这是最常见的通信方式。发送端明确指定接收端的 IP 地址 和 端口号。只有目标主机能收到数据包。
特点：点对点，不会给其他不相关的机器造成负担。
Java 实现：使用常规的 InetAddress.getByName("192.168.1.100")

广播

发送端向局域网（LAN）内的所有主机发送数据。无论对方想不想听，数据都会送到他们的门口。
广播地址：固定为 255.255.255.255。
特点：范围限制在当前局域网内，路由器通常不会转发广播包（防止垃圾信息塞满互联网）。
Java 实现：

	// 发送到广播地址
	InetAddress address = InetAddress.getByName("255.255.255.255");
	DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, 10086);

组播

组播是介于单播和广播之间的一种高效方式。发送端向一个特定的组播地址发消息，只有“加入”了这个组的主机才能收到。
组播地址范围：D 类地址（224.0.0.0 ~ 239.255.255.255）。其中 224.0.0.0 ~ 224.0.0.255 为预留。
特点：比广播更节省资源，只有感兴趣的主机才会处理数据。
Java 实现（特殊类）：接收端需要使用 MulticastSocket 并调用 joinGroup()

TCP发送和接收数据

客户端 (Socket)：主动拨号的人（请求连接）。
服务端 (ServerSocket)：接电话的人（等待连接）。

//TCP发送数据
	
	// 1. 创建客户端 Socket 对象，并连接服务端
	// 这一步会自动完成“三次握手”
	Socket socket = new Socket("127.0.0.1", 10086);

	// 2. 获取输出流，准备往服务器写数据
	OutputStream os = socket.getOutputStream();

	// 3. 写出数据
	os.write("你好，TCP服务端！我是客户端".getBytes());

	// 4. 释放资源
	os.close();
	socket.close();
	
	
//TCP接收数据

	// 1. 创建服务端的 ServerSocket，并指定端口
	ServerSocket ss = new ServerSocket(10086);

	// 2. 等待客户端连接（阻塞式）
	// 只有客户端拨通了，这行代码才会往下走，并返回一个 Socket 对象
	System.out.println("服务端已启动，等待连接...");
	Socket socket = ss.accept(); 

	// 3. 获取输入流，读取客户端发来的数据
	InputStream is = socket.getInputStream();
	byte[] bytes = new byte[1024];
	int len = is.read(bytes); // 读取数据

	// 4. 解析并打印
	String msg = new String(bytes, 0, len);
	System.out.println("收到消息：" + msg);

	// 5. 释放资源
	socket.close();
	ss.close();

三次握手 (Three-way Handshake) —— 建立连接

核心目的：确认双方的收、发能力都是正常的，并同步序列号。

第一次握手：客户端发送一个 SYN 包给服务端。
- 潜台词：“喂，你能听到我说话吗？”（客户端：确认自己能发；服务端：确认自己能收，对方能发）。
第二次握手：服务端收到后，回传一个 SYN + ACK 包。
- 潜台词：“我能听到！你能听到我说话吗？”（服务端：确认自己能发；客户端：确认自己能收，对方能发/收都正常）。
第三次握手：客户端收到后，再回传一个 ACK 包。
- 潜台词：“我也能听到。那我们要开始传数据了。”（服务端：确认对方收/发都正常）。

四次挥手 (Four-way Wave) —— 释放连接

核心目的：确保双方都发送完了数据，并优雅地关闭双向通道。

第一次挥手：客户端发一个 FIN 包。
- 潜台词：“我的数据传完了，我要挂了。”（此时客户端进入半关闭状态）。
第二次挥手：服务端回一个 ACK。
- 潜台词：“我知道你要挂了，但我这儿还有点活没干完，你等会儿。”（此时服务端可能还在发最后的数据）。
第三次挥手：服务端干完活了，发一个 FIN。
- 潜台词：“好了，我也干完了，挂吧。”
第四次挥手：客户端回一个 ACK，并进入 TIME_WAIT 状态。
- 潜台词：“收到，拜拜！”（客户端会等一会儿确保服务端收到了这个 ACK，然后彻底消失）。

为什么握手是 3 次，挥手要 4 次？

为什么不是 2 次？ * 防止“失效的连接请求”突然到达服务端。如果只有 2 次，服务端一回应就建立连接，但客户端其实已经走掉了，这会浪费服务端资源。
为什么挥手多一次？ * 核心原因：半关闭状态。当客户端说“我不发了”时（第一次挥手），服务端可能还有数据没发完。服务端必须先回一个 ACK 告诉客户端“我收到你的请求了”，等自己发完最后的数据，再发 FIN（第三次挥手）。中间这两步不能合并。

反射与动态代理

Fri, 27 Mar 2026 00:00:00 +0000

本文更新于 2026-03-26

反射

原定义：允许对封装类的字段，方法，和构造函数的信息进行编程式访问
反射允许程序在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意方法和属性。
正常方式：引入包 $\rightarrow$ new 对象 $\rightarrow$ 调用方法。
反射方式：获取 Class 对象 $\rightarrow$ 解剖类内容 $\rightarrow$ 操作成员。

获取 Class 对象的三种方式

类名.class（最安全，性能最高）： Class clazz = Student.class;
- 一般当作参数进行传递
对象.getClass()（已有对象时使用）： Student s = new Student(); Class clazz = s.getClass();
Class.forName(“全类名”)（最常用，配置文件加载）： Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");

核心API

操作目标	对应类	核心方法
构造方法	`Constructor`	`newInstance(参数)` ：创建对象
成员变量	`Field`	`set(对象, 值)` / `get(对象)`
成员方法	`Method`	`invoke(对象, 参数)` ：运行方法

反射获取构造方法

方法名	作用	备注
`getConstructors()`	获取所有 public 构造	只能拿到公有的。
`getDeclaredConstructors()`	获取所有构造	包含私有、受保护的。
`getConstructor(Class...)`	获取指定的 public 构造	需传入参数类型的字节码。
`getDeclaredConstructor(Class...)`	获取指定的构造	最常用，可以获取私有构造。

反射获取成员变量

方法名	作用	备注
`getFields()`	获取所有 public 变量	包含从父类继承的公有变量。
`getDeclaredFields()`	获取所有变量	仅限本类定义的（含私有）。
`getField(String name)`	获取指定的 public 变量	根据变量名获取。
`getDeclaredField(String name)`	获取指定的变量	可以获取私有变量。

当变量为private时，可以通过setAccessible(true)设置为可访问

	Class clazz = Class.forName("asia.creat.demo2.Student"); 
	Field name = clazz.getDeclaredField("name"); 
	
	Student s = new Student("张三",23,"男"); 
	name.setAccessible(true); 
	Object value = name.get(s); 
	System.out.println(value);

反射获取成员方法

方法名	作用	备注
`getMethods()`	获取所有 public 方法	包含本类及父类继承的所有公有方法。
`getDeclaredMethods()`	获取所有方法	仅限本类定义的（含私有）。
`getMethod(String, Class...)`	获取指定的 public 方法	需指定方法名和参数类型。
`getDeclaredMethod(String, Class...)`	获取指定的方法	用于精确锁定本类某个方法。

总结：反射的三步

获取 Class 对象：Class clazz = Class.forName("全类名");
获取成员对象：
- 找构造：getDeclaredConstructor()
- 找属性：getDeclaredField("变量名")
- 找方法：getDeclaredMethod("方法名", 参数.class)
暴力拆解（针对 private）：
- 执行 setAccessible(true);
实际操作：
- 构造 $\rightarrow$ newInstance()
- 属性 $\rightarrow$ set() / get()
- 方法 $\rightarrow$ invoke()

动态代理

无侵入性：不需要修改 BigStar 的任何代码，就能给它增加功能。
JDK 代理限制：只能代理实现了接口的类。如果一个类没接口，需要使用 CGLIB（通过继承实现代理）。
应用场景：
- 日志记录：每个方法执行前打印参数，执行后打印耗时。
- 权限校验：执行方法前检查用户是否登录。
- 事务管理：Spring 在方法开始前开启事务，结束后提交或回滚。

// 1. 定义接口（明星的功能清单）
interface Star {
 String sing(String name);
 void dance(String name);
}

// 2. 定义实现类（真正的明星：被代理对象）
class BigStar implements Star {
 private String name;

 public BigStar(String name) {
 this.name = name;
 }

 @Override
 public String sing(String name) {
 System.out.println(this.name + "正在唱歌: " + name);
 return "谢谢";
 }

 @Override
 public void dance(String name) {
 System.out.println(this.name + "正在跳舞: " + name);
 }

 // Getter & Setter ...
 public String getName() { return name; }
 public void setName(String name) { this.name = name; }
}

// 3. 创建代理工具类（经纪人生成器）
import java.lang.reflect.Proxy;

class ProxyUtil {
 public static Star creatProxy(BigStar bs) {
 /*
 * Proxy.newProxyInstance 参数说明：
 * 1. 类加载器：用于加载生成的代理类
 * 2. 接口数组：告诉代理类要实现哪些方法
 * 3. 处理器(InvocationHandler)：定义代理对象要额外做的“杂事”
 */
 Star s = (Star) Proxy.newProxyInstance(
 ProxyUtil.class.getClassLoader(),
 new Class[]{Star.class},
 (proxy, method, args) -> {
 // 这里就是“增强”逻辑（插队干活）
 if ("sing".equals(method.getName())) {
 System.out.println("【准备】准备话筒，收钱");
 } else if ("dance".equals(method.getName())) {
 System.out.println("【准备】准备场地，收钱");
 }
 
 // 核心步骤：通过反射调用被代理对象（明星）的真实方法
 return method.invoke(bs, args);
 }
 );
 return s;
 }
}

// 4. 测试类（外部调用）
public class ReflectDemo {
 public static void main(String[] args) {
 // 1. 创建真实的对象
 BigStar bs = new BigStar("张三");
 
 // 2. 获取代理对象（请经纪人）
 Star proxy = ProxyUtil.creatProxy(bs);

 // 3. 通过代理对象调用方法
 String result = proxy.sing("《千里之外》");
 System.out.println("返回值: " + result);

 System.out.println("--------------------");

 proxy.dance("太空步");
 }
}

PTA临时

Fri, 08 May 2026 00:00:00 +0000

本文更新于 2026-05-08

顺序查找（数组作形参）

int search(int arr[],int n,int x){
 for(int i = 0; i < n; i++){
 if(arr[i] == x) return i;
 }
 return -1;
}

思路：

设置循环变量 i，从 0 开始遍历数组。
每遍历一个元素，与目标值 x 进行比较。
若相等，直接返回当前下标 i。
循环结束仍未找到，返回 -1 表示查找失败。
时间复杂度：O(n)。

顺序查找（顺序表作形参）

int searchSq(SqList L,ElemType x){
 for(int i = 0; i < L.len; i++){
 if(L.data[i] == x) return i;
 }
 return -1;
}

思路：

顺序查找的核心思路与数组版本完全相同。
区别在于数组边界由 SqList 结构体的 L.len 控制。
从 0 到 L.len-1 依次遍历 L.data[]。
找到则返回下标，未找到返回 -1。

有序表的插入（数组作形参）

void insert(int a[], int *n, int x) {
 int i = *n - 1;
 while (i >= 0 && a[i] > x) {
 a[i + 1] = a[i];
 i--;
 }
 a[i + 1] = x;
 (*n)++;
}

思路：

初始化 i = n - 1，指向当前数组的最后一个元素。
从后向前寻找插入位置，只要 a[i] > x，说明 x 应插在这些元素之前。
因此将 a[i] 后移一位到 a[i+1]，腾出空位。
i 递减，继续向前比较。
循环结束后，i+1 就是 x 应该插入的位置。
将 x 写入 a[i+1]，数组长度 n 加一。
由于数组有序，插入后仍然保持有序。

有序表的插入（顺序表作形参）

void ListInsertByOrder(SqList L, ElemType x){
 int len = L->length;
 if(len == LISTSIZE){
 printf("顺序表已满，无法进行插入操作！");
 return;
 }
 int i = len - 1;
 while(i>=0 && L->elem[i] > x){
 L->elem[i+1] = L->elem[i];
 i--;
 }
 L->elem[i+1] = x;
 L->length++;
 return;
}

思路：

步骤一：检查顺序表是否已满，已满则无法插入，直接返回。
步骤二：获取当前长度 len，从 len-1 位置开始向前查找插入位置。
步骤三：将所有大于 x 的元素依次后移，腾出插入位置。
步骤四：循环结束后，在 i+1 处写入 x。
步骤五：顺序表长度加一，插入完成。

有序表的插入（单链表作形参）

LinkList InsertList(LinkList L, EType X){
 LNode* x = (LNode*)malloc(sizeof(LNode));
 x->data = X;
 LNode* pre = (LinkList)malloc(sizeof(LNode));
 pre = L;
 while(pre->next != NULL && pre->next->data > X){
 pre = pre -> next;
 }
 x-> next = pre->next;
 pre -> next = x;
 return L;
}

思路：

步骤一：为新值 X 创建一个新节点 x。
步骤二：初始化前驱指针 pre 指向链表头 L。
步骤三：向后遍历链表，找到第一个大于 X 的节点的前驱 pre。
步骤四：将新节点接入链表：x->next = pre->next，pre->next = x。
由于链表有序，插入后链表仍然有序。

合并两个有序数组（数组作形参）

void merge(int* a, int m, int* b, int n, int* c){
 int i = 0,j = 0, k = 0;
 while(i<m && j<n){
 if(a[i] < b[j]){
 c[k++] = a[i++];
 }else if(a[i] > b[j]){
 c[k++] = b[j++];
 }else{
 c[k++] = a[i++];
 c[k++] = b[j++];
 }
 }
 while(i<m) c[k++] = a[i++];
 while(j<n) c[k++] = b[j++];
}

思路：

步骤一：设置三个指针——i 指向数组 a，j 指向数组 b，k 指向结果数组 c。
步骤二：双指针同时遍历两数组，每次将较小的元素放入 c。
步骤三：若两元素相等（==），则两个都放入 c，允许重复值存在。
步骤四：当其中一个数组遍历完成后，将另一个数组的剩余元素全部复制到 c。
此为经典的二路归并算法，时间复杂度 O(m+n)。

合并两个有序表（顺序表作形参）

SqList MergeList_Sq(SqList La, SqList Lb){
 SqList Lc = InitList(MAXSIZE);;
 int i = 0,j = 0,k = 0;
 int iLen = La->length,jLen = Lb->length;
 while(i<iLen && j<jLen){
 if(La->elem[i] <= Lb->elem[j]){
 Lc->elem[k++] = La->elem[i++];
 }else{
 Lc->elem[k++] = Lb->elem[j++];
 }
 }
 while(i<iLen) Lc->elem[k++] = La->elem[i++];
 while(j<jLen) Lc->elem[k++] = Lb->elem[j++];
 Lc -> length = iLen + jLen;
 return Lc;
}

思路：

步骤一：初始化一个新的顺序表 Lc。
步骤二：用三个指针 i、j、k 分别遍历 La、Lb、Lc。
步骤三：比较两表中当前元素，较小的复制到 Lc。
步骤四：任一表遍历完后，将另一表的剩余元素全部接入 Lc。
步骤五：设置 Lc 的长度为两表长度之和，返回 Lc。

线性表元素的区间删除

List Delete( List L, ElementType minD, ElementType maxD ){
 int j = 0;
 for(int i = 0; i <= L->Last; i++){
 ElementType ele = L->Data[i];
 ElementType jele = L->Data[j];
 if(ele<=minD || ele>=maxD){
 L->Data[j] = ele;
 j++;
 }
 }
 L->Last = j-1;
 return L;
}

思路：

步骤一：设置双指针——i 用于遍历整个顺序表，j 用于标记保留下来的元素应放置的位置。
步骤二：遍历每个元素 ele，判断是否在开区间 (minD, maxD) 之内。
步骤三：若 ele <= minD 或 ele >= maxD（即不在区间内），则保留。将 ele 写入 L->Data[j]，j 加一。
步骤四：若在区间内，则跳过（不写入），相当于删除。
步骤五：遍历结束后，更新 L->Last = j-1，即新的最后元素下标。
此为原地压缩算法，空间复杂度 O(1)。

单链表遍历

void Traverse(LinkList L){
 L = L->next;
 while(L != NULL){
 printf("%d ",L->data);
 L = L->next;
 }
}

思路：

步骤一：由于链表可能带头结点，先将 L 跳过头结点，指向第一个数据节点。
步骤二：进入循环，只要 L != NULL 就继续遍历。
步骤三：打印当前节点的 data 值。
步骤四：将 L 指向下一个节点，继续循环。
循环终止条件为 L == NULL（到达链表末尾）。

链式表的按序号查找

ElementType FindKth( List L, int K ){
 K--;
 int index = 0;
 List p = L;
 while(p != NULL){
 if(index == K){
 return p->Data;
 }
 p = p->Next;
 index++;
 }
 return -1;
}

思路：

步骤一：将目标序号 K 减一，因为链表下标从 0 开始计数（序号1对应下标0）。
步骤二：从链表头开始遍历，设置 index = 0 记录当前下标。
步骤三：每经过一个节点，index++，当 index == K 时返回该节点数据。
步骤四：若遍历完链表仍未找到，返回 -1 表示错误。

单链表的建立（头插法-逆序建立）

struct ListNode *createlist(){
 struct ListNode* newNode = NULL;
 int data;
 while(scanf("%d",&data) != -1){
 if(data == -1)break;
 struct ListNode* L =
 (struct ListNode*)malloc(sizeof(struct ListNode));
 L->data = data;
 L->next = newNode;
 newNode = L;
 }
 return newNode;
}

思路：

步骤一：初始化 newNode = NULL，作为当前链表的起始。
步骤二：循环读入整数，读到 -1 时结束输入。
步骤三：每读入一个数，创建新节点 L，将 L->data 设为读入的值。
步骤四：将新节点插入到链表头部——L->next = newNode，newNode = L。
步骤五：先读入的数据位于链表尾部，后读入的位于链表头部，最终链表与输入顺序相反。

单链表的建立（尾插法-顺序建立）

LinkList Create (){
 LinkList L = (LinkList)malloc(sizeof(LinkList));
 LinkList head = L;
 head->data = NULL;
 L->next = NULL;

 int data;
 while(scanf("%d",&data) != -1){
 if(data == -1) break;
 LinkList newNode = (LinkList)malloc(sizeof(LinkList));
 newNode->data = data;
 newNode->next = NULL;
 L->next = newNode;
 L = newNode;
 }
 return head;
}

思路：

步骤一：创建头结点 head（或第一个节点），用指针 L 记录当前尾节点。
步骤二：循环读入整数，读到 -1 时结束。
步骤三：每读入一个数，创建新节点 newNode。
步骤四：将新节点接入链表尾部——L->next = newNode，然后 L = newNode 更新尾指针。
步骤五：先读入的数据位于链表头部，最终链表与输入顺序一致。

单链表的按值删除

int DelNode(LinkList head, int deldata){
 int flag = 0;
 LinkList p = head;

 while(p->next != NULL) {
 if(p->next->data == deldata) {
 flag = 1;
 LinkList temp = p->next;
 p->next = temp->next;
 free(temp);
 } else {
 p = p->next;
 }
 }
 return flag;
}

思路：

步骤一：设置指针 p 指向待比较节点的前驱节点（初始为 head）。
步骤二：遍历链表，判断 p->next->data 是否等于目标值 deldata。
步骤三：若相等，说明找到了待删除节点。用临时指针 temp 保存该节点，p->next = temp->next 绕过它，然后 free(temp) 释放内存。p 不移动，继续检查。
步骤四：若不相等，p 后移到下一个节点，继续遍历。
步骤五：找到并删除则 flag = 1，返回删除结果。

单链表的按值查找

LinkList Locate_LinkList(LinkList L, datatype x){
 while(L != NULL && L->data !=x)
 L = L->next;
 return L;
}

思路：

步骤一：从链表头部开始逐个节点检查。
步骤二：每经过一个节点，比较 L->data 与目标值 x。
步骤三：若相等，返回该节点指针；若遍历完仍未找到，L == NULL，返回 NULL。

单链表的按位置查找

LinkList Findk(LinkList L, int k) {
 if (k <= 0) return NULL;
 int count = 0;
 LinkList p = L;

 while (p != NULL && count != k) {
 p = p->next;
 count++;
 }
 return p;
}

思路：

步骤一：先检查 k <= 0，非法输入直接返回 NULL。
步骤二：从链表头部开始，设置计数器 count = 0。
步骤三：向后移动指针 k 次，每移动一次 count++。
步骤四：若移动过程中到达 NULL（节点数不足 k），返回 NULL。
步骤五：若成功移动 k 步，返回当前节点 p。

带头结点的链式表操作集

List MakeEmpty(){
 struct LNode* head = (struct LNode*)malloc(sizeof(struct LNode));
 head->Data=0;
 head->Next=NULL;
 return head;
}
Position Find(List L, ElementType X ){
 struct LNode* p = L;
 while(p!=NULL){
 if(p->Data == X){
 return p;
 }
 p=p->Next;
 }
 return ERROR;
}
bool Insert( List L, ElementType X, Position P ){
 struct LNode* p = L;
 while(p!=NULL && p->Next != P){
 p=p->Next;
 }
 if(p == NULL) {
 printf("Wrong Position for Insertion\n");
 return false;
 }
 struct LNode* temp = (struct LNode*)malloc(sizeof(struct LNode));
 temp->Data = X;

 temp->Next = p->Next;
 p->Next = temp;
 return true;
}
bool Delete( List L, Position P ){
 struct LNode* p = L;
 while(p!=NULL && p->Next != P){
 p=p->Next;
 }
 if(p==NULL){
 printf("Wrong Position for Deletion\n");
 return false;
 }
 p->Next = P->Next;
 free(P);
 return true;
}

思路：

MakeEmpty：创建头结点，初始化数据为0，Next 指向 NULL，返回链表指针。
Find：从头结点遍历，依次比较每个节点的 Data 是否等于 X，找到则返回该节点指针。
Insert：
- 步骤一：先遍历找到 P 的前驱节点 p（条件 p->Next == P）。
- 步骤二：若未找到前驱（p == NULL），说明 P 不在链表中，报错并返回 false。
- 步骤三：创建新节点 temp，将其插入到 p 之后——temp->Next = p->Next，p->Next = temp。
Delete：
- 步骤一：同样先找到待删除节点 P 的前驱 p。
- 步骤二：若未找到前驱，报错并返回 false。
- 步骤三：p->Next = P->Next 绕过 P，然后 free(P) 释放内存。

删除单链表偶数节点

struct ListNode *createlist() {
 struct ListNode *head = NULL, *tail = NULL;
 int data;
 while (scanf("%d", &data) != -1 && data != -1) {
 struct ListNode *newNode = (struct ListNode *)malloc(sizeof(struct ListNode));
 newNode->data = data;
 newNode->next = NULL;

 if (head == NULL) {
 head = newNode;
 tail = head;
 } else {
 tail->next = newNode;
 tail = newNode;
 }
 }
 return head;
}

struct ListNode *deleteeven(struct ListNode *head) {
 // 步骤一：处理头部连续的偶数节点
 while (head != NULL && head->data % 2 == 0) {
 struct ListNode *temp = head;
 head = head->next;
 free(temp);
 }

 // 步骤二：若链表已空，直接返回
 if (head == NULL) return NULL;

 // 步骤三：处理后续节点中的偶数
 struct ListNode *p = head;
 while (p->next != NULL) {
 if (p->next->data % 2 == 0) {
 struct ListNode *temp = p->next;
 p->next = temp->next;
 free(temp);
 } else {
 p = p->next;
 }
 }
 return head;
}

思路：

createlist：尾插法建立链表，读到 -1 结束，过程同前文"单链表的建立（尾插法）"。
deleteeven：
- 步骤一：处理头部连续出现的偶数节点——只要 head 为偶数，就头指针后移并释放原头节点。此过程可能连续删除多个偶数。
- 步骤二：若链表已删空（head == NULL），直接返回 NULL。
- 步骤三：此时头节点必为奇数。用 p 记录待检查节点的前驱，遍历剩余链表。
- 步骤四：若 p->next 为偶数，则绕过它并释放；若为奇数，则 p 后移继续检查。
- 注意：删除偶数节点后 p 不移动，因为新顶替上来的 p->next 还需要检查。

两个有序链表序列的合并

List Merge(List L1,List L2){
 List dummy = (List)malloc(sizeof(struct Node));
 dummy->Next = NULL;
 List list1 = L1->Next;
 List list2 = L2->Next;
 List curr = dummy;
 while(list1!=NULL && list2!=NULL){
 if(list1->Data >= list2->Data){
 curr->Next = list2;
 curr = list2;
 list2 = list2->Next;
 }else{
 curr->Next = list1;
 curr = list1;
 list1 = list1->Next;
 }
 }
 curr->Next = (list1 != NULL) ? list1 : list2;
 L1->Next = NULL;
 L2->Next = NULL;
 return dummy;
}

思路：

步骤一：创建一个虚拟头结点 dummy，用它简化边界处理，curr 指向结果链表当前尾节点。
步骤二：跳过两链表的头结点，分别用 list1 和 list2 指向第一个数据节点。
步骤三：同时遍历两链表，每次比较 list1 和 list2 的数据，较小的节点接入结果链表，并后移对应指针。
步骤四：当任一链表遍历完成后，将另一链表的剩余部分直接接到结果链表末尾。
步骤五：断开原链表的连接（L1->Next = NULL，L2->Next = NULL），返回 dummy->Next。

递增的整数序列链表的插入

List Insert( List L, ElementType X ){
 List p = L;
 while (p->Next != NULL && p->Next->Data < X) {
 p = p->Next;
 }
 List newNode = (List)malloc(sizeof(struct Node));
 newNode->Data = X;
 newNode->Next = p->Next;
 p->Next = newNode;
 return L;
}

思路：

步骤一：链表带头结点，用 p 从头结点开始向后遍历。
步骤二：循环条件 p->Next != NULL && p->Next->Data < X，即向后移动直到 p->Next 是第一个 大于等于 X 的节点的前驱。
步骤三：找到位置后，创建新节点 newNode。
步骤四：将新节点接入——newNode->Next = p->Next，p->Next = newNode。
由于链表有序，插入后仍保持递增。

单链表逆转

List Reverse( List L ){
 if (L == NULL || L->Next == NULL) return L;
 struct Node* pre = NULL;
 struct Node* curr = L;
 struct Node* next = NULL;
 while(curr!=NULL){
 next = curr->Next;
 curr->Next = pre;
 pre = curr;
 curr = next;
 }
 return pre;
}

思路：

步骤一：处理边界情况——空链表或只有单节点，直接返回。
步骤二：初始化三个指针：pre = NULL（最终成为新头），curr = L（当前处理节点），next 用于暂存 curr->next。
步骤三：进入循环，每次处理一个节点的指向反转：
- 保存 next = curr->Next；
- 将 curr->Next 指向 pre（完成反转）；
- pre 后移到 curr；
- curr 后移到 next。
步骤四：当 curr == NULL 时循环结束，pre 指向原链表最后一个节点，即新链表的头结点。

单链表分段逆转

void K_Reverse( List list, int k ){
 if (k <= 1 || list == NULL || list->length < k)
 return;
 Position pre = list->head;//待转部分的前驱节点
 Position start = pre->next;//待转部分的第一个节点
 int rest = list->length;//剩余节点数量
 while(rest >= k){
 //正常反转链表
 Position prev = NULL;
 Position curr = start;
 Position next = NULL;
 for(int i=0;i<k;i++){
 next = curr->next;
 curr->next = prev;
 prev = curr;
 curr = next;
 }
 //将上一段末尾 接 这一段的头prev
 pre->next = prev;
 //将这一段末尾 接 下一段开头
 start->next = curr;
 //移动pre
 pre = start;
 //移动start
 start = curr;


 rest -=k;
 }

}

思路：

步骤一：检查边界——k <= 1 或节点数不足 k 时直接返回。
步骤二：pre 指向待反转段的前驱节点，start 指向待反转段的第一个节点，rest 记录剩余节点数。
步骤三：进入大循环，只要剩余节点数 >= k，就处理一段。
- 用三指针法反转 k 个节点，得到新头 prev，新尾 curr。
- pre->next = prev：将上一段末尾接上反转后的新头。
- start->next = curr：将反转段的新尾接上下一段的原始头。
- pre = start：前驱指针后移到反转段的原末尾（现为下一段的前驱）。
- start = curr：待反转段的起始指针后移。
- rest -= k：剩余节点数减少 k。
步骤四：当剩余节点不足 k 时退出，完成所有段的逆转。

求链表的倒数第m个元素

ElementType Find( List L, int m ){
 if(L == NULL) return ERROR;
 List fast = L;
 List slow = L;
 while(m-- && fast!=NULL) fast = fast->Next;
 if(fast == NULL) return ERROR;
 while(fast!=NULL){
 fast = fast->Next;
 slow = slow->Next;
 }
 return slow->Data;
}

思路：

步骤一：检查链表是否为空，空则返回错误。
步骤二：快慢指针初始化——fast 和 slow 都指向链表头。
步骤三：fast 先向前移动 m 步。若移动过程中到达 NULL，说明链表节点数不足 m，返回错误。
步骤四：fast 和 slow 同时向后移动，直到 fast 到达链表末尾。
步骤五：此时 slow 正好指向倒数第 m 个节点，返回其数据。

学生成绩链表处理

struct stud_node *createlist(){
 struct stud_node* head = NULL,*tail = NULL;
 int num,score;
 char name[20];
 while(1){
 scanf("%d",&num);
 if(num == 0) break;
 scanf("%s",name);
 scanf("%d",&score);
 //创建学生节点
 struct stud_node* stu =
 (struct stud_node*)malloc(sizeof(struct stud_node));
 stu->num = num;
 int i;
 for(i=0; name[i]!='\0'; i++)
 stu->name[i] = name[i];
 stu->name[i] = '\0';
 stu->score = score;
 //尾插法
 if (head == NULL) {
 head = stu;
 tail = stu;
 } else {
 tail->next = stu;
 tail = stu;
 }
 }
 return head;
}
struct stud_node *deletelist( struct stud_node *head, int min_score ){
 struct stud_node *p, *temp;
 while (head != NULL && head->score < min_score) {
 temp = head;
 head = head->next;
 free(temp);
 }
 if(head == NULL)return NULL;
 p = head;
 while(p->next!=NULL){
 if(p->next->score < min_score){
 temp = p->next;
 p->next = temp->next;
 free(temp);
 }else{
 p = p->next;
 }
 }
 return head;
}

思路：

createlist 部分：

步骤一：循环读入学号 num，若 num == 0 则结束输入。
步骤二：读入姓名 name 和成绩 score。
步骤三：创建新学生节点，填入学号、姓名（逐字符拷贝并加终止符）、成绩。
步骤四：尾插法接入链表——第一个节点时建立 head 和 tail，后续节点接在 tail 后并更新 tail。
步骤五：返回链表头指针。

deletelist 部分：

步骤一：处理头部连续的不及格节点——只要 head->score < min_score，就头指针后移并释放原头节点。
步骤二：若链表已删空（head == NULL），直接返回 NULL。
步骤三：此时头节点必符合要求。用 p 从头开始向后遍历。
步骤四：若 p->next->score < min_score，绕过并释放该节点，p 不移动（继续检查新顶替上来的节点）。
步骤五：若 p->next 符合要求，p 后移继续检查。
步骤六：返回处理后的链表头。

前/中/后缀表达式

只需更换printf的位置即可

void Prefix(BiTree T){
 if(T){
 printf("%c ",T->data);
 Prefix(T->lchild);
 //printf("%c ",T->data);
 Prefix(T->rchild);
 //printf("%c ",T->data);
 }
 return ;
}

求二叉树高度

int GetHeight( BiTree BT ){
 if(!BT) return 0;
 int l =GetHeight(BT->lchild);
 int r =GetHeight(BT->rchild);
 return (l>=r?l:r)+1;
}

统计二叉树叶子结点个数

int LeafCount ( BiTree T){
 if(!T) return 0;
 if(!T->lchild &&!T->rchild) return 1;
 return LeafCount(T->lchild) + LeafCount(T->rchild);
}

先序遍历输出二叉树的叶结点

void PreorderPrintLeaves( BiTree BT ){
 if(BT == NULL) return;
 if(BT->lchild == NULL && BT->rchild == NULL){
 printf(" %c",BT->data);
 return ;
 }
 PreorderPrintLeaves(BT->lchild);
 PreorderPrintLeaves(BT->rchild);
}

二叉树的节点数

int count_n(BinTree T){
 if(T == NULL) return 0;
 return count_n(T->Left) + count_n(T->Right) + 1;
}

二叉树的建立

BiTree CreatBiTree(){
 TElemType ch;
 scanf("%c",&ch);
 if(ch == '#') return NULL;
 BiTree node = (BiTree)malloc(sizeof(BiTNode));
 node->data = ch;

 node->lchild = CreatBiTree();
 node->rchild = CreatBiTree();
 return node;
}

二叉树的层次遍历

void Levelorder(BiTree T) {
 if (T == NULL) return;
 BiTree queue[1001];
 int head= 0;
 int rear = 0;
 queue[rear++] = T;
 while(head < rear){
 BiTree p = queue[head++];
 printf(" %c",p->data);
 if(p->lchild != NULL){
 queue[rear++] = p->lchild;
 }
 if(p->rchild != NULL){
 queue[rear++] = p->rchild;
 }
 }
}

二叉树的非递归遍历

 void InorderTraversal( BinTree BT ) {
 Stack s = CreateStack();
 while (BT || !IsEmpty(s)) {
 while (BT) {
 Push(s, BT);
 BT = BT->Left;
 }
 BT = Pop(s);
 printf(" %c", BT->Data); 
 BT = BT->Right;
 }
 }
void PreorderTraversal( BinTree BT ){
 Stack s = CreateStack();
 while (BT || !IsEmpty(s)) {
 while (BT) {
 printf(" %c", BT->Data); 
 Push(s, BT);
 BT = BT->Left;
 }
 BT = Pop(s);
 BT = BT->Right;
 }
 
}
void PostorderTraversal( BinTree BT ){
 Stack s = CreateStack();
 while (BT || !IsEmpty(s)) {
 while (BT) {
 BT->flag = 0; //标记
 Push(s, BT);
 BT = BT->Left;
 }
 BT = Peek(s);
 if(BT->flag == 0){
 //第一次回到这个节点
 BT->flag = 1 ;
 BT = BT-> Right;
 }else{
 //第二次回到节点
 Pop(s);
 printf(" %c",BT->Data);
 
 }
 }
}

哈夫曼树的构造

HFTree MakeHFTree(char data[], int weight[], int n){
 if(n == 0)return NULL;
 Heap* heap = InitHeap(n);
 for(int i = 0; data[i] != 0;i++){
 HFTree node = (HFTree)malloc(sizeof(HTNode));
 node->data = data[i];
 node->weight = weight[i];
 node->lchild = NULL;
 node->rchild = NULL;
 Insert(heap,node);
 }
 while(heap->size > 1){
 HFTree node1 = DelTop(heap);
 HFTree node2 = DelTop(heap);
 HFTree node = (HFTree)malloc(sizeof(HTNode));
 
 node->data = '\0';
 node->weight = node1->weight + node2->weight;
 node->rchild = node1;
 node->lchild = node2;

 Insert(heap,node);
 }
 HFTree root = DelTop(heap);
 return root;
}

哈夫曼编码实现

void dfs(HFTree node,char path[],int depth,char data[],char codes[][1001]){
 if(node == NULL) return;
 if(node->lchild == NULL && node->rchild == NULL){
 path[depth] = '\0';//结束
 int i;
 for(i=0; data[i]!='\0';i++){
 if(data[i] == node->data){
 break;
 }
 }
 strcpy(codes[i],path);
 return ;
 }else{
 path[depth] = '0'; dfs(node->lchild,path,depth+1,data,codes);
 path[depth] = '1'; dfs(node->rchild,path,depth+1,data,codes);
 }
}
void Show_HFcoding(HFTree root, char data[], int n){
 char codes[1001][1001];
 char path[1001];
 dfs(root,path,0,data,codes);
 for(int i = 0;i<n;i++) printf("%c:%s\n",data[i],codes[i]);
}

编程题

7-1 一元多项式的乘法与加法运算

数组映射法

#include <iostream>
using namespace std;

int poly1[1001] = {0}; 
int ans_sum[1001] = {0};
int ans_mul[2001] = {0};

// 打印多项式
void print_poly(int arr[], int max_expon) {
 bool first = true;
 // 从高次到低次输出
 for (int i = max_expon; i >= 0; --i) {
 if (arr[i] != 0) {
 if (!first) cout << " ";
 cout << arr[i] << " " << i;
 first = false;
 }
 }
 // 空多项式输出 0 0
 if (first) cout << "0 0";
 cout << endl;
}

int main() {
 int n1, n2, c, e;

 // 读取第一个多项式
 cin >> n1;
 int a_c[1001], a_e[1001];
 for (int i = 0; i < n1; ++i) {
 cin >> c >> e;
 a_c[i] = c;
 a_e[i] = e;
 ans_sum[e] += c;
 }

 // 读取第二个多项式，同时计算加法与乘法
 cin >> n2;
 for (int i = 0; i < n2; ++i) {
 cin >> c >> e;
 ans_sum[e] += c;
 
 // 乘法：逐项相乘累加
 for (int j = 0; j < n1; ++j) {
 ans_mul[e + a_e[j]] += c * a_c[j];
 }
 }

 // 输出：先乘法 后加法
 print_poly(ans_mul, 2000);
 print_poly(ans_sum, 1000);

 return 0;
}

思路（数组映射法）：

步骤一：创建三个整型数组——poly1[] 存第一个多项式，ans_sum[] 存加法结果，ans_mul[] 存乘法结果。数组下标对应指数，下标处的值对应系数。
步骤二：读入第一个多项式的 n1 项，将每项系数累加到 ans_sum[指数] 和 poly1[指数] 中（poly1 备份以便后续乘法使用）。
步骤三：读入第二个多项式的 n2 项，做两件事：
- 加法：直接累加到 ans_sum[指数]；
- 乘法：遍历第一个多项式的每一项，将 c * a_c[j] 累加到 ans_mul[e + a_e[j]]（指数相加，系数相乘）。
步骤四：按指数从高到低遍历数组，输出所有系数非零项（ans_mul 先输出，ans_sum 后输出）。
步骤五：若没有任何非零项，输出 0 0。

正常链表解决

#include <stdio.h>
#include <stdlib.h>

// 定义多项式节点
struct PolyNode {
 int coef; // 系数
 int expon; // 指数
 struct PolyNode *next;
};
typedef struct PolyNode *Polynomial;

// 辅助函数：将新项接到链表尾部
void Attach(int c, int e, Polynomial *pRear) {
 Polynomial P = (Polynomial)malloc(sizeof(struct PolyNode));
 P->coef = c;
 P->expon = e;
 P->next = NULL;
 (*pRear)->next = P;
 *pRear = P; // 更新尾指针
}

// 读入多项式
Polynomial ReadPoly() {
 int N, c, e;
 scanf("%d", &N);
 Polynomial head = (Polynomial)malloc(sizeof(struct PolyNode));
 head->next = NULL;
 Polynomial rear = head;
 while (N--) {
 scanf("%d %d", &c, &e);
 Attach(c, e, &rear);
 }
 return head;
}

// 两个多项式相加
Polynomial Add(Polynomial P1, Polynomial P2) {
 Polynomial t1 = P1->next;
 Polynomial t2 = P2->next;
 Polynomial head = (Polynomial)malloc(sizeof(struct PolyNode));
 head->next = NULL;
 Polynomial rear = head;

 while (t1 && t2) {
 if (t1->expon > t2->expon) {
 Attach(t1->coef, t1->expon, &rear);
 t1 = t1->next;
 } else if (t1->expon < t2->expon) {
 Attach(t2->coef, t2->expon, &rear);
 t2 = t2->next;
 } else {
 int sum = t1->coef + t2->coef;
 if (sum != 0) Attach(sum, t1->expon, &rear);
 t1 = t1->next;
 t2 = t2->next;
 }
 }
 while (t1) { Attach(t1->coef, t1->expon, &rear); t1 = t1->next; }
 while (t2) { Attach(t2->coef, t2->expon, &rear); t2 = t2->next; }
 return head;
}

// 两个多项式相乘
Polynomial Mult(Polynomial P1, Polynomial P2) {
 Polynomial t1 = P1->next;
 Polynomial t2 = P2->next;
 if (!t1 || !t2) return NULL;

 Polynomial head = (Polynomial)malloc(sizeof(struct PolyNode));
 head->next = NULL;

 // 用 P1 的每一项去乘 P2 的每一项
 while (t1) {
 Polynomial tempHead = (Polynomial)malloc(sizeof(struct PolyNode));
 tempHead->next = NULL;
 Polynomial tempRear = tempHead;
 Polynomial p2 = t2;
 
 while (p2) {
 Attach(t1->coef * p2->coef, t1->expon + p2->expon, &tempRear);
 p2 = p2->next;
 }
 
 // 将乘出来的这一行加到总结果里
 Polynomial oldRes = head;
 head = Add(head, tempHead);
 
 // 释放临时链表空间（此处略，考试时可不写，但在工程中很重要）
 t1 = t1->next;
 }
 return head;
}

// 打印多项式
void PrintPoly(Polynomial P) {
 if (!P || !P->next) {
 printf("0 0\n");
 return;
 }
 Polynomial t = P->next;
 int first = 1;
 while (t) {
 if (!first) printf(" ");
 printf("%d %d", t->coef, t->expon);
 first = 0;
 t = t->next;
 }
 printf("\n");
}

int main() {
 Polynomial P1 = ReadPoly();
 Polynomial P2 = ReadPoly();

 Polynomial PP = Mult(P1, P2);
 PrintPoly(PP);

 Polynomial PS = Add(P1, P2);
 PrintPoly(PS);

 return 0;
}

思路（链表法）：

ReadPoly 部分：

步骤一：读取项数 N，创建带头结点的空链表 head，尾指针 rear 初始指向 head。
步骤二：循环读取 N 次系数 c 和指数 e，调用 Attach(c, e, &rear) 将新节点接到链表尾部。
步骤三：返回链表头指针 head。

Add 部分：

步骤一：用 t1、t2 分别指向两链表的第一个数据节点（跳过头结点）。
步骤二：同时遍历两链表，按指数大小分情况处理：
- 若 t1->expon > t2->expon，将 t1 接入结果链表，t1 后移；
- 若 t1->expon < t2->expon，将 t2 接入结果链表，t2 后移；
- 若指数相等，系数相加后若非零则接入，t1、t2 同时后移。
步骤三：当任一链表遍历完后，将另一链表的剩余节点全部接入结果链表。
步骤四：返回结果链表的头指针。

Mult 部分：

步骤一：处理边界情况——任一多项式为空则返回 NULL。
步骤二：用 t1 遍历第一个多项式的每一项，对每一项：
- 步骤二.1：用 t2 遍历第二个多项式的每一项，调用 Attach 生成 t1->coef * t2->coef、t1->expon + t2->expon 的节点，构成临时结果链表 tempHead。
- 步骤二.2：将 tempHead 与已有的 head 通过 Add 函数合并，更新 head。
步骤三：t1 后移，重复以上过程直到 P1 所有项遍历完毕。

PrintPoly 部分：

步骤一：检查链表是否为空或只有头结点，若是则输出 0 0。
步骤二：从第一个数据节点开始遍历，用 first 标记控制空格输出格式，逐个打印系数和指数。
步骤三：遍历完毕换行。

7-2 银行业务队列简单模拟

#include<bits/stdc++.h>
using namespace std;
int main(void){
 int n;
 cin >> n;
 int x;
 queue<int>a,b;
 for(int i=0;i<n;i++){
 cin >> x;
 if(x%2 & 1) a.push(x);
 else b.push(x);
 }
 if(n == 1){
 cout << x ;
 }else{
 x = a.front();
		cout << x;
		a.pop();
		x = a.front();
		cout << " " << x;
		a.pop();
 while(!a.empty() && !b.empty()){
 //B
 x = b.front();
 cout << " " << x; b.pop();
 //A
 x = a.front();
 cout << " " << x; a.pop();
 if(!a.empty()){
 x = a.front();
 cout << " " << x; a.pop();
 }
 }
 while (!a.empty()) {
			x = a.front();
			cout << " " << x;
			a.pop();
		}
		while (!b.empty()) {
			x = b.front();
			cout << " " << x;
			b.pop();
		} 
 }
 return 0;
}

web后端实战

Thu, 16 Apr 2026 00:00:00 +0000

本文更新于 2026-04-16

Restful

REST(REpresentational state Transfer)，表述性状态转换，它是一种软件架构风格。 ❗它并不是一种标准或协议，而是一组设计原则，旨在让网络服务更加简洁、高效且易于扩展。

具体请求url

动作	完整的 URL 示例	语义
查询全部	`GET localhost:8080/books`	查列表
查询单个	`GET localhost:8080/books/{id}`	查详情
新增	`POST localhost:8080/books`	存入新数据
更新	`PUT localhost:8080/books/{id}`	覆盖旧数据
删除	`DELETE localhost:8080/books/{id}`	移除数据

对应的注解

注解	对应的 HTTP 方法	REST 语义	典型应用场景
`@GetMapping`	GET	查	获取列表、查看详情、条件搜索。
`@PostMapping`	POST	增	提交表单、上传文件、新增部门/员工。
`@PutMapping`	PUT	改（整）	修改整个对象的信息（如修改员工的所有资料）。
`@PatchMapping`	PATCH	改（部）	修改部分信息（如只修改状态、只重置密码）。
`@DeleteMapping`	DELETE	删	删除单个或批量删除资源。

特性	POST	PUT
语义	创建 (Create)：用于创建子资源。	更新/替换 (Update/Replace)：用于更新或替换指定资源。
资源标识	资源 ID 通常由服务器生成。	资源 ID 通常由客户端指定。
对应 SQL	类似于 `INSERT`。	类似于 `UPDATE` (全量) 或 `REPLACE INTO`。
幂等性	不幂等。	幂等。

	@GetMapping("/depts") 
	//指定请求方式 
	public Result list(){ 
	 System.out.println("查询全部部门数据"); 
	 List<Dept> deptList = deptService.findAll(); 
	 return Result.success(deptList); 
	}

优点

轻量级: 相比早期的 SOAP 协议，REST 传输的数据量更小。
易于理解: 直接利用 HTTP 语义，开发者上手极快。
高兼容性: 只要支持 HTTP 协议的平台（浏览器、移动端、IoT）都能轻松调用。
利于缓存: 良好的 RESTful 设计可以充分利用 HTTP 缓存机制，提升性能。

数据封装

在 MyBatis 中，如果实体类属性名（比如 deptName）和数据库字段名（比如 name）对不上，MyBatis 找不到对应关系，封装出来的结果就会是 null

手动结果映射`@Results @Result`

@Mapper 
public interface DeptMapper{ 
 @Results({ 
 @Result(column = "create_time", property = "createTime"), 
 @Result(column = "update_time", property = "updateTime") 
 }) 
 @Select("SELECT id, name, create_time, update_time FROM dept ORDER BY update_time DESC") 
 List<Dept> findAll(); 
}

起别名

在写 SQL 语句时，利用 SQL 的 AS 关键字，手动将数据库字段名改成和实体类属性名一致。

优点： 简单直接。
缺点： 如果字段很多，SQL 语句会变得非常臃肿，且每个查询都要写一遍。

	SELECT 
	 id, name, 
	 dept_name AS deptName, -- 数据库是 dept_name，实体类是 deptName
	 create_time AS createTime 
	FROM dept;

开启驼峰命名自动转换 (最推荐)

这是目前最常用的方案。大部分开发规范中，数据库字段用下划线（dept_name），Java 属性用小驼峰（deptName）。

只需要在 Spring Boot 的配置文件 application.yml（或 properties）中开启一个开关，MyBatis 就会自动帮你转换。

配置文件设置：

 mybatis:
 configuration:
 # 开启驼峰命名自动映射：a_column -> aColumn
 map-underscore-to-camel-case: true

效果： 开启后，dept_name 会自动映射到 deptName

使用 ResultMap (最强大、最灵活)

如果命名完全不规则（比如数据库叫 d_n，实体类叫 deptName），或者需要处理复杂的关联查询，就需要手动定义映射规则。

在 Mapper 的 XML 文件中定义 <resultMap>：

	<resultMap id="DeptResultMap" type="com.example.pojo.Dept">
	 <id column="id" property="id" />
	 <result column="name" property="deptName" />
	 <result column="c_time" property="createTime" />
	</resultMap>
	
	<select id="findAll" resultMap="DeptResultMap">
	 SELECT id, name, c_time FROM dept
	</select>

维度	ResultMap (Join)	分开查询 (Service组装)
开发效率	高 (MyBatis 自动化)	中 (需要写 Java 逻辑)
SQL 复杂度	高 (涉及多表关联)	低 (全是单表操作)
传输压力	较大 (存在冗余字段)	小 (按需取数据)
缓存灵活性	差	好

<!--自定义结果集--> 
<resultMap id="empResultMap" type="asia.creat.pojo.Emp"> 
 <id column="id" property="id" /> 
 <result column="username" property="username" /> 
 <result column="name" property="name" /> 
 <result column="gender" property="gender" /> 
 <result column="phone" property="phone" /> 
 <result column="job" property="job" /> 
 <result column="salary" property="salary" /> 
 <result column="image" property="image" /> 
 <result column="entry_date" property="entryDate" /> 
 <result column="dept_id" property="deptId" /> 
 <result column="create_time" property="createTime" /> 
 <result column="update_time" property="updateTime" /> 
 <!--封装exprList--> 
 <collection property="exprList" ofType="asia.creat.pojo.EmpExpr"> 
 <id column="ee_Id" property="id"/> 
 <result column="ee_company" property="company"/> 
 <result column="ee_job" property="job"/> 
 <result column="ee_begin" property="begin"/> 
 <result column="ee_end" property="end"/> 
 <result column="ee_emp_id" property="empId"/> 
 </collection>
</resultMap>

Nginx

server{
	listen 90;
	# 省略......
	# ......
	location ^~ /api/{
		# 只要URL 是以 /api/ 开头的请求
		rewrite ^~/api/(.*)$ /$1 break;
		proxy_pass http://localhost:8080; # 代理转发
	}
}

各种注解

HttpServletRequest

	/* 
	* 基于HttpServetRequest接收前端请求参数，删除部门数据 
	* */ 
	@DeleteMapping("/depts") 
	public Result deleteById(HttpServletRequest request){ 
	 String idStr = request.getParameter("id"); 
	 int id = Integer.parseInt(idStr); 
	 System.out.println("根据ID删除部门:"+id); 
	 return Result.success(); 
	}

@RequestParam

	@DeleteMapping("/depts") 
	public Result deleteById(@RequestParam("id") Integer deptId){ 
	 System.out.println("根据ID删除部门:"+deptId); 
	 return Result.success(); 
	}

@DeleteMapping("/depts"): 指定该方法处理发送到 /depts 路径的 DELETE 类型请求。
@RequestParam("id"):
- ❗明确映射：强制要求前端必须传递一个名为 id 的参数，否则报错
  - 默认Request 为 true，设为false 则不传递不会报错
- 自动转换：Spring 会自动将前端传来的字符串（如 "1"）转换为 Java 的 Integer 类型。如果前端传了非数字字符，Spring 会直接抛出 400 Bad Request 错误，无需你手动编写 Integer.parseInt。
Integer deptId: 这里的变量名可以叫 deptId，因为在注解中明确指定了匹配前端的 id 字段

省略@RequestParam

如果请求参数名与形参变量名相同，直接定义方法形参即可接收 但是此时的形参只能为前端请求参数名

	@DeleteMapping("/depts") 
	public Result deleteById(Integer id){ 
	 System.out.println("根据ID删除部门:"+id); 
	 return Result.success(); 
	}

指定默认值

使用defaultValue设置默认值

	/* 
	* 分页查询 
	* */ 
	@GetMapping 
	public Result page(@RequestParam(defaultValue = "1") Integer page, Integer pageSize){ 
	 log.info("分页查询{},{}",page,pageSize); 
	 PageResult<Emp> pageResult = empService.page(page, pageSize); 
	 return Result.success(pageResult); 
	}

@RequestBody

当请求进入后端时，@RequestBody 会告诉 Spring：“不要去 URL 路径或查询参数里找数据，去请求体（HTTP Body）里找。把那段 JSON 字符串拿出来，转换成我定义的这个 Java 对象。”

Controller:
	@PostMapping("/depts") 
	public Result add(@RequestBody Dept dept){ //将json数据封装到对象 
	 System.out.println("新增部门"+dept); 
	 deptService.add(dept);
	 return Result.success(); 
	}
	
Service:
	@Override 
	public void add(Dept dept) { 
	 dept.setCreateTime(LocalDateTime.now()); 
	 dept.setUpdateTime(LocalDateTime.now()); 
	 deptMapper.add(dept); 
	}
	
Mapper:
	@Insert("INSERT INTO dept (name,create_time,update_time)VALUES (#{name},#{creatTime},#{updateTime})") 
	❗❗❗注意：VALUES后用的是属性名(驼峰命名)而不是字段名(下划线)❗❗❗
	
	void add(Dept dept);

使用前提

请求方式：通常用于 POST、PUT 或 PATCH。GET 请求没有请求体，所以不能使用
Content-Type：前端发送请求时，Header 中必须包含 Content-Type: application/json。否则后端会报 415 Unsupported Media Type 错误
属性匹配：JSON 中的键名（Key）必须与 Java 实体类中的属性名完全一致，且实体类必须提供 Setter 方法

@PathVariable

REST 风格提倡“URL 代表资源”。例如，你想访问 ID 为 5 的部门，URL 应该是 .../depts/5，而不是传统的 .../depts?id=5。这里的 5 就是一个路径变量要让 @PathVariable 生效，需要两个步骤的配合：

在路径中使用占位符：用 {变量名} 标注。
在参数前加注解：将占位符的值映射到 Java 变量。

@GetMapping("/depts/{id}") 
public Result getInfo(@PathVariable Integer id){ 
	❗❗❗ 如果占位符名称 {id} 和方法参数名 id 一致，可以直接映射❗❗❗
 System.out.println("根据ID查询部门："+ id); 
 return Result.success(); 
}

[!NOTE] 在URL中可以携带多个路径参数如 “/depts/1/0”

@DateTimeFormat

@DateTimeFormat 是一个非常实用的注解，主要用于 格式化请求参数（也就是从前端传到后端的日期字符串）

在实体类中使用（处理搜索条件）

@Data
public class EmpQueryDTO {
 private String name;
 
 // 接收类似 "2024-01-01" 的字符串
 @DateTimeFormat(pattern = "yyyy-MM-dd")
 private LocalDate beginDate;

 @DateTimeFormat(pattern = "yyyy-MM-dd")
 private LocalDate endDate;
}

直接在 Controller 参数中使用

@GetMapping 
	public Result pageByCondition(String name, Integer gender, 
		 @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, 
		 @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end, 
		...
		...
		return Result.success(result); 
	}

[!NOTE] 如果是普通 GET 请求的参数，用 @DateTimeFormat；如果是 @RequestBody 接收的 JSON 数据，用 @JsonFormat

@Options

@Options 注解主要用于在使用 注解开发（即直接在 Mapper 接口方法上写 @Insert 或 @Update）时，配置一些额外的开关和属性。最常见的用法是 获取自增主键

	@Options(useGeneratedKeys = true,keyProperty = "id")
	//获取到生成的主键 
	@Insert("...插入语句...") 
	void insertEmp(Emp emp);

useGeneratedKeys = true：告诉 MyBatis 使用数据库生成的自增主键
keyProperty = "id"：告诉 MyBatis 把拿到的主键值，设置到 emp 对象的哪个属性中执行后的效果：

	empService.insertEmp(emp); 
	System.out.println(emp.getId()); // 这里就能打印出数据库生成的那个新 ID 了

除了获取主键，@Options 还可以配置以下内容：

属性	作用
`timeout`	设置这条 SQL 执行的超时时间（单位：秒）
`flushCache`	设置为 `true` 时，只要语句被调用，就会清空一级和二级缓存
`useCache`	是否将该查询结果放入二级缓存（默认为 true）
`statementType`	设置 SQL 执行方式（默认为 `PREPARED`，即预编译）

XML形式的等价写法

	<insert id="insert" useGeneratedKeys="true" keyProperty="id">
	 insert into emp(...) values(...)
	</insert>

将多个参数提取到实体类

代码整洁：方法参数由 10 个变成 1 个。
高复用性：这个实体类可以在 Controller、Service、Mapper 之间直接传递。
自动封装：Spring MVC 会自动根据请求参数的名称（Query Params）与实体类的属性名进行匹配并赋值

@Data 
public class EmpQueryParam { 
 private Integer page = 1; 
 private Integer pageSize = 10; 
 private String name; 
 private Integer gender; 
 @DateTimeFormat(pattern = "yyyy-MM-dd") 
 private String begin; 
 @DateTimeFormat(pattern = "yyyy-MM-dd") 
 private String end; 
}

注意事项

不要加 @RequestBody：@RequestBody 是用来解析 POST 请求里的 JSON 体的。对于 GET 请求的 URL 参数映射到对象，直接写参数即可。
默认值处理：在实体类中直接为 page 和 pageSize 赋初值，可以省去 Controller 里的 @RequestParam(defaultValue = "...")。
日期处理：记得给日期属性加上 @DateTimeFormat，否则当前端传 2026-05-20 时，后端会因为无法转换为 LocalDate 而报错。

路径抽取

修改前：每个方法（如查询、删除、新增）都要在注解里写 @GetMapping("/depts") 或 @DeleteMapping("/depts/{id}")
修改后：在 public class DeptController 顶部添加 @RequestMapping("/depts")。这样下方的方法注解就可以简化，例如：
- 查询全部简写为：@GetMapping
- 根据 ID 查询简写为：@GetMapping("/{id}")

@RequestMapping("/depts") //指定请求路径前缀 
@RestController
public class DeptController { 
 @Autowired 
 private DeptService deptService; 
	 
 @RequestMapping(value = "/depts",method = RequestMethod.GET) 
 @GetMapping 
 //指定请求方式 
 public Result list(){...} 
	 
 @PostMapping 
 public Result add(@RequestBody Dept dept){...} 
	 
 @DeleteMapping 
 public Result deleteById(Integer id){...} 
	 
 @GetMapping("/{id}") --> 即为 "/depts/{id}"
 public Result getInfo(@PathVariable Integer id){...} 
	 
	 
 @PutMapping 
 public Result update(@RequestBody Dept dept){...} 
}

日志Logback

JUL (java.util.logging)：Java 原生日志框架，虽然配置简单但灵活性和性能较差
Log4j：早期非常流行的第三方日志框架，配置灵活
Logback：由 Log4j 作者开发的升级版，性能更优，也是目前 Spring Boot 默认集成的日志实现
Slf4j (Simple Logging Facade for Java)：重点强调的“简单日志门面”，它不是真正的日志实现，而是一套标准接口，允许你在不修改代码的情况下切换底层的日志框架（如从 Log4j 切换到 Logback）

	//logger 来自 SLF4j包
	private static final Logger log =
	 org.slf4j.LoggerFactory.getLogger(LogTest.class);

可替换为注解：@Slf4j

日志级别

日志级别	说明	记录方式
trace	追踪，记录程序运行轨迹，使用很少	`log.trace("...")`
debug	调试，记录调试过程中的信息，实际应用中通常视为最低级别	`log.debug("...")`
info	记录一般信息，描述运行关键事件（如网络连接、IO 操作），使用较多	`log.info("...")`
warn	警告信息，记录潜在有害情况，使用较多	`log.warn("...")`
error	错误信息，使用较多	`log.error("...")`

只有大于等于设定级别的日志才会被输出。
如果将 root 级别设为 info，那么 trace 和 debug 级别的日志将不会被记录或显示

	<root level="info">
		<appender-ref ref="STDOUT" />
		<appender-ref ref="FILE" />
	</root>

PageHelper分页查询

原理

PageHelper 利用了 MyBatis 的 拦截器（Interceptor） 机制。它的工作流程如下：

拦截：当你调用 Mapper 方法前，PageHelper 会拦截到即将执行的 SQL
解析：自动检测你当前使用的数据库类型（MySQL, Oracle, MariaDB 等）
改写：根据你设置的页码（pageNum）和每页数量（pageSize），动态地在原始 SQL 后面拼接分页子句
自动 Count：它还会额外执行一条 SELECT COUNT(0) 来获取总记录数，方便前端显示总页数
❗SQL语句结尾不能加分号；(PageHelper会追加limit语句)
❗PageHelper仅仅能对紧跟在其后的第一个查询语句进行分页处理

使用

原始Service层

	@Override 
	public PageResult<Emp> page(Integer page, Integer pageSize) { 
	 Long total = empMapper.count(); 
	 List<Emp> rows = empMapper.page((page -1)*pageSize, pageSize); 
	 return new PageResult<Emp>(total,rows); 
	}

使用后

@Override 
	public PageResult<Emp> page(Integer page, Integer pageSize) { 
	 //设置分页参数PageHelper 
	 PageHelper.startPage(page, pageSize); 
	 //执行查询 
	 List<Emp> emp = empMapper.list(page, pageSize); 
	 //解析查询结果并封装数据 
	 Page<Emp> p = (Page<Emp>) emp; //多态的实现
	 return new PageResult<Emp>(p.getTotal(), p.getResult()); 
	}

Spring事务管理

Spring 事务的本质是利用 AOP（面向切面编程）。当你给一个方法加上事务注解时，Spring 会为该类创建一个代理对象。

开启：在方法执行前，代理对象关闭自动提交，开启事务。
提交：如果方法正常执行完毕，代理对象提交事务。
回滚：如果方法执行过程中抛出异常，代理对象捕获异常并回滚数据。

@Transactional

这是开发中最常用的方式，通过注解直接管理事务，代码零侵入

@Service
public class EmpServiceImpl implements EmpService {
 @Autowired
 private EmpMapper empMapper;
 @Autowired
 private DeptMapper deptMapper;

 @Transactional // 开启事务
 @Override
 public void deleteDept(Integer id) {
 // 1. 删除部门
 deptMapper.deleteById(id);
 
 // 模拟异常：一旦报错，上面的删除操作也会撤销
 // int i = 1/0; 
 
 // 2. 删除该部门下的所有员工
 empMapper.deleteByDeptId(id);
 }
}

属性	描述
`rollbackFor`	指定哪些异常触发回滚。默认只回滚 `RuntimeException`。建议设置为 `Exception.class` 以涵盖所有异常。
`propagation`	事务传播行为：定义当一个事务方法调用另一个事务方法时，事务如何传递。
`readOnly`	是否为只读事务。查询操作建议设为 `true`，可以优化数据库性能。

rollbackFor

	@Transactional//默认出现运行时异常RuntimeException才会回滚
	@Transactional(rollbackFor = {Exception.class})//指定所有异常都会回滚

propagation

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务
SUPPORTS	支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行；如果当前存在已有事务，则挂起当前事务
MANDATORY	必须有事务，否则抛异常
NEVER	必须没事务，否则抛异常

readOnly

@Transactional(readOnly = true)
public User getUserById(Long id) {
 return userRepository.findById(id);
}

作用：告诉数据库这是一个只读事务。
好处：数据库可以针对只读操作进行优化（例如在 MySQL 中不分配回滚段），提高查询效率

维度	说明
它能防止修改吗？	不一定。这取决于数据库和驱动。虽然 Hibernate 会跳过脏检查，但如果你在只读事务中强行执行原生 SQL 的 `UPDATE`，某些数据库可能仍然允许执行（虽然这会导致语义混乱）。
主从架构（Read/Write Splitting）	这是 `readOnly` 的关键应用场景。通过 AOP 拦截 `readOnly=true` 的方法，可以将请求路由到从库（Read Node），而将其他的路由到主库。
性能损耗	虽然它能优化内存，但开启事务本身也是有开销的（获取连接、上下文切换）。对于极其简单的单条查询，有时不加 `@Transactional` 反而更快。

失效场景

非 public 方法：@Transactional 只能用于 public 方法。
方法内部调用：同一个类中，A 方法调用 B 方法，即使 B 加了注解也不会生效（因为绕过了 AOP 代理）。
异常被捕获：如果你在代码里 try...catch 了异常且没有抛出，Spring 无法感知到报错，就不会回滚。
数据库不支持：比如 MySQL 的 MyISAM 引擎不支持事务，必须使用 InnoDB。

⭐Tips

加在 Service 层：不要加在 Controller 层，确保业务逻辑的完整性。
显式指定回滚范围：推荐使用 @Transactional(rollbackFor = Exception.class)。
保持方法短小：事务会占用数据库连接，尽量不要在事务方法中进行远程接口调用或耗时操作，防止连接池耗尽

[!TIP] @Transactional 可以加在方法上、类上、接口上 ※ 推荐加在方法上 ※

文件上传

MultipartFile

MultipartFile 是处理文件上传的核心接口。它代表了 HTML 表单中 multipart/form-data 类型的文件内容。

	@PostMapping("/upload") 
	public Result upload(String name, Integer age, MultipartFile file){ 
	 log.info("接收参数：{},{},{}",name,age,file); 
	 return Result.success(); 
	}

方法	说明
`getName()`	获取表单中文件参数的名称（如上面例子中的 “file”）。
`getOriginalFilename()`	获取客户端文件系统的原始文件名。
`getContentType()`	获取内容类型（如 `image/png`）。
`isEmpty()`	判断文件是否为空（没有内容或未选择文件）。
`getSize()`	返回文件大小（单位：字节）。
`getBytes()`	以字节数组形式读取文件内容。
`getInputStream()`	获取输入流，用于流式读取（适合大文件处理）。
`transferTo(File dest)`	最常用：将上传的文件直接保存到目标文件。

问题及注意事项

多文件上传：如果你需要一次上传多个文件，将参数改为数组或列表即可： public String upload(@RequestParam("files") MultipartFile[] files)
文件名冲突：直接使用 getOriginalFilename() 可能导致重名覆盖。建议使用 UUID 或 时间戳 重命名文件。
临时存储： MultipartFile 在处理时会产生临时文件（存储在操作系统的 tmp 目录）。一旦请求处理完成，这些临时文件会被自动删除。
安全性：务必校验文件后缀名和文件头（Magic Number），防止用户上传恶意的 .exe 或 .sh 脚本文件。

存储在本地

	@PostMapping("/upload") 
	public Result upload(String name, Integer age, MultipartFile file) throws IOException { 
	 log.info("接收参数：{},{},{}",name,age,file); 
	 //原始文件名 
	 String fof = file.getOriginalFilename(); 
	 //新文件名 
	 String extension = fof.substring(fof.lastIndexOf(".")); 
	 String newName = UUID.randomUUID() + extension; 
	 //保存文件 
	 file.transferTo(new File("F:/images/"+ newName)); 
	 return Result.success(); 
	}

Spring中默认上传文件最大大小为1MB，超过大小需要在配置文件中配置

# 文件上传
Spring:
	servlet: 
	 multipart: 
	 # 最大单个文件大小 
	 max-file-size: 10MB 
	 # 最大请求大小（包含所有文件和表单数据） 
	 max-request-size: 100MB

OSS

@Value("${aliyun.oss.endpoint}") 
private String endpoint; 
@Value("${aliyun.oss.bucketName}") 
private String bucketName; 
@Value("${aliyun.oss.region}") 
private String region;

# 阿里云 OSS配置 
aliyun: 
 oss: 
 endpoint: https://oss-cn-beijing.aliyuncs.com 
 bucketName: creat-spring-oss 
 region: cn-beijing

批量注入值@ConfigurationProperties

@Component 
public class AliyunOSSOperator { 
 @Autowired 
 private AliyunOSSProperties aliyunOSSProperties; 
	
	
	public String upload(byte[] content, String originalFilename) throws ClientException {
	 String endpoint = aliyunOSSProperties.getEndpoint(); 
	 String bucketName = aliyunOSSProperties.getBucketName(); 
	 String region = aliyunOSSProperties.getRegion();
	 
	 ......
 }
}

@Data 
@Component 
@ConfigurationProperties(prefix = "aliyun.oss") 
public class AliyunOSSProperties { 
 private String endpoint; 
 private String bucketName; 
 private String region; 
}

全局异常处理器

无论程序在哪里抛出了异常，都能被这个处理器统一拦截，并返回一个优雅、格式统一的错误信息给前端或客户端

注解

@RestControllerAdvice：标记这是一个增强版的控制器，专门处理全局层面的逻辑(@ControllerAdvice + @ResponseBody)。
@ExceptionHandler：指定具体的异常类型，当这种异常发生时，执行对应的方法。

核心流程：

异常发生：Controller 或 Service 层抛出一个异常（如 UserNotFoundException）。
自动捕获：Spring 发现该异常未被内部 try-catch，于是将其向上抛给全局处理器。
匹配处理：处理器根据异常类型找到对应的处理方法。
返回结果：处理器将异常包装成一个通用的 Result 对象（包含错误码、错误消息），转换成 JSON 返回。

@RestControllerAdvice // = @ControllerAdvice + @ResponseBody
public class GlobalExceptionHandler {

 // 处理自定义业务异常
 @ExceptionHandler(BusinessException.class)
 public Result handleBusinessException(BusinessException e) {
 return Result.error(e.getCode(), e.getMessage());
 }

 // 处理参数验证异常 (如 @Valid 校验失败)
 @ExceptionHandler(MethodArgumentNotValidException.class)
 public Result handleValidationException(MethodArgumentNotValidException e) {
 String msg = e.getBindingResult().getFieldError().getDefaultMessage();
 return Result.error(400, msg);
 }

 // 兜底：处理所有未知的运行异常
 @ExceptionHandler(Exception.class)
 public Result handleException(Exception e) {
 log.error("系统崩溃了，救命！", e); 
 return Result.error(500, "服务器开小差了，请稍后再试");
 }
 ---------------------
	@ExceptionHandler 
	public Result handleException(Exception e) { 
	 log.error("发生异常: ", e); 
	 return Result.error("服务器发生异常，请稍后再试"); 
	} 
	@ExceptionHandler 
	public Result handleDuplicateKeyException(DuplicateKeyException e) { 
	 log.error("发生异常: ", e); 
	 String msg = e.getMessage(); 
	 int i = msg.indexOf("Duplicate entry"); 
	 String errMsg = msg.substring(i); 
	 String[] arr = errMsg.split(" "); 
	 
	 return Result.error("'" + arr[2] + "' 已存在，请检查数据"); 
	}
}

会话技术

工作流程

Cookie 的本质是通过 HTTP 响应头和请求头在外部交换数据：

设置阶段：服务器在响应（Response）中加入 Set-Cookie 头部字段。
存储阶段：浏览器收到响应后，将 Cookie 内容保存在本地（内存或硬盘）。
携带阶段：下次请求同一个域名时，浏览器会自动在请求（Request）头中加入 Cookie 字段。

缺点

维度	缺点	说明
存储能力	容量小	单个 Cookie 最大限制约为 4KB，不适合存大数据。
用户控制	可被禁用	用户可以在浏览器设置中完全禁止接收 Cookie，导致功能失效。
安全性	不安全	默认明文存储在客户端，极易受到 XSS 攻击窃取或中间人篡改。
访问限制	跨域限制	受到同源策略限制，Cookie 无法在不同的一级域名间直接共享。
网络性能	占用带宽	每次 HTTP 请求都会自动携带相关 Cookie，增加了请求头体积，浪费流量。
合规隐私	隐私问题	常用于行为追踪，可能触犯 GDPR 等隐私法规，令用户反感。
生命周期	时效性	默认为会话级别（关闭浏览器即消失），除非开发者手动设置 `Max-Age`。
物理限制	无法跨设备	数据绑定在特定设备的特定浏览器上，无法实现手机/电脑端同步。

典型场景与规避方案

敏感信息处理：
- 原则：绝不在 Cookie 中存储密码、身份证号等敏感数据。
- 方案：仅存储加密后的 Token，并设置 HttpOnly 属性以防止 JS 脚本读取。
移动端开发：
- 痛点：部分原生 App 内置浏览器或某些移动端环境对 Cookie 支持不佳。
- 方案：在移动端或前后端分离架构中，优先考虑使用 JWT (JSON Web Token) 并通过自定义 Header 传输。
分布式/集群环境：
- 痛点：多台服务器之间无法直接共享保存在各自内存或浏览器关联的传统 Session。
- 方案：采用 分布式会话（如 Spring Session + Redis），将状态数据统一托管在外部缓存中。

Session

工作原理

Session 的核心在于服务器与浏览器之间的一个“约定”。

创建： 当用户第一次访问服务器时，服务器会为该用户创建一个唯一的 HttpSession 对象，并生成一个唯一的 ID（通常称为 JSESSIONID）。
传递： 服务器通过 HTTP 响应头，将这个 JSESSIONID 以 Cookie 的形式发送给浏览器。
识别： 当浏览器再次请求该服务器时，会自动在请求头中携带这个 JSESSIONID。
检索： 服务器根据收到的 ID，在内存中找到对应的 Session 对象

生命周期

开始： 用户第一次调用 request.getSession() 时。
超时： 为了节省服务器内存，Session 不会永久存在。如果用户在一段时间内（默认通常是 30 分钟）没有任何操作，Session 会自动销毁。

缺点

维度	优势	劣势
开发难度	简单易用：Java 原生支持，直接调用 `getAttribute` 即可，逻辑清晰。	依赖 Cookie：如果客户端禁用了 Cookie，Session 就会失效（需额外处理 URL 重写）。
数据安全	安全性高：敏感数据留在服务器，客户端只拿一个加密 ID，不容易被篡改。	会话劫持：如果 ID 被窃取，攻击者可以完全冒充用户身份（需 HTTPS 配合）。
性能表现	读写极快：数据就在本地内存中，无需网络开销，适合单机小型应用。	内存消耗：用户多了会占满服务器内存。用户关浏览器不点退出，数据会白白占用内存直到超时。
架构扩展	无需额外中间件：单机部署时非常方便，不需要安装 Redis 等数据库。	分布式困境：多台服务器环境下，Session 不共享，会导致用户登录状态频繁丢失。
数据类型	灵活：可以存储复杂的 Java 对象，不需要像 Token 那样进行频繁的序列化转换。	存储限制：不能存太大的东西（如大列表、大图片），否则严重拖慢服务器性能。

对比Cookie

特性	Cookie	Session
存储位置	客户端（浏览器）	服务器端
安全性	较低（易被伪造或窃取）	较高（敏感数据不发送给客户端）
存储容量	较小（通常单个 4KB）	较大（取决于服务器内存）
数据类型	只能存储字符串	可以存储任意 Java 对象
性能影响	几乎不占用服务器资源	占用服务器内存，用户多时压力大

⭐Token令牌（主流）

工作原理

1. 签发： 当用户通过用户名和密码登录成功后，服务器会根据用户信息（如用户 ID）和一段只有服务器知道的“秘钥”，生成一个加密的字符串（即 Token）。

2. 传输： 服务器将这个 Token 作为响应体的一部分发送给浏览器。与 Session 不同，服务器此时不会在自己的内存或数据库中保存这个 Token。

3. 存储： 浏览器接收到 Token 后，通常将其存储在 localStorage、sessionStorage 或 Cookie 中。

4. 携带： 当浏览器后续请求受保护的资源（如获取订单列表）时，会手动将 Token 放入 HTTP 请求头中（通常放在 Authorization: Bearer <Token> 字段）。

5. 校验： 服务器接收到请求后，不再去查找数据库或内存，而是直接使用存储在服务器本地的“秘钥”对该 Token 进行解密和签名校验。

6. 提取： 如果校验通过，服务器就认为该请求是合法的，并直接从 Token 内部解密出用户信息（如该用户是“张三”），从而完成业务处理。

JWT组成

这部分用于描述 JWT 的元数据，告诉服务器如何处理这个令牌。

内容： 通常包含令牌的类型（typ: “JWT”）和所使用的加密算法（alg: 如 “HS256” 或 “RS256”）。
编码： 使用 Base64URL 算法进行编码。

	{ "alg": "HS256", "typ": "JWT" }

Payload（有效载荷）—— “货物”

这是 JWT 的核心部分，包含了实际要传递的用户信息（Claims）。

标准字段： 如签发人（iss）、过期时间（exp）、用户 ID（sub）等。
自定义字段： 你可以放入用户的角色、权限、姓名等（例如："role": "admin"）。
编码： 同样使用 Base64URL 编码。
注意： 这里的内容只是编码，并不是加密。绝对不要在此处存放密码或敏感信息，因为任何人拿到 Token 都能通过解码看到里面的内容。

	{ 
		"sub": "ZhangSan", 
		"role": "Java-Dev", 
		"exp": 1746144000 
	}

Signature（签名）—— “防伪封条”

这是保证安全的关键。它用于验证 Token 在传输过程中是否被篡改。

生成原理： 服务器将编码后的 Header 和 Payload 用点拼接起来，再加上一个只有服务器知道的密钥（Secret），按照 Header 中指定的算法进行哈希计算。
作用： 如果有人修改了 Payload 里的用户权限（比如把 user 改成 admin），由于他没有服务器的密钥，生成的签名就会和原来的不匹配。服务器校验失败，该 Token 立即失效。

	a-string-secret-at-least-256-bits-long

总结外观

一个完整的 JWT 看起来像这样： eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9. eyJzdWIiOiJaaGFuZ3NhbiIsInJvbGUiOiJKYXZhLURldiIsImV4cCI6MTc0NjE0NDAwMH0. MJSEga1Hm1wHRnaCKpjSzXcr7DpI3TlhDQoGcIWnXDA

xxxxx.yyyyy.zzzzz

红色部分 (xxxxx): 头部，声明算法。
蓝色部分 (yyyyy): 负载，存放用户信息。
绿色部分 (zzzzz): 签名，由前两部分加盐哈希而成

JWR生成/解析

private static final String SECRET = "基于base64的字符串（字节数必须大于32）"; 
private static final SecretKey KEY = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
 
@Test 
public void testGenerateJwt() { 
 Map<String, Object> dataMap = new HashMap<>(); 
 dataMap.put("userId", 1); 
 dataMap.put("username", "admin"); 
 
 String token = Jwts.builder() 
 .claims(dataMap) 
 .expiration(new Date(System.currentTimeMillis() + 3600 * 1000)) 
 .signWith(KEY) 
 .compact(); 
 
 System.out.println(token); 
} 
 
@Test 
public void testParseJwt() { 
 String token = "JWT得到的Token"; 
 Claims claims = Jwts.parser() 
 .verifyWith(KEY) 
 .build() 
 .parseSignedClaims(token) 
 .getPayload(); 
 System.out.println(claims); 
}

`Cookie,Session,Token`对比

维度	Cookie	Session	Token (JWT)
定义	存储在浏览器端的一段文本。	服务器端的一种会话记录机制。	一段经过加密/签名的凭证字符串。
核心位置	客户端	服务器（内存/数据库/Redis）	客户端（服务器不存储）
工作逻辑	浏览器自动携带。	依赖 Session ID 匹配服务器记录。	客户端手动放入 Header，服务器解密。
安全性	较低，容易被拦截或伪造。	较高，敏感信息存在服务器。	高，有签名校验，防篡改。
扩展性	无。	差，多台服务器需做数据同步。	极佳，天然支持跨服务器、跨域。
存储压力	无（存在用户本地）。	较大，用户多时会消耗大量服务器内存。	无（存在用户本地）。

优点对比

维度	Cookie (客户端存储)	Session (服务端存储)	Token (无状态令牌/JWT)
最大优势	减轻服务器压力：数据存用户本地，服务器不占内存。	数据最安全：敏感信息不发给客户端，只在服务器内部。	极易水平扩展：服务器不存任何数据，非常适合微服务/集群。
生命周期	持久性好：可以设置长达数天的有效期，甚至关机后再开也存在。	控制力强：服务器可以随时主动让某个特定用户下线。	性能均衡：不需要查数据库或缓存，服务器解析 Token 即可校验身份。
开发难度	最简单：浏览器原生支持，几乎不需要写代码逻辑。	非常简单：成熟的框架（如 Spring）自动处理 ID 传递。	跨域支持完美：不受浏览器跨域限制，App、小程序、H5 通用。
存储能力	随用随取：适合存偏好设置（如主题颜色、语言）。	类型多样：可以存复杂的 Java 对象（用户角色、权限列表）。	自包含：Token 内部可以携带用户信息，减少后端查询次数。

过滤器Filter

核心作用

过滤器主要用于处理一些通用性的横切关注点：

权限校验：检查请求头中是否携带有效的 JWT Token。
字符编码转换：统一设置 request 和 response 的编码（如 UTF-8）。
日志记录：统计接口的访问耗时、记录请求来源 IP。
敏感词过滤：对用户提交的内容进行安全扫描。

工作原理：责任链模式

过滤器并不是独立存在的，它们通常组成一个过滤器链 (FilterChain)。

执行前处理：请求进入时，过滤器先执行 doFilter 方法中 chain.doFilter() 之前的代码。
放行（传递）：调用 chain.doFilter(request, response)。如果有下一个过滤器，就传给下一个；如果没有，就传给 Servlet（或 Controller）。
执行后处理：当核心业务处理完返回响应时，代码会回到 chain.doFilter() 之后，执行后续逻辑。

执行顺序

$$Filter \rightarrow Controller \rightarrow Service \rightarrow Mapper \rightarrow DB$$
$$\uparrow \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \downarrow$$
$$Filter(回程) \leftarrow Controller \leftarrow Service \leftarrow Mapper$$

		[浏览器请求]
		 │
		 ▼
		┌────── Filter (去程：校验Token、记录时间) ──────┐
		│ │ │
		│ ▼ │
		│ ┌──── Controller (解析请求、参数校验) ────┐ │
		│ │ │ │ │
		│ │ ▼ │ │
		│ │ ┌── Service (业务逻辑处理) ────────┐ │ │
		│ │ │ │ │ │ │
		│ │ │ ▼ │ │ │
		│ │ │ ┌ Mapper (SQL执行) ──┐ │ │ │
		│ │ │ │ │ │ │ │ │
		│ │ │ │ ▼ │ │ │ │
		│ │ │ │ [ 数据库 DB ] <────┘ │ │ │
		│ │ │ │ │ (返回结果) │ │ │
		│ │ │ └────────────────────────────┘ │ │
		│ │ │ │ │ │ │
		│ │ └── Service (业务结果组装) ────────┘ │ │
		│ │ │ │ │
		│ └──── Controller (封装结果对象) ─────────┘ │
		│ │ │
		└────── Filter (回程：清理ThreadLocal、日志打印) ┘
		 │
		 ▼
		[返回响应]
//-- 这种图强调了 Filter 是最外层，它包裹着所有的内部组件：--
		( ( ( ( [ 数据库 DB ] ) ) ) )
 ▲ ▲ ▲ ▲ ▲ ▼ ▼ ▼ ▼ ▼
 │ │ │ └─────┴───┘ │ │ │ │
 │ │ └──── Mapper ─────┘ │ │ │
 │ └─────── Service ─────────┘ │ │
 └────────── Controller ───────────┘ │
 └───────────── Filter ──────────────────┘
 [请求进入] [响应返回]

去程： Client $\rightarrow$ Filter $\rightarrow$ Controller $\rightarrow$ Service $\rightarrow$ Mapper $\rightarrow$ DB

核心： 数据库执行查询/更新

回程： DB $\rightarrow$ Mapper $\rightarrow$ Service $\rightarrow$ Controller $\rightarrow$ Filter $\rightarrow$ Client

—页尾—

注意事项

@PathVariable与@RequestParam

方式	前端URL	后端请求	什么时候用？
精准定位	`/clazzs/5`	`/{id}` + `@PathVariable`	删除单个 ID
带清单操作	`/clazzs?ids=1,2,3`	`(无路径)` + `@RequestParam`	批量删除
路径串烧	`/clazzs/1,2,3`	`/{ids}` + `@PathVariable`	极少用，除非有特殊设计需求

`xml`的更新语句

字段类型	业务要求	判定表达式	避坑指南
String	必填 (非空且非空串)	`test="name != null and name != ''"`	这样可以防止前端传个空字符串 `""` 导致数据库存入无意义数据。
String	允许置空	`test="address != null"`	注意：这样如果传 `""`，它会判定为非 null，从而把空串插入数据库。
Integer / 数字	必填	`test="id != null"`	绝对不要加 `and id != ''`！如果 id 为 0，MyBatis 可能会误判它等于空串，导致 0 存不进去。
Integer / 数字	允许置空	`test="degree != null"`	同上，只判断 null 即可。

操作类型	字段类型	推荐写法	理由
SELECT (搜索)	任何类型	`!= null and != ''`	防前端传空搜索框导致的“查无数据”。
UPDATE (更新)	String	`!= null and != ''`	过滤无效空串，保证数据严谨。
UPDATE (更新)	Integer	`!= null`	最安全，防止 `0` 值无法更新。
INSERT (插入)	任何类型	`!= null`	通常只为了防止 null 值覆盖数据库默认值。

Web

Sat, 11 Apr 2026 00:00:00 +0000

本文更新于 2026-04-11

SpringBootWeb基础

/* 
* 请求处理类 
* */ 
@RestController 
public class HelloController { 
 /* 
 * 响应返回值 
 * */ @RequestMapping("/Hello") 
 public String Hello(String name){ 
 System.out.println("name:"+name); 
 return "Hello" + name + "~"; 
 } 
}

HTTP协议

概念:Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则

特点:
1. 基于TCP协议：面向连接，安全
2. 基于请求-响应模型的：一次请求对应一次响应
3. HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。
- 缺点:多次请求间不能共享数据。
- 优点:速度快

请求协议

请求数据格式

请求行 (Request Line)

包含三个核心信息：

请求方法：GET、POST、PUT、DELETE 等。
资源路径：例如 /api/v1/users。
协议版本：通常是 HTTP/1.1 或 HTTP/2。

示例：POST /login HTTP/1.1

请求头 (Request Headers)

用键值对（Key: Value）的形式告知服务器客户端的环境、权限以及数据格式。常见头信息：

Host: 服务器域名。
User-Agent: 客户端浏览器或系统信息。
Content-Type: 最重要的字段，告诉服务器请求体里装的是什么格式的数据（如 JSON 或表单）。
Authorization: 携带 Token 进行登录校验。

空行 (Empty Line)

必须存在的一行空行，用于分隔“报头”和“数据体”。

请求体 (Request Body)

真正传输的数据。注意：GET 请求通常没有请求体（参数放在 URL 后），而 POST、PUT 请求通常将数据放在这里。

请求数据获取

@RestController 
public class RequestController { 
 @RequestMapping("/request") 
 public String request(HttpServletRequest request) { 
 //获取请求方式 
 String method = request.getMethod(); 
 System.out.println("请求方式:" + method); 
 //获取请求url地址 
 String url = request.getRequestURL().toString();
 //http://localhost:8080/request 
 
 System.out.println("请求url地址:" + url); 
 String uri = request.getRequestURI();//request 
 System.out.println("请求uri地址:" + uri); 
 
 //获取请求协议 
 String protocol = request.getProtocol(); 
 System.out.println("请求协议:" + protocol); 
 //获取请求参数 - name 
 String name = request.getParameter("name"); 
 String age = request.getParameter("age"); 
 System.out.println("请求参数name:" + name + ",age:" + age); 
 
 //获取请求头 - Accept 
 String accept = request.getHeader("Accept"); 
 System.out.println("请求头Accept:" + accept); 
 
 return "OKK"; 
 } 
}

URL (Uniform Resource Locator)：资源的路径。它像家庭住址：http://localhost:8080/request。
URI (Uniform Resource Identifier)：资源的身份证。它只关心资源本身：/request。

面试题： 所有的 URL 都是 URI，但不是所有的 URI 都是 URL

响应协议

响应数据格式

响应行

协议版本 + 状态码 + 状态描述

例如：HTTP/1.1 200 OK 或 HTTP/1.1 404 Not Found。

响应头

服务器告知客户端的数据元信息。

Content-Type: 最关键。告知浏览器数据格式（如 application/json 或 text/html）。
Set-Cookie: 服务器给客户端种下的“小饼干”。

空行

分隔头部与内容。

响应体

真正传回给前端的数据（HTML、JSON、图片字节流等）

HTTP 状态码	含义说明
`1xx`	响应中 - 临时状态码，表示请求已经接收，告诉客户端应该继续请求或者如果它已经完成则忽略它。
`2xx`	成功 - 表示请求已经被成功接收，处理已完成。
`3xx`	重定向 - 重定向到其他地方；让客户端再发起一次请求以完成整个处理。
`4xx`	客户端错误 - 处理发生错误，责任在客户端。如：请求了不存在的资源、客户端未被授权、禁止访问等。
`5xx`	服务器错误 - 处理发生错误，责任在服务端。如：程序抛出异常等。
最常见状态码：

状态码	英文描述	解释
`200`	`OK`	请求成功，服务器正常处理并返回资源
`404`	`Not Found`	请求的资源不存在
`500`	`Internal Server Error`	服务器内部错误，无法完成请求
字段解释：

响应头字段	含义说明
`Content-Type`	表示该响应内容的类型，例如`text/html`, `application/json`。
`Content-Length`	表示该响应内容的长度（字节数）。
`Content-Encoding`	表示该响应压缩算法，例如`gzip`。
`Cache-Control`	指示客户端应如何缓存，例如`max-age=300`表示可以最多缓存 300 秒。
`Set-Cookie`	告诉浏览器为当前页面所在的域设置 cookie。

响应数据设置

@RestController 
public class ResponseController { 
 @RequestMapping("/response") 
 public void response(HttpServletResponse response) throws IOException { 
 //设置响应状态码 
 response.setStatus(401); 
 //设置响应头 
 response.setHeader("name","itcast"); 
 //设置响应体 
 response.getWriter().write("<h1>Hello Response</h1>"); 
 // 
 } 
 /* 
 * 方法二 
 * 基于ResponseEntity构建响应对象 
 * */ @RequestMapping("/response2") 
 public ResponseEntity<String> response2(){ 
 return ResponseEntity 
 .status(401) 
 .header("name","javaweb") 
 .body("<h1>Hello ResponseEntity</h1>"); 
 } 
}

案例

//UserController
/* 
 * 用户信息Controller 
 * */@RestController 
public class UserController { 
 @RequestMapping("/list") 
 public List<User> list() throws FileNotFoundException { 
 //加载并读取user.txt 
 InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt"); 
 ArrayList<String> lines = IoUtil.readLines 
 (in, StandardCharsets.UTF_8, new ArrayList<>()); 
 //解析用户信息，封装为User对象，list集合 
 List<User> userList = lines.stream().map(line -> { 
 String[] parts = line.split(","); 
 Integer id = Integer.parseInt(parts[0]); 
 String username = parts[1]; 
 String password = parts[2]; 
 String name = parts[3]; 
 Integer age = Integer.parseInt(parts[4]); 
 LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); 
 return new User(id, username, password, name, age, updateTime); 
 }).toList(); 
 
 //返回数据json 
 return userList; 
 } 
}

//User
@Data 
@NoArgsConstructor // 
@AllArgsConstructor //全参 
public class User { 
 private Integer id; 
 private String username; 
 private String password; 
 private String name; 
 private Integer age; 
 private LocalDateTime updateTime; 
 
}

1.静态资源文件存放位置

resources/static

2.@ResponseBody 注解的作用

将 controller 方法的返回值直接写入 HTTP 响应体

如果是对象或集合，会先转为 json，再响应

@RestController = @Controller + @ResponseBody

分层解耦

耦合: 衡量软件中各个层/各个模块的依赖关联程度。

内聚: 软件中各个功能模块内部的功能联系。

设计原则：高内聚低耦合

三层架构

层次名称	对应英文	核心注解	职责描述（通俗理解）
控制层	Controller	`@RestController`	门面。负责接收请求、校验参数，并把结果响应给前端。它不负责处理业务。
业务逻辑层	Service	`@Service`	大脑。负责所有的计算、逻辑判断、事务管理。它是系统最核心的部分。
数据访问层	dao(Data Access Object)	`@Repository`	搬运工。负责与数据库打交道，进行增删改查（CRUD）。

Controller

/* 
 * 用户信息Controller 
 * */@RestController 
public class UserController { 
 private UserService userService = new UserServiceImpl(); 
 *多态的实现*
 @RequestMapping("/list") 
 public List<User> list() throws FileNotFoundException { 
 
 List<User> list = userService.findAll(); 
 *多态的实现*
 
 return list; 
 } 
}

Service

//接口
public interface UserService { 
 /* 
 *查询所有用户信息 
 * */ 
 public List<User> findAll(); 
}

//实现类
//带impl就是一个实现类 
public class UserServiceImpl implements UserService { 
 private UserDao userDao = new UserDaoImpl(); 
	*多态的实现*
 @Override 
 public List<User> findAll() { 
 List<String> lines = userDao.findAll(); 
 *多态的实现*
 
 List<User> userList = lines.stream().map(line -> { 
 String[] parts = line.split(","); 
 Integer id = Integer.parseInt(parts[0]); 
 String username = parts[1]; 
 String password = parts[2]; 
 String name = parts[3]; 
 Integer age = Integer.parseInt(parts[4]); 
 LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); 
 return new User(id, username, password, name, age, updateTime); 
 }).toList(); 
 return userList; 
 } 
}

Dao

//接口
public interface UserDao { 
 /* 
 * 加载用户数据 
 * */ 
 public List<String> findAll(); 
}

//实现类
public class UserDaoImpl implements UserDao { 
 @Override 
 public List<String> findAll() { 
 
 InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt"); 
 
 ArrayList<String> lines = IoUtil.readLines 
 (in, StandardCharsets.UTF_8, new ArrayList<>()); 
 
 return lines; 
 } 
 
}

控制反转（IOC）& 依赖注入（DI）& Bean对象

对象的创建控制权由程序自身转移到外部(容器)，这种思想称为控制反转
容器为应用程序提供运行时，所依赖的资源，称之为依赖注入
IOC容器中创建、管理的对象，称之为Bean

IOC详解

如何将一个类交给 IOC 容器管理？

@Component（注意：是加在实现类上，而非接口上）

如何从 IOC 容器中找到该类型的 bean，然后完成依赖注入？

@Autowired

@Component时声明bean的基础注解其他三个是@Component的衍生注解

注解	适用层级	语义描述
`@Component`	通用组件	不属于以下三类时，用此注解（如工具类、配置类）。
`@Controller`	标注在控制层类 (Web)	负责处理 HTTP 请求，分发数据。
`@Service`	标注在业务逻辑层类	负责核心业务逻辑处理、事务管理。
`@Repository`	标注在数据访问层类 (Dao)	负责数据库的增删改查，并能将原生数据库异常转为 Spring 异常。（由于与mybatis整合，用的少）

[!warning] ❗：@RestController 注解内部已经包含 @Controller

❗：声明bean的时候，可以通过注解的value属性指定bean的名字，如果没有指定，默认为类名首字母小写

DI详解

基于@Autowired进行依赖注入的常见方式

①.属性注入

这是最常见、最简洁的方式。直接在成员变量上加上 @Autowired。

 @RestController
 public class UserController {
 	@Autowired
 	private UserService userService; // 直接注入
 }

优点：代码极其简洁，可读性好。
缺点：
- 不能使用 final 修饰变量（因为变量必须在对象实例化后通过反射注入）。
- 隐藏依赖关系：外部不通过反射很难看到这个类到底依赖了谁。
- 违背单一职责原则：因为写起来太简单，容易导致一个类注入了过多的依赖。

②.构造器注入—Spring官方推荐

通过类的构造函数来完成注入。

 @Service //将当前类给IOC容器管理 
 public class UserServiceImpl implements UserService { 
 private final UserDao userDao; //可以是final
 @Autowired //可省略！
 public UserServiceImpl(UserDao userDao) { 
 this.userDao = userDao; 
 }
 }

优点：
- 支持 final 关键字：保证了依赖在对象创建后不可变，更加安全。
- 完全初始化：确保对象在被调用前，所有依赖都已就绪。
- 易于测试：在写单元测试时，可以直接通过 new 一个对象并传入 Mock 依赖，不需要启动整个 Spring 容器。
注意：如果类中只有一个构造函数，Spring 4.3 以后可以省略 @Autowired

③.Setter方法注入

通过对应的 setXxx 方法来注入依赖。

 @RestController 
 public class UserController { 
 private UserService userService; 

 @Autowired 
 public void setUserService(UserService userService) { 
 this.userService = userService; 
 }
 }

优点：允许依赖在之后被修改（灵活性高）。
缺点：
- 不能使用 final。
- 对象在被使用时可能处于“未完全初始化”的状态（如果没调用 set 方法）

对比：

注入方式	是否推荐	支持 final	优点	缺点
属性注入	慎用	否	简单、快	依赖关系不透明，不方便单元测试
构造器注入	强烈推荐	是	安全、强制初始化、方便测试	代码略显冗长
Setter 注入	可选	否	灵活，可按需注入	无法保证对象完整性

当出现多个相同类型的Bean就会报错，如何解决？

①使用 @Primary

如果你希望在大多数情况下都使用某个特定的实现类，可以在该类上加上 @Primary 注解。

效果：当存在多个候选 Bean 时，Spring 会优先注入标注了 @Primary 的那一个

 @Primary
 @Service
 public class UserServiceImpl1 implements UserService { 
 // ... 
 }

 @Service
 public class UserServiceImpl2 implements UserService { 
 // ... 
 }

②使用@Qualifier(指定具体的名称)

如果你想在不同的地方注入不同的实现，可以配合 @Autowired 使用 @Qualifier，并指定 Bean 的名称。

注意：Bean 的默认名称是类名首字母小写（如 userServiceImpl1），你也可以在注解中手动指定名称，如 @Service("userService2")。

 @RestController
 public class UserController {
 @Autowired
 @Qualifier("userServiceImpl1") // 明确告诉 Spring：我要这一个
 private UserService userService;
 }

③使用@Resource(直接按名称查找)

@Resource 是 JDK 提供的注解（Spring 也支持）。它与 @Autowired 的最大区别在于查找顺序：

@Autowired：先按类型找，如果类型有多个，再按名称找。
@Resource：先按名称找，如果名称找不到，再按类型找。

 @RestController
 public class UserController {
 @Resource(name = "userServiceImpl2") // 直接通过名字“精准定位”
 private UserService userService;
 }

解决方案	核心原理	适用场景
`@Primary`	权重优先	存在一个“绝对主流”的实现类时。
`@Qualifier`	类型 + 名称辅助	需要在不同类中灵活切换不同实现时。
`@Resource`	名称优先	想减少对 Spring 注解的依赖，或更倾向于按名字查找时。

问题

问：“既然没有代码显式调用构造函数，Spring 是如何实现注入的？”

这是通过 IoC 容器 的生命周期管理实现的。Spring 启动时会解析 BeanDefinition（Bean 的定义信息）。如果发现是构造器注入，Spring 会通过反射查找匹配的参数 Bean，并利用 Constructor.newInstance() 方法完成实例化。这种方式将对象的创建权交给了容器，实现了真正的控制反转。

问：“如果你在代码里同时用了 @Primary 和 @Qualifier，谁会生效？”

“@Qualifier 的优先级更高。因为 @Primary 定义的是默认的首选 Bean，而 @Qualifier 是在注入点进行的‘精准指名’。这就好比食堂默认提供大米饭（Primary），但你明确跟打饭阿姨说你要面条（Qualifier），阿姨肯定会给你面条。”

附录

状态码大全

Maven

Fri, 10 Apr 2026 00:00:00 +0000

本文更新于 2026-04-10

用于管理和构建Java项目的工具
拥有本地仓库，中央仓库，远程仓库（私服）

* 生命周期

Maven 的工作是有固定逻辑顺序的 只需要执行一个命令，它会自动执行之前的所有步骤：（前提：同一生命周期）

clean：清理旧的编译文件（删掉 target 目录）
compile：编译源代码
test：运行单元测试
package：打包（生成可执行的 Jar 包）
install：把打好的包安装到本地仓库，让其他项目也能引用它

坐标

在 Maven 中，坐标（Coordinates） 是用来唯一标识一个 Jar 包（插件或项目）的地址

坐标的核心组成（GAV）

一个最基本的坐标由三个核心部分组成，简称 GAV：

groupId (团体/组织 ID)：
- 含义：定义当前项目隶属的实际项目或组织。
- 命名习惯：通常是公司域名的倒写。例如：com.google、org.apache、com.alibaba。
artifactId (项目 ID)：
- 含义：该组织下的某个具体模块或项目的名称。
- 命名习惯：通常是项目名。例如：spring-boot-starter-web、mysql-connector-java。
version (版本)：
- 含义：当前项目的版本号。
- 常见格式：1.0.0-RELEASE（正式版）或 2.1.5-SNAPSHOT（开发快照版）

在`pom.xml`中的样子

当你去 Maven 中央仓库 搜到一个依赖时，它会给你这样一段坐标代码，你只需把它复制到 dependencies 标签里：

	<dependency>
	 <groupId>org.mybatis</groupId>
	 <artifactId>mybatis</artifactId>
	 <version>3.5.13</version>
	</dependency>

坐标与目录结构的逻辑顺序

坐标不仅仅是几个字母，它直接决定了 Jar 包在本地仓库中的物理存放路径。

如果本地仓库路径是 D:\maven_repo，那么上面 MyBatis 的 Jar 包会被存放在： D:\maven_repo \ org \ mybatis \ mybatis \ 3.5.13 \ mybatis-3.5.13.jar

groupId：中的点（.）会被转换成文件夹斜杠（\）。
artifactId：是下一级文件夹。
version：是再下一级文件夹。

依赖配置

在 Maven 项目中，依赖配置（Dependency Configuration） 是通过 pom.xml 文件来声明项目运行所需的外部库

依赖传递与排除 (Exclusions)

这是 Maven 解决复用性的核心逻辑：如果引入了 A，而 A 依赖了 B，Maven 会自动把 B 也下载下来。

问题：如果 A 引入的 B 版本太旧，导致项目报错怎么办？解决：使用 <exclusions> 手动切断传递

<dependency>
 <groupId>com.example</groupId>
 <artifactId>library-a</artifactId>
 <version>1.0.0</version>
 
 <exclusions>
 <exclusion>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-log4j12</artifactId>
 </exclusion>
 </exclusions>
</dependency>

常见配置逻辑顺

确定需求：比如需要连接 MySQL。
查找坐标：在 MVNrepository 搜索 mysql-connector-java
粘贴配置：将代码放入 pom.xml
刷新 Maven：在 IDEA 中点击刷新图标
检查冲突：在 IDEA 右侧 Maven 面板查看 Dependencies 树，确认没有红色的冲突标识

[!WARNING] 警告

如果依赖配置变更了，必须要刷新/重新加载

单元测试

单元测试 (Unit Testing) 是指对软件中的最小可测试单元（在 Java 中通常是一个类或一个方法）进行检查和验证

为什么要写单元测试？

快速反馈：改完代码秒知对错，不用等启动整个项目或手动点浏览器。
防止回滚：当你重构（修改）旧代码时，单元测试能确保你没有改坏原本正常的功能。
文档作用：好的测试代码本身就是最好的“功能说明书”。

[!NOTE]

测试代码与应用程序代码分开,便于维护

可以自动生成测试报告(通过:绿色，失败:红色)

一个测试方法执行失败，不会影响其它测试方法

JUnit

测试类要求

维度	要求标准	说明
存放路径	`src/test/java`	必须与业务代码（`src/main/java`）分开存放。
包名结构	与被测类包名一致	例如被测类在 `com.demo.service`，测试类也应在此包下。
类名规范	以 `Test` 结尾	例如：`UserServiceTest.java`（Surefire 插件默认识别规则）。
依赖配置	`scope` 设为 `test`	确保测试相关的 Jar 包（如 JUnit）不会被打包到生产环境。

断言`assert`

本质：测试逻辑的“裁判”。它对比 预期值 (Expected) 与 实际值 (Actual)
逻辑流：执行业务逻辑 -> 获取结果 -> 调用断言方法 -> 判定测试通过/失败

	@Test 
	public void testGenderWithAssert(){ 
	 UserService userService = new UserService(); 
	 String gender = userService.getGenderByIdCard("100000200010011011"); 
	 Assertions.assertEquals("男", gender,"性别获取逻辑有问题");
	 //会检测与结果是否一致
	}

[!PROBLEM] 测试代码中，通常会极力避免手动写 try-catch

断言方法	说明	适用场景
`assertEquals(exp, act)`	判断两个值是否相等	验证计算结果、字符串内容、对象相等。
`assertNotEquals(exp, act)`	判断两个值是否不相等	验证更新后的值确实变了。
`assertTrue(condition)`	判断条件是否为 `true`	验证布尔逻辑（如：`canAfford` 方法）。
`assertFalse(condition)`	判断条件是否为 `false`	验证否定逻辑（如：用户是否未登录）。
`assertNull(obj)`	判断对象是否为空	验证查询不到数据时的返回。
`assertNotNull(obj)`	判断对象是否不为空	验证对象是否成功创建或查询到。
`assertArrayEquals(exp, act)`	判断两个数组是否相等	验证列表排序或批量处理后的数组。

	@Test 
	public void testGenderWithAssert2(){ 
	 UserService userService = new UserService(); 
	 String gender = userService.getGenderByIdCard("100000200010011011"); 
	 
		//当异常发生的时候 测试能否抛出正确的异常
	 Assertions.assertThrows(IllegalArgumentException.class,()-> 
	 userService.getGenderByIdCard(null)); 
	}

组合断言

当一个测试方法里有多个断言时：

普通逻辑：第一个断言挂了，后面都不跑了。
assertAll 逻辑：所有断言都会跑完，最后统一输出哪些挂了。

	// 笔记示例：
	assertAll("用户信息校验",
	 () -> assertEquals("男", gender),
	 () -> assertEquals(36, age)
	);

注解`Annotation`

生命周期钩子

注解	执行时机	强制要求	典型用途
`@BeforeAll`	所有测试开始前，只执行一次	必须是 `static` 方法	初始化数据库连接池、启动 Redis 容器。
`@BeforeEach`	每个测试方法执行前都跑一次	普通方法	重置对象状态、准备 Mock 数据。
`@AfterEach`	每个测试方法执行后都跑一次	普通方法	清理临时文件、撤销数据库更改。
`@AfterAll`	所有测试结束后，只执行一次	必须是 `static` 方法	关闭数据库连接、释放系统资源。

执行顺序逻辑： @BeforeAll $\rightarrow$ (@BeforeEach $\rightarrow$ @Test $\rightarrow$ @AfterEach) $\times$ N次 $\rightarrow$ @AfterAll

	before All
	before each
	after each
	before each
	男
	after each
	before each
	26
	after each
	before each
	after each
	after All
	
	进程已结束，退出代码为 0

核心测试与显示

@Test：最基础的标签，告诉 Maven 这是一个标准的单元测试。
@DisplayName("描述内容")：
- 作用：在 IDEA 的运行面板或测试报告中，显示中文或易读的描述，而不是枯燥的方法名。
- 复用性：让非技术人员（或一个月后的你）一眼看懂这个测试在测什么

参数化测试

@ParameterizedTest

作用：声明这个方法是一个“参数化测试”，它会多次运行，每次注入不同的值。
逻辑：它必须配合“数据源”注解使用。

@ValueSource

作用：最简单的数据源，提供一组基本类型的值（如 Strings, Ints）
身份证性别测试：

 @ParameterizedTest
 @ValueSource(strings = 
 				{"100000200010011021",
 				"100000200010011032",
 				"100000200010011051"
 			})
 @DisplayName("验证多个男性身份证的识别")
 public void testGenderWithAssert2(String idCard){//strings传入idCard
 UserService userService = new UserService(); 
 String gender = userService.getGenderByIdCard(idCard); 
 Assertions.assertEquals("男",gender); 
 }

总结

注解分类	注解名称	记忆关键词
控制流	`@Before...` / `@After...`	时机控制（前置/后置）
基础	`@Test`	入场券（标记测试）
美化	`@DisplayName`	别名（中文描述）
高级	`@ParameterizedTest`	分身术（一法多测）
数据源	`@ValueSource`	数据池（提供参数）

[!WARNING]

静态限制：记住 @BeforeAll 和 @AfterAll 必须加 static 关键字，因为它们在类实例创建之前就要运行。

依赖冲突：如果你在 pom.xml 里用的是 JUnit 4，这些注解（来自 org.junit.jupiter 包）是无法识别的。

不要混用：通常一个方法要么标 @Test，要么标 @ParameterizedTest，不要两个都标。

规范

在企业开发规范中，这种写法被称为 “测试环境准备（Test Fixture Setup）”

	private UserService userService; 
	@BeforeEach 
	public void setUp(){ 
	 userService = new UserService(); 
	}

依赖范围

范围 (Scope)	编译 (main)	测试 (test)	运行 (runtime)	打包	典型例子
`compile` (默认)	✅	✅	✅	✅	Spring 核心库、Log4j
`test`	❌	✅	❌	❌	JUnit 5、Mockito
`provided`	✅	✅	❌	❌	Servlet API、Lombok
`runtime`	❌	✅	✅	✅	JDBC 驱动实现
`system`	✅	✅	✅	✅	本地磁盘上的 Jar 包，迁移报错

详细范围

compile（编译范围）

逻辑：如果不写 <scope>，默认就是这个。
特性：全能型。你在写代码、跑测试、部署上线时都需要它。
复用性：它具有传递性（如果你依赖 A，A 依赖 B，那么你的项目也会获得 B）。

🔹 test（测试范围）

逻辑：只在 src/test/java 下的代码中有效。
为什么要用：像 JUnit 这种工具，上线运行代码时根本不需要。
规范：必须给所有测试框架加上 test 范围，防止线上包由于包含测试类而变得臃肿。

🔹 provided（已提供范围）

逻辑：编译时我需要它，但打包时请不要带上它。
典型场景：
- Servlet API：你的代码需要它来编译，但你最终要把项目部署到 Tomcat。Tomcat 已经自带了 Servlet 的 Jar 包，如果你的包里也带一个，就会产生版本冲突。
- Lombok：编译时生成 Getter/Setter，编译完后就不再需要了。

🔹 runtime（运行时范围）

逻辑：写代码（编译）时不需要，但程序跑起来（运行）时必须有。
典型场景：数据库驱动（如 MySQL Connector）。
- 我们在代码里通常使用 JDK 自带的 java.sql.Connection（接口），不需要直接调用 MySQL 的具体实现类。只有在程序运行时，Maven 才会加载驱动包来建立真实连接。

BOM

BOM 的全称是 Bill of Materials（物料清单）

简单来说，BOM 是一个特殊的 pom.xml 文件，它的核心逻辑不是为了提供代码，而是为了统一管理依赖的版本号

使用BOM

在 pom.xml 中导入 BOM

<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>3.2.0</version>
 <type>pom</type>
 <scope>import</scope> </dependency>
 </dependencies>
</dependencyManagement>

引入具体依赖（不写版本号）

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>

维度	传统方式	使用 BOM
版本控制	每个模块各自维护，易冲突	全局统一，一处修改全线更新
配置量	每个 `<dependency>` 都要写版本	只在顶层写一次，子模块极简
复用性	差，需要反复确认版本号	极强，确保所有组件完美兼容
稳定性	容易出现 Jar 包版本不匹配	官方认证的“全家桶”组合，最稳定

Vue3 & Ajax.md

Thu, 09 Apr 2026 00:00:00 +0000

本文更新于 2026-04-09

Vue

Vue.js 是一个用于构建用户界面的 JavaScript 框架。它最核心的价值在于：不再需要手动操作 DOM。

框架：就是一套完整的项目解决方案，用于快速构建项目
优点：大大提升前端项目的开发效率
引入Vue模块

	<div id="app">{{ message }}</div>
	
	<script type="module">
	 import { createApp, ref } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
	
	 createApp({
	 setup() {
	 const message = ref('Hello Vue!')
	 return {
	 message
	 }
	 }
	 }).mount('#app')
	</script>

指令

基础显示指令

指令	作用	说明
`v-text`	更新元素的文本内容	类似 `innerText`，但通常直接用 `{{ }}` 更方便。
`v-html`	更新元素的 `innerHTML`	内容按 HTML 解析。注意：只在信任的内容上使用，防止 XSS 攻击。
`v-once`	只渲染一次	之后即使数据变了，这里也不会更新，用于性能优化。

条件渲染指令

v-if / v-else-if / v-else：真正的条件渲染。如果条件为假，元素根本不会被创建（不出现在 DOM 树中）
- 原理:基于条件判断，来控制创建或移除元素节点(条件渲染)
- 场景:要么显示，要么不显示，不频繁切换的场景
v-show：通过修改 CSS 的 display: none 来切换显隐。元素始终存在于 DOM 中
- 原理:基于CSS样式display来控制显示与隐藏
- 场景:频繁切换显示隐藏的场景

场景建议：频繁切换显示用 v-show，运行时条件不大可能改变用 v-if

列表渲染指令

v-for：基于一个数组来渲染一个列表
语法：v-for="(item, index) in list" :key="item.id"
- item：当前遍历项
- index：当前索引（从 0 开始）
- list：要循环的数组
- :key="item.id"：给列表项唯一标识，提升渲染性能

	<tbody>
 <tr v-for="(e, index) in empList" :key="e.id">
 <td>{{index+1}}</td>
 <td>{{e.name}}</td>
 <td>{{e.gender == 1?"男":"女" }}</td>
 <td>{{e.job}}</td>
 <td>{{e.entrydate}}</td>
 <td>{{e.updatetime}}</td>
 </tr>
 </tbody>
 
 
	empList: [
	 { "id": 1,
		"name": "姓名",
		"gender": 1,
		"job": "1",
		"entrydate": "2023-06-09",
		"updatetime": "2024-07-30T14:59:38"
	 }

[!NOTE]

关键点：使用 v-for 时必须绑定 :key。这能帮助 Vue 的 Diff 算法精准识别每个节点，提高更新性能

注意：遍历的数组，必须在data中定义;要想让哪个标签循环展示多次，就在哪个标签上使用 v-for 指令。

属性绑定与事件监听

v-bind (缩写 :)：动态绑定 HTML 属性。

	<img v-bind:src="imageSrc">
	<img :src="imageSrc">
	插值表达式不能在标签内使用

v-on (缩写 @)：绑定事件监听器。
- 完整写法：v-on:事件名="方法名"
- 简写形式（最常用）：@事件名="方法名"

	//HTML
	<button type="button" @click="search">查询</button>
    <button type="reset" @click="clear">清空</button>

	//JS
	methods:{
			search(){
				console.log(this.searchForm);
			},
			clear(){
				this.searchForm.name = '';
				this.searchForm.gender = '';
				this.searchForm.job = '';
			}
		}

双向绑定指令(表单)

v-model：在表单元素（input, select, textarea）上创建双向数据绑定。
原理：它是 v-bind:value 和 v-on:input 的语法糖
- 从数据到视图：当变量值改变时，输入框的内容自动变
- 从视图到数据：当用户在输入框打字时，变量的值实时更新

	<select name="gender" v-model="searchForm.gender">
		...
	</select>
	
	<select name="job" v-model="searchForm.job">
		...
	</select>
	
	searchForm:{
				name:'',
				gender:'',
				job:''
                },

Ajax

Ajax (Asynchronous JavaScript and XML) 是让网页实现“局部刷新”的核心技术。它允许网页在不重新加载整个页面的情况下，从服务器请求数据。

XML: (Extensible Markup Language)可扩展标记语言，本质是一种数据格式，可以用来存储复杂的数据结构。

作用
- 数据交换: 通过Ajax可以给服务器发送请求，并获取服务器响应的数据。
- 异步交互: 可以在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页的技术，如:搜索联想、用户名是否可用的校验等等。

同步异步

同步

浏览器页面在发送请求给服务器，在服务器处理请求的过程中，浏览器页面不能做其他的操作。只能等到服务器响应结束后才能，浏览器页面才能继续做其他的操作

异步

浏览器页面发送请求给服务器，在服务器处理请求的过程中，浏览器页面还可以做其他的操作。

async & await

可以通过async、await可以让异步变为同步操作。async就是来声明一个异步方法，await是用来等待异步任务执行


 async search() {
 //基于axios发送异步请求，请求http://127.0.0.1:5500/json/simple.json，根据条件查询员工列表
 const result = await axios.get(`http://127.0.0.1:5500/json/simple.json?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`);
 
 this.empList = result.data.data;
 },

Axios

步骤
- 引入Axios的js文件
- 使用Axios发送请求，并获取响应结果
为了方便，Axios已经为所有支持的请求方法提供了别名
格式：axios.请求方式(url [,data [, config ]])

	//GET请求
    document.querySelector('#getData').onclick = function() {
    
        //发出请求后 不会等待服务器返回（异步），而是继续执行后续代码
	axios.get('https://jsonplaceholder.typicode.com/posts/1').then((result) => {
	 console.log(result.data);
	}).catch((err) => {
		console.log(err);
	});
	
	console.log('================================');//先输出
	
	}

Vue 的生命周期

阶段	状态名 (Vue 2)	Vue 3 (组合式 API)	状态描述
创建	`beforeCreate`	`setup`	实例初始化，无数据
	`created`	`setup`	数据可用，无 DOM
挂载	`beforeMount`	`onBeforeMount`	虚拟 DOM 已准备好
	`mounted`	`onMounted`	DOM 已渲染（最常用）
更新	`beforeUpdate`	`onBeforeUpdate`	数据变了，页面没变
	`updated`	`onUpdated`	页面更新完成
销毁	`beforeDestroy`	`onBeforeUnmount`	清理现场（防内存泄漏）
	`destroyed`	`onUnmounted`	完全消失

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script type="module">
 // 导入 Vue 3 的 createApp 方法
 import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
 createApp({
 data() {
 return {
 // 搜索表单绑定的数据
 searchForm: {
 name: '', // 姓名
 gender: '', // 性别
 job: '' // 职位
 },
 // 员工列表，表格渲染的数据
 empList: []
 }
 },
 methods: {
 // 查询方法，点击“查询”按钮或页面加载时调用
 search() {
 // 发送 GET 请求到远程接口，带上表单参数
 axios.get(`https://web-server.itheima.net/emps/list?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`)
 .then((result) => {
 // 将返回的员工数组赋值给 empList，页面自动渲染
 this.empList = result.data.data;
 })
 // 控制台输出分隔线，调试用
 console.log('================================');
 },
 /*
 result.data：是整个响应体（包含 code、msg、data 等字段）
 result.data.data：才是真正需要的员工数组
 */
 // 清空方法，点击“清空”按钮时调用
 clear() {
 // 重置表单
 this.searchForm = {
 name: '',
 gender: '',
 job: ''
 };
 // 重新查询，显示所有数据
 this.search();
 }
 },
 // 生命周期钩子，页面加载完成后自动查询一次，显示所有数据
 mounted() {
 this.search();
 }
 }).mount('#container')
</script>

HTML

Tue, 07 Apr 2026 00:00:00 +0000

本文更新于 2026-04-07

HTML

HyperText Markup Language

HTML 不是一种编程语言，而是一种标记语言（Markup Language）。它通过一系列“标签”来描述网页的结构，是构建 Web 页面的基石。

HTML 核心标签

HTML 是网页的骨架，用于定义页面内容。

标题标签 (<h1> - <h6>)：用于定义 1 到 6 级标题，数字越小级别越高，字体越大。
超链接标签 (<a>)：
- href 属性：指定资源访问的 URL 地址。
- target 属性：指定打开链接的位置。
  - _self：在当前页面打开（默认）。
  - _blank：在新的空白页面打开。

表单

表单容器 `<form>`

所有表单控件必须放在 <form> 标签内，它负责定义数据提交的方向和方式。

action: 服务器接收数据的 URL 地址。
method:
- GET: 数据跟在 URL 后面，适合搜索、查询（安全性低，有长度限制）。
- POST: 数据放在请求体中，适合注册、上传文件（安全性高，无长度限制）。

	form表单：
	action：表单数据提交的url地址
	method：提交方式
	 get：默认，表单数据会出现在url后面，形式：/save?name=Tom&age=18
	 特点：
	 1．如果表单中包含了隐私数据，get方式并不安全，不推荐使用该方式．
	 2．在浏览器中get请求的大小是有限制的，不适合提交大数据量的表单．
	 post：表单数据会在消息体/请求体中提交到服务器
	 特点：
	 1．安全．
	 2．请求大小没有限制
	注意：表单项要想能够采集数据，必须得设置name属性，表示当前表单项的名字

表单项

<label> 标签 (点击文字也能选中)

极力推荐使用。它能通过 for 属性绑定到对应的 input 的 id 上。

好处：点击“用户名”这三个字，光标也会跳进输入框，对移动端非常友好。

name 属性 (后端唯一标识)

这是表单项最核心的属性。后端程序只认 name。

💡 比喻：name 是变量名，用户输入的是变量值。没写 name，后端就收不到这个项的数据。

value 属性 (初始值/提交值)

对于文本框：它是默认填好的文字。
对于单选/复选框：它是选中后传给后端的“暗号”。

`<input>`

常用 Type	视觉效果	适用场景
`text`	单行输入框	用户名、地址
`password`	掩盖输入内容	密码、敏感信息
`radio`	圆形选择点	单选（必须设置相同 `name` 才能互斥）
`checkbox`	方形勾选框	多选（如爱好、协议确认）
`file`	文件选择按钮	上传头像、文档
`submit`	提交按钮	确认并发送整个表单

`<select> & <option>`

用于在有限的空间里提供大量选项。

	<select name="city">
	 <option value="bj">北京</option>
	 <option value="sh">上海</option>
	</select>

`<textarea>`

用于输入大量文字（如自我介绍、评价），支持换行。

表格

HTML 表格是由行（Row）组成的，行里面再拆分单元格（Cell）。

<table>: 表格的容器。
<tr> (Table Row): 定义一行。
<th> (Table Header): 表头单元格。文字默认加粗、居中。
<td> (Table Data): 普通单元格。承载具体内容。为了让长表格更易读、更符合标准，建议使用以下标签：

标签	作用
`<thead>`	包裹表头部分（通常是第一行）。
`<tbody>`	包裹表格主体（数据部分）。
`<tfoot>`	包裹表格页脚（如合计行）。
`<caption>`	表格的标题，紧跟在 `<table>` 之后。

单元格合并

这是表格布局中最常用的技巧，用于处理复杂的表头或跨行数据。

colspan (跨列)：将多个单元格水平合并。
rowspan (跨行)：将多个单元格垂直合并。

页脚

维度	`<footer>` (页面页脚)	`<tfoot>` (表格页脚)
所属父级	`<body>` 或 `<article>`	`<table>`
主要功能	放置版权、导航、作者信息	放置表格数据的合计、平均值
出现频率	一个页面通常只有一个主 `<footer>`	每个表格可以有一个 `<tfoot>`
布局技巧	常配合 CSS 固定在页面底部	常配合 `colspan` 合并单元格

CSS

Cascading Style Sheets

CSS 负责网页的表现（Presentation）。如果说 HTML 是建筑的骨架，那么 CSS 就是装修、油漆和家具布局。它通过选择器定位 HTML 元素，并应用样式属性。

CSS 引入方式

CSS 用于美化 HTML 页面，主要有三种引入手段：

行内样式 (Inline Styles)：直接写在标签的 style 属性中，优先级最高但不易维护。
内部样式表 (Internal Style Sheet)：写在 <head> 标签内的 <style> 标签中，适用于单页样式。
外部样式表 (External Style Sheet)：推荐做法。通过 <link rel="stylesheet" href="路径.css"> 引入独立的 .css 文件，实现结构与表现分离。

颜色表示

十六进制颜色值

这是目前网页开发中最常用的表达方式

格式：#RRGGBB（前缀为 #，后面跟着三组十六进制数）。
原理：使用十六进制（0-9, A-F）分别定义红 (Red)、绿 (Green)、蓝 (Blue) 三原色的强度。
示例：
- #FFFFFF：纯白色。
- #000000：纯黑色。

RGB 与 RGBA 模式

直接通过数字定义三原色的混合比例，更符合计算机颜色的底层逻辑。

RGB 格式：rgb(红色值, 绿色值, 蓝色值)。每个数值范围是 0-255。
- 示例：rgb(231, 76, 60) 等同于十六进制的 #e74c3c。
RGBA 格式：rgba(r, g, b, alpha)。多了一个 alpha 通道用于控制透明度。
- alpha 取值范围是 0（完全透明）到 1（完全不透明）。
- 示例：rgba(52, 152, 219, 0.5) 表示 50% 透明度的蓝色。

选择器

基本选择器

这是最常用、最基础的选择方法。

标签选择器 (1)：通过 HTML 标签名选择。
- 写法：p { color: red; }（选中页面上所有的 <p> 标签）。
类选择器 (10)：选择具有特定 class 属性的元素。
- 写法：.highlight { background: yellow; }（选中所有 class="highlight" 的元素）。
ID 选择器 (100)：选择具有特定 id 属性的唯一元素。
- 写法：#header { font-size: 24px; }（选中 id="header" 的元素）。注意：一个 ID 在 HTML 页面中应该是唯一的。
通配符选择器 (0)：选择页面上的所有元素。
- 写法：* { margin: 0; padding: 0; }（常用于重置页面默认边距）。

复合选择器

用于更精确地定位元素。

后代选择器 (Descendant Selector)：选择某个元素内部的所有指定后代。
- 写法：.container p { ... }（选中 .container 内部所有的 <p> 标签，无论嵌套多深）。
子元素选择器 (Child Selector)：仅选择某个元素的直接子元素。
- 写法：.container > p { ... }（只选中 .container 下的第一层 <p>）。
并集选择器 (Grouping Selector)：同时给多个选择器设置相同的样式。
- 写法：h1, h2, .title { ... }（用逗号分隔）。

伪类选择器

用于选择元素的特定状态，常用于交互效果。

:hover：鼠标悬停在元素上的状态。
- 写法：a:hover { text-decoration: underline; }（鼠标移上去显示下划线）。
:active：元素被激活（鼠标点击按下）的状态。
:nth-child(n)：选择父元素中的第 n 个子元素。
- 写法：li:nth-child(2) { color: blue; }（选中列表中的第二项）。

属性选择器

根据 HTML 标签的属性来选择，这在处理你之前提到的 contest.xml 这种结构化数据转换成的 HTML 时非常有用。

写法：[type="text"] { border: 1px solid #ccc; }（选中所有 type 属性为 text 的输入框）。

选择器的优先级

当多个选择器指向同一个元素并设置相同属性时，浏览器会根据“权重”来决定听谁的：

行内样式 (style="...")：权重最高 (1000)
ID 选择器 (#id)：权重高 (100)
类、伪类、属性选择器 (.class)：权重中 (10)
标签选择器 (div, p)：权重低 (1)
通配符 (*)：权重最低 (0)

原则：描述得越精准，权重越高。如果权重相同，则后写的样式会覆盖先写的样式。

正文样式

属性	功能说明	常见取值示例
`color`	设置字体颜色	`#e74c3c` (十六进制), `rgba(0,0,0,0.8)`
`font-size`	设置字体大小	`16px`, `1rem`, `1.2em`
`line-height`	设置行高（行间距）	`1.5`, `1.6` (通常为字号的倍数)
`letter-spacing`	设置字间距	`1px`, `2px`
`text-indent`	首行缩进	`2em` (缩进两个字符)
`text-align`	文本对齐方式	`left`, `center`, `right`, `justify`

盒子模型

在 CSS 中，所有的 HTML 元素都可以看作是一个矩形的“盒子”。这个盒子由内到外由四个部分（区域）组成。

内容 (Content)：盒子的核心，显示文本、图片等实际内容。
内边距 (Padding)：内容与边框之间的透明区域。
边框 (Border)：围绕在内边距和内容外的线。
外边距 (Margin)：边框外的区域，用于控制元素与其它元素之间的距离。

通过 box-sizing 属性切换计算逻辑，这是最容易出错的地方：

标准盒子模型 (`content-box`)

特性：width 只等于 Content。
总宽度公式：Width + Padding*2 + Border*2。
结果：加了边框或内边距，盒子会被“撑大”。

怪异盒子模型 (`border-box`)

特性：width 等于 Content + Padding + Border。
总宽度公式：等于你设置的 Width。
结果：加了边框或内边距，内容区会“向内压缩”，盒子总尺寸不变。

布局

布局标签

1.<div> 标签 (Division) —— 块级容器

<div> 是 “division”（部分、分区）的缩写，用于定义文档中的一个区块。

显示特性：块级元素 (Block-level)。
- 默认情况下，它会独占一行（宽度默认铺满父容器 100%）。
- 它可以设置宽度 (width)、高度 (height)、内边距 (padding) 和外边距 (margin)。
常用场景：
- 划分页面的大区域（如：页眉、导航栏、内容区、页脚）。
- 作为 CSS 布局（如 Flex 或 Grid）的父容器。
示例：

	<div class="team-card">
	<h2>Alpha Team</h2>
	<p>积分：1500</p>
	</div>

2. <span> 标签 —— 行内容器

<span> 用于组合文档中的行内元素，以便通过 CSS 修改局部样式。

显示特性：行内元素 (Inline)。
- 它不会换行，只会占据内容所需的宽度，与其他文本排在同一行。
- 默认情况下，设置宽高属性无效。
常用场景：
- 修改一段文字中某个词的颜色、字号或字体。
- 在一行内放置小图标或状态标签。
示例：

	<p>队伍 T001 的状态是 <span style="color: green;">AC</span></p>

特性	`<div>`	`<span>`
元素类型	块级元素 (Block)	行内元素 (Inline)
占用空间	独占一行，默认宽度 100%	随内容变化，不换行
嵌套规则	可以包含其它 `div` 或 `span`	只能包含文本或其它行内元素
布局用途	构建网页骨架、容器	局部修饰、修饰行内小部件

flex布局

flex是flexible Box的缩写，意为"弹性布局"，是一种一维的布局模型。flex布局可以为元素之间提供强大的空间分布和对齐能力。
通过给父容器添加flex的相关属性,来控制子元素的位置和排列方式，

理解 Flex 的关键在于明白它有两个轴：

主轴 (Main Axis)：默认是水平方向（从左到右）。
交叉轴 (Cross Axis)：默认是垂直方向（从上到下）。

可以通过 flex-direction 来交换这两个轴。

属性	作用	常用取值
`justify-content`	控制子元素在主轴（横向）上的对齐	`center`, `space-between`, `flex-end`
`align-items`	控制子元素在交叉轴（纵向）上的对齐	`center`, `flex-start`, `stretch`
`flex`	控制子元素如何分配剩余空间	`1` (平分), `2` (占两份)

flex布局相关的CSS样式

属性	说明	取值	含义
`display`	模式	`flex`	使用 flex 布局
`flex-direction`	设置主轴	`row`	主轴方向为 x 轴，水平向右（默认）
		`column`	主轴方向为 y 轴，垂直向下
`justify-content`	子元素在主轴上的对齐方式	`flex-start`	从头开始排列
		`flex-end`	从尾部开始排列
		`center`	在主轴居中对齐
		`space-around`	平分剩余空间
		`space-between`	先两边贴边，再平分剩余空间

HTML & CSS总览

JavaScript

组成

1. ECMAScript (核心语法)

这是 JavaScript 的大脑，定义了语言的基础规则。它不涉及浏览器，只规定语法。

包含内容：变量声明 (var, let, const)、数据类型、流程控制 (if/else, for)、函数、类 (Class)、对象等。
标准制定者：由 ECMA 国际组织负责更新（如 ES6, ES2023）。
通俗理解：就像汉语的语法字典，规定了怎么造句，但不规定这些句子是在书里还是在墙上。

2. DOM (文档对象模型)

DOM (Document Object Model) 是 JavaScript 操作网页内容的手脚。

功能：将 HTML 页面抽象为一棵“树”。JS 通过 DOM 接口可以增、删、改、查网页上的任何标签、属性和样式。
常见操作：
- document.getElementById()
- 修改文字内容 (innerText)
- 修改 CSS 样式 (style.display = 'none')
通俗理解：把 HTML 页面看作一间屋子，DOM 就是家具的控制面板，让你能随时换个沙发或者关上灯。

3. BOM (浏览器对象模型)

BOM (Browser Object Model) 是 JavaScript 与浏览器软件本身对话的窗口。

功能：提供与浏览器窗口交互的对象，不涉及页面内部的具体内容。
包含内容：
- window: 顶层对象（所有 JS 全局变量都在这里）。
- location: 获取或设置当前页面的 URL。
- navigation: 获取浏览器信息（版本、系统等）。
- history: 操作浏览器的前进和后退。
- screen: 获取屏幕分辨率。
通俗理解：它是浏览器的外壳控制，比如弹出一个警告框 (alert) 或开启一个新的标签页。

引入方式

行内引入

直接将 JS 代码写在 HTML 标签的事件属性中（如 onclick）

	<button onclick="alert('你点击了按钮！')">点击我</button>

优点：简单、快速，用于极少量的交互。
缺点：代码与 HTML 耦合度过高，极难维护，不推荐使用

内部引入

将代码写在 HTML 文档的 <script> 标签内。通常放在 </body> 标签之前。

代码示例：

	<body>
		<h1>标题</h1>
		<script>
			const title = document.querySelector('h1');
			console.log(title.innerText);
		</script>
	</body>

优点：不需要额外创建文件，适合单个页面的简短脚本。
缺点：如果脚本过长，会使 HTML 文件变得臃肿，无法在多个页面间复用代码。

外部引入–推荐

将 JS 代码写在独立的 .js 文件中，通过 <script> 标签的 src 属性引入。

HTML 部分：

<script src="js/main.js"></script>

JS 部分 (main.js)：

alert("这是来自外部文件的代码");

优点：
1. 代码复用：多个网页可以引用同一个 JS 文件。
2. 结构清晰：HTML 只负责结构，JS 负责逻辑，各司其职。
3. 缓存优化：浏览器会缓存外部 JS 文件，提高页面加载速度。

基础语法

1. 变量声明 (Variables)

在现代 JS 中，我们使用 let 和 const 来代替过时的 var。

const: 声明常量。一旦赋值，不能修改。优先使用。
let: 声明变量。值可以被重新覆盖。

const pi = 3.14; // 不可变
let score = 10; // 可变
score = 20; // 允许

2. 数据类型 (Data Types)

JS 的数据分为“简单”和“复杂”两类。

分类	数据类型	英文	说明 & 示例
基本类型	数字	`number`	数字（10, 3.14）
	字符串	`string`	字符串`("Hello", 'Hi')`
	布尔	`boolean`	布尔（true, false）
	空值	`null`	空值,`null != Null != NULL`
	未定义	`undefined`	该变量未初始化
引用类型	对象	`object`	对象，用 {} 表示，存储键值对
	数组	`array`	数组，用 [] 表示，存储有序列表

使用typeof运算符可以获取数据类型 typeof a -> number 避免使用 var，否则变量可能在声明前被访问而导致 undefined

[!WARNING] 注意

由字母、数字、下划线 _、美元符 $ 组成

不能以数字开头

严格区分大小写

不能是 JavaScript 关键字或保留字

建议见名知意，语义清晰

推荐使用小驼峰命名法，第一个单词小写，后面单词首字母大写

模板字符串

三种功能

变量嵌入通过 ${} 语法，可以直接在字符串中插入变量或表达式，不再需要用大量的 + 号

	const name = "Gemini";
	const version = 3.0;
	
	// 旧版写法
	console.log("你好，我是 " + name + "，当前版本是 " + version);
	
	// 模板字符串写法
	console.log(`你好，我是 ${name}，当前版本是 ${version}`);

多行字符串在传统字符串中，换行需要使用 \n。而在模板字符串中，可以直接按回车键换行

	// 自动保留换行格式
	const htmlTemplate = `
	 <div>
	 <h1>标题</h1>
	 <p>内容段落</p>
	 </div>
	`;

嵌入表达式 ${} 内部不仅可以放变量，还可以进行运算、调用函数或逻辑判断。

	const price = 100;
	const tax = 0.1;
	
	console.log(`总价是：${price * (1 + tax)} 元`); // 运算
	console.log(`状态：${price > 50 ? '昂贵' : '便宜'}`); // 三元运算

[!tip] 如果在模板字符串中需要显示反引号本身，请使用转义符：` \` `

如果在模板字符串中需要显示 ${} 原样字符，也需要转义：\${}

函数

在 JavaScript 中，函数（Function） 是执行特定任务的可重复调用的代码块。它是程序中最基本的“逻辑单元”。

函数声明 (Function Declaration)

最传统、最常用的方式。具有“声明提升”特性（可以在声明前调用）。

	function greet(name) {
		return `你好, ${name}!`;
	}
	console.log(greet("张三")); // 调用

匿名函数

匿名函数（Anonymous Function） 是指在定义时没有函数名称的函数。在 JavaScript 中，它们通常作为“工具人”使用，在需要的地方临时定义并立即执行或传递。

函数表达式 (Function Expression)

将函数赋值给一个变量。没有提升特性。

	const add = function(a, b) {
	 return a + b;
	};

箭头函数 (Arrow Function) —— 现代主流

ES6 引入的简洁写法。注意：它没有自己的 this，适合用作回调函数。

const multiply = (a, b) => a * b;

[!NOTE] 由于匿名函数没有名字，在复杂的报错调试（Debug）时，错误堆栈里可能只显示 anonymous，找起 Bug 来会比具名函数稍微麻烦一点。

自定义对象

在 JavaScript 中，自定义对象（Custom Objects） 是将相关数据（属性）和行为（方法）组织在一起的容器。它是 JS 模拟现实世界实体（如：用户、商品、订单）的核心方式。

	let 对象名 = {
		属性名1:属性值1;
		属性名2:属性值2;
		属性名3:属性值3;
		方法名:function(形参列表){}
	}
	
	// 调用格式
	对象名.属性名;
	对象名.方法名;

字面量方式（常用）

直接用大括号 {} 定义，适合创建一个独立、唯一的对象

	const phone = {
	 brand: "华为",
	 model: "Mate 60",
	 price: 5999,
	 // 方法：对象中的函数
	 call: function() {//不推荐使用箭头函数
		 console.log("正在拨打电话...");
	 }
	};

构造函数

当需要批量创建多个结构相似的对象时（如 100 个学生），使用构造函数约定：函数名首字母大写

	function Student(name, age) {
	 this.name = name;
	 this.age = age;
	 this.study = function() {
	 console.log(`${this.name} 正在学习`);
	 };
	}
	
	const s1 = new Student("小明", 18);
	const s2 = new Student("小红", 19);

类

ES6 引入的语法糖，逻辑更清晰，接近 Java/C# 的风格

	class Car {
	 constructor(color, speed) {
	 this.color = color;
	 this.speed = speed;
	 }
	 drive() {
	 console.log(`这辆${this.color}的车正在以${this.speed}码行驶`);
	 }
	}
	
	const myCar = new Car("白色", 120);

JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式

它基于 JavaScript 的一个子集，但它是独立于语言的文本格式，目前几乎所有的编程语言（Python, Java, PHP, Go 等）都支持 JSON

语法规则

JSON 的结构非常简单，主要由键值对组成。

数据在键值对中：键（Key）必须用双引号包裹。
数据由逗号分隔。
对象由大括号 {} 保存。
数组由方括号 [] 保存。

数据类型

类型	示例
字符串	`"Hello World"` (必须双引号)
数字	`123`, `45.6`
布尔值	`true`, `false`
数组	`["Apple", "Orange"]`
对象	`{"id": 1, "name": "Gemini"}`
空值	`null`

⚠️ 注意：JSON 不能包含函数、日期对象或 undefined

JavaScript 中的 JSON 操作

	// JSON.parse() 当从服务器收到一段 JSON 字符串时，需要用它将其解析为 JS 对象。
	const jsonStr = '{"name": "小明", "age": 18}';
	const obj = JSON.parse(jsonStr);
	console.log(obj.name); // 输出: 小明
	
	
	// JSON.stringify() 当准备把数据发送给服务器时，需要将 JS 对象转换为 JSON 字符串。
	const user = { name: "小明", age: 18 };
	const jsonString = JSON.stringify(user);
	console.log(jsonString); // 输出: '{"name":"小明","age":18}'

DOM

DOM (Document Object Model)，即文档对象模型，是 JavaScript 操作网页内容的“桥梁” 它将 HTML 文档表现为一个树状结构，让我们可以通过脚本动态地修改页面的内容、结构和样式。

DOM操作

根据CSS选择器获取DOM对象

document.querySelector('选择器')
- 作用：返回匹配到的第一个对象。
- 示例：document.querySelector('.my-class') 或 document.querySelector('#my-id p')。
document.querySelectorAll('选择器')
- 作用：返回匹配到的所有对象。
- 结果：一个 NodeList（类似数组的集合，可以用 forEach 遍历）
- 注意:得到的是一个NodeList节点集合，是一个伪数组(有长度、有索引的数组)

方法	获取依据	返回值类型	说明
`getElementById('id')`	唯一 ID	单个对象	速度最快，只能找 ID
`getElementsByClassName('class')`	类名	动态集合 (HTMLCollection)	实时更新的集合
`getElementsByTagName('标签名')`	标签名	动态集合 (HTMLCollection)	比如找所有的 `div`

事件监听

三要素

可以把事件监听想象成一个报警系统：

事件源 (Target)：谁触发了事件？（比如：一个 <button> 按钮）
- 事件源.addEventListener('事件类型',事件触发执行的函数);可以多次绑定同一事件
- 早期版本写法:事件源.on事件=function{}如果多次绑定同一事件，就会覆盖
事件类型 (Type)：发生了什么事？（比如：click 点击）
事件处理程序 (Handler)：要做什么？（通常是一个回调函数）

分类	事件名	触发时机
鼠标事件	`click`	鼠标点击
	`mouseenter` / `mouseleave`	鼠标移入 / 移出
键盘事件	`keydown` / `keyup`	按键按下 / 松开
表单事件	`input`	输入内容改变时（实时）
	`change`	内容改变并失去焦点时
	`submit`	表单提交时
窗口事件	`load`	整个页面加载完成
	`scroll`	页面滚动

JS优化

基础

Tue, 07 Apr 2026 00:00:00 +0000

本文更新于 2026-04-09

HTTP

HTTP 是互联网上应用最为广泛的一种网络协议。它定义了浏览器（客户端）与服务器之间交换数据的格式和规则

HTTP 的基本特性

应用层协议：运行在 TCP/IP 协议栈之上（默认端口 80，HTTPS 为 443）。
请求-响应模型：必须由客户端发起请求，服务器给出响应。
无状态 (Stateless)：协议本身不保留之前的事务记忆。
- 对策：在开发中通过 Cookie/Session 或 JWT (Token) 来维持登录状态。
灵活：允许传输任意类型的数据对象，通过 Content-Type 加以标记。

HTTP 请求报文结构

一个标准的 HTTP 请求由四部分组成：

请求行 (Request Line)： Method + URL + Version (如 GET /index.html HTTP/1.1)
请求头 (Request Headers)：键值对格式，描述客户端环境和偏好。
- Host: 目标主机。
- User-Agent: 浏览器标识。
- Accept: 客户端可接受的内容类型。
空行：必须存在，用于分隔头部和正文。
请求体 (Request Body)：仅 POST/PUT 等方法使用，存放要提交的数据（如 JSON）。

HTTP 响应报文与状态码

响应报文同样由 状态行、响应头、空行、响应体 组成。

核心状态码分类：

2xx (成功)：200 OK (请求成功)。
3xx (重定向)：301 (永久重定向)、302 (临时重定向)。
4xx (客户端错误)：
- 400 Bad Request: 请求语法错误。
- 403 Forbidden: 服务器拒绝执行。
- 404 Not Found: 资源不存在。
- 405 Method Not Allowed: 方法不支持（如用 GET 访问 POST 接口）。
5xx (服务器错误)：
- 500 Internal Server Error: 后端代码抛出未处理的异常。
- 502 Bad Gateway: 网关从后端收到了非法响应（如 Nginx 找不到 Java 服务）。
- 504 Gateway Timeout: 后端处理超时。

长链接与短链接

HTTP	应用层协议
TCP	传输层协议
ip	网络层协议

特性	短连接 (Short Connection)	长连接 (Keep-Alive)
底层表现	一次请求/响应消耗一个 TCP 连接	多次请求/响应复用一个 TCP 连接
HTTP 版本	HTTP/1.0 默认	HTTP/1.1 默认
HTTP Header	`Connection: close`	`Connection: keep-alive`
握手开销	高（每次请求都要三次握手）	低（仅首次建立需要）
服务器压力	CPU 压力较大（频繁建立/销毁连接）	内存压力较大（需维持空闲连接的 socket）
适用场景	偶尔交互的单次请求、请求频率极低的服务	Web 页面浏览、前后端高频 API 交互、图片服务器

InnoDB引擎

Sun, 05 Apr 2026 00:00:00 +0000

本文更新于 2026-04-05

InnoDB 是 MySQL 的默认事务型引擎，也是目前最常用、最强大的存储引擎。它被设计用来处理大量的短期事务，具有高性能和高可用性。

核心特性

InnoDB 的强大源于其四大核心支柱：

事务支持 (ACID)：
- 支持事务的原子性、一致性、隔离性和持久性。通过 Redo Log（重做日志）保证持久性，通过 Undo Log（回滚日志）保证原子性。
行级锁 (Row-level Locking)：
- 不同于 MyISAM 的表级锁，InnoDB 支持行锁，极大提高了多用户并发操作的性能。
外键约束 (Foreign Key)：
- 它是 MySQL 中唯一支持外键的内置存储引擎，能够维护数据的参照完整性。
MVCC (多版本并发控制)：
- 通过 Read View 和 Undo Log 实现非阻塞读。在“可重复读”隔离级别下，读操作不会加锁，从而提升了并发查询效率。

逻辑存储结构

InnoDB 将所有数据逻辑地存放在一个名为 Tablespace（表空间）的地方，其结构从大到小依次为：

表空间 (Tablespace)：包含系统表空间（ibdata1）或独立表空间（.ibd）。
段 (Segment)：分为数据段（Leaf node segment）、索引段（Non-leaf node segment）等。
区 (Extent)：固定大小为 1MB，由 64 个连续的页组成。
页 (Page)：InnoDB 磁盘管理的最小单位，默认大小为 16KB。
行 (Row)：InnoDB存储引擎数据是按行进行存放的

MySQL InnoDB 架构

InnoDB 存储引擎的架构设计主要分为两个部分： 内存结构 (In-Memory Structures) 和 磁盘结构 (On-Disk Structures)。这种设计旨在平衡高性能（内存操作）与数据持久性（磁盘存储）。

内存结构 (In-Memory Structures)

内存池是 InnoDB 性能的核心，其主要组件包括：

Buffer Pool (缓冲池)：
- 核心作用：缓存磁盘上的真实数据页和索引页。
  - 机制：读取数据时，若缓冲池有则直接返回；修改数据时，先修改缓冲池中的页（变为“脏页”），再通过 Checkpoint 机制异步刷入磁盘。
Change Buffer (写缓冲区)：
- 针对非唯一辅助索引的优化。当插入或更新辅助索引且该页不在缓冲池时，先记录在 Change Buffer 中，等未来读取该页时再进行合并。
Adaptive Hash Index (自适应哈希索引)：
- InnoDB 会监控表上的索引查询，如果观察到某些索引值被频繁访问，会自动建立哈希索引以加速查询（将 B+ 树查询变为 O(1) 查找）
Log Buffer (日志缓冲区)：
- 用于保存准备写入磁盘的 Redo Log 数据。默认大小为 16MB，定期刷入磁盘以保证事务的持久性。
- 意义： 即使内存里的数据还没来得及写回磁盘就断电了，重启后也能通过磁盘上的 Redo Log 把数据恢复回来。

磁盘结构 (On-Disk Structures)

磁盘结构确保了数据的物理存储和崩溃恢复能力：

Tablespaces (表空间)：
- System Tablespace (系统表空间)：存储 InnoDB 数据字典、双写缓冲区等。
- File-Per-Table Tablespaces (独立表空间)：每个表对应一个 .ibd 文件，存储该表的数据和索引
- 创建表空间&撤销表空间&临时表空间
Doublewrite Buffer (双写缓冲区)：
- 位于系统表空间的物理存储区。在将页写入数据文件前，先写入此处。用于防止在写入过程中发生断电导致的“页破碎”问题。
Redo Log (重做日志)：
- 记录对页的物理修改。当数据库宕机重启，会根据 Redo Log 将未落盘的脏页恢复。
Undo Logs (回滚日志)：
- 逻辑日志，记录事务变更前的样子。用于事务回滚和 MVCC（实现非阻塞读）。

核心后台线程

InnoDB 依靠多个后台线程来维持运行：

Master Thread：负责将缓冲池数据异步刷新到磁盘，保持数据一致性。
IO Thread：主要负责 AIO（异步IO）请求的回调处理（分为 Read, Write, Log, Insert Buffer 线程）。
Purge Thread：事务提交后，负责回收已经不再需要的 Undo Log 页。
Page Cleaner Thread：专门负责脏页的刷新工作，减轻 Master Thread 的负担。

架构设计的精髓：WAL (Write-Ahead Logging)

InnoDB 遵循 日志先行策略：

当数据发生变更时，先修改内存（Buffer Pool），并同步记录 Redo Log 到磁盘。
只要 Redo Log 落地，即使此时内存中的“脏页”还没来得及刷入磁盘，数据库发生崩溃也能通过日志恢复。
这种将“随机写磁盘”转变为“顺序写日志”的设计，是 InnoDB 高性能读写的基石。

事务原理

事务（Transaction）是逻辑上的一组操作，要么全部成功，要么全部失败。在 InnoDB 引擎中，事务的四大特性（ACID）是通过不同的技术手段共同保障的。

持久性 (Durability) — Redo Log

定义：一旦事务提交，它对数据库的改变就是永久性的，即使系统崩溃也不会丢失。

实现原理：Redo Log（重做日志） 与 WAL（Write-Ahead Logging）。
工作机制：
1. 当数据修改时，InnoDB 先修改 Buffer Pool 中的内存页。
2. 同时将修改操作记录到 Redo Log Buffer。
3. 事务提交时，根据策略将 Redo Log 顺序写入磁盘文件。
Crash Recovery：如果数据库宕机，虽然内存里的脏页丢了，但重启后系统会读取磁盘上的 Redo Log，把未落盘的修改“重做”一遍。

原子性 (Atomicity) — Undo Log

定义：事务是不可分割的最小单位，要么全部完成，要么全部不完成。

实现原理：Undo Log（回滚日志）。
工作机制：当事务对数据库进行修改时，InnoDB 会生成对应的 Undo Log。
- 如果你执行的是 INSERT，日志会记录一条对应的 DELETE。
- 如果你执行的是 UPDATE，日志会记录修改前的数据。
结果：如果事务执行失败或调用了 ROLLBACK，系统会利用 Undo Log 中的逻辑记录将数据恢复到事务开始前的样子。

一致性 (Consistency)

定义：事务执行前后，数据库的完整性约束没有被破坏，数据从一个一致性状态转移到另一个一致性状态。

实现原理：一致性是事务追求的最终目标。
手段：它由原子性、隔离性和持久性共同维系，同时也依赖于数据库的完整性约束（如外键、唯一索引、非空限制）以及应用层的逻辑正确性。

隔离性 (Isolation) — MVCC & 锁

定义：多个并发事务之间相互隔离，互不干扰。

实现原理：锁机制 与 MVCC（多版本并发控制）。
工作机制：
- 锁：处理“写-写”冲突，确保同一时间只有一个事务能修改同一行数据。
- MVCC：处理“读-写”冲突。通过在每行记录后面保存隐藏列（事务ID、回滚指针）并结合 Read View，让事务能读取到符合自己隔离级别的数据快照，实现非阻塞读。

总结：ACID 实现脑图

特性	实现技术	核心作用
原子性 (A)	Undo Log	逻辑回滚，确保要么都做，要么都不做。
隔离性 (I)	MVCC + 锁	并发控制，确保事务执行不被干扰。
持久性 (D)	Redo Log	崩溃恢复，确保提交的数据不丢失。
一致性 (C)	上述三者 + 代码逻辑	最终目的，确保数据逻辑正确。

核心提示：对于 Java 开发来说，理解 Redo Log（保证不丢数据）和 Undo Log（保证能回滚）的区别是面试和调优的关键。

MVCC

MVCC 全称 多版本并发控制 (Multi-Version Concurrency Control)，是 InnoDB 实现隔离级别（读已提交 RC 和可重复读 RR）的核心技术。它的核心思想是：通过保存数据的历史版本，实现“读-写”操作的非阻塞。

快照读 (Snapshot Read)： 普通的 SELECT 语句（不加锁）。它读的是记录的“某个版本”，可能是历史数据。
当前读 (Current Read)： INSERT、UPDATE、DELETE 或 SELECT ... FOR UPDATE。它必须读取记录的“最新版本”，并且要加锁。

MVCC 解决的就是“快照读”的问题。

隐式字段

InnoDB 在每行记录后面都会自动加上三个隐藏列：

DB_TRX_ID：最近修改该记录的事务 ID。
DB_ROLL_PTR：回滚指针，指向该记录的上一个版本（在 Undo Log 中）。
DB_ROW_ID：如果表没有主键，InnoDB 会自动生成一个自增 ID（有主键则无此列）。

作用

实现回滚 (Rollback)：当你执行 ROLLBACK 时，系统通过 DB_ROLL_PTR 找到旧数据，直接覆盖回来。
实现 MVCC（读写不冲突）：当事务 A 在改数据（加了排他锁），事务 B 来读。B 会根据自己的 Read View 和记录上的 DB_TRX_ID 判断：
- “这个版本是 A 正在改的，我不能看。”于是 B 顺着 DB_ROLL_PTR 去读 Undo Log 里的旧版本。
- 结果：事务 A 慢慢改，事务 B 照样读，互不干扰。

undo log版本链

每当一个事务修改数据时，旧版本的数据会被写入 Undo Log 中。通过 DB_ROLL_PTR，不同事务对同一行记录的修改会形成一个由旧到新的链表。

[ 当前聚簇索引记录 (最新行) ]
┌─────────────────────────────────────┐
│ 业务字段：name = '王五' │
│ 隐藏字段 DB_TRX_ID = 30 │
│ 隐藏字段 DB_ROLL_PTR = 指针地址 A │
└───────────────┬─────────────────────┘
 │
 ▼ 指针指向 Undo Log
 ┌─────────────────────────────┐
 │ 【Undo Log 版本1】A │
 │ 数据：name = '李四' │
 │ 事务ID：TRX_ID = 20 │
 │ 回滚指针：指针地址 B │
 └───────────────┬─────────────┘
 │
 ▼ 继续指向上一版本
 ┌─────────────────────┐
 │ 【Undo Log 版本2】B │
 │ 数据：name = '张三' │
 │ 事务ID：TRX_ID = 10 │
 │ 回滚指针：NULL │
 └─────────────────────┘
 │
 ▼
 【链表结束】

read view(一致性视图)

ReadView(读视图)是 快照读 SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务(未提交的)id。它包含四个核心字段：

m_ids：当前活跃（未提交）的事务 ID 列表。
min_trx_id：活跃事务中的最小值。
max_trx_id：预分配给下一个事务的 ID 值，当前最大失误ID+1（事物的ID是自增的）
creator_trx_id：创建该 Read View 的事务 ID。

版本可见性算法 (核心逻辑)

当一个事务读取某行记录时，它会拿着该行的 DB_TRX_ID 去和自己的 Read View 进行比对：

trx_id == creator_trx_id：该版本是我自己改的，可见。
trx_id < min_trx_id：该版本在 Read View 创建前已提交，可见。
trx_id >= max_trx_id：该版本在 Read View 创建后才开启，不可见。
min_trx_id <= trx_id < max_trx_id：
- 若 trx_id 在 m_ids 列表中：说明事务还没提交，不可见。
- 若 trx_id 不在 m_ids 列表中：说明事务已提交，可见。

如果不可见怎么办？ 顺着 DB_ROLL_PTR 回滚指针去找 Undo Log 里的上一个版本，直到找到可见的版本为止。

MVCC 在 RC 和 RR 级别下的唯一区别在于 生成 Read View 的时机：

读已提交 (RC)：
- 每次执行 SELECT 语句时 都会重新生成一个新的 Read View。
- 结果：可以看到其他事务期间提交的数据（不可重复读）。

属性	含义	第一个 ReadView	第二个 ReadView
m_ids	当前活跃事务 ID 列表（正在运行的事务）	`{3, 4, 5}`	`{4, 5}`
min_trx_id	m_ids 中的最小值	3	4
max_trx_id	生成 ReadView 时，系统分配的下一个事务 ID	6	6
creator_trx_id	生成该视图的事务 ID（当前事务 ID）	5	5

可重复读 (RR)：
- 仅在事务第一次执行 SELECT 时 生成一个 Read View，后续所有查询共用这一个。
- 结果：整个事务期间看到的数据始终一致（解决了不可重复读，并在很大程度上解决了幻读）。

属性	值	含义
`m_ids`	`{3, 4, 5}`	生成 ReadView 时，系统中所有活跃（未提交）事务 ID的集合
`min_trx_id`	`3`	`m_ids` 中的最小值
`max_trx_id`	`6`	生成 ReadView 时，系统即将分配的下一个事务 ID（比当前所有活跃 ID 都大）
`creator_trx_id`	`5`	生成这个 ReadView 的事务 ID（也就是事务 5 自己）

MySQL管理

系统数据库

数据库名	角色	常用操作
mysql	管理员	修改用户密码、配置 SSL 证书、调整权限。
information_schema	开发者	检查表结构、查找大表、确认字段长度。
performance_schema	DBA / 性能专家	深度分析 CPU 尖峰、定位锁等待根源。
sys	运维/开发者	快速查看慢查询 Top 10、分析未使用的索引。

常用工具

mysql客户端工具

mysqlbinlog二进制日志查看工具

mysqlshow查看数据库、表、字段的统计信息

mysqldump数据备份工具

mysqlimport/source数据导入工具

JDBC & Mybatis

Sun, 05 Apr 2026 00:00:00 +0000

本文更新于 2026-04-05

API

DriverManager 驱动管理类

注册驱动：让 DriverManager 知道当前有哪些可用的数据库驱动（如 MySQL, Oracle, PostgreSQL）。
建立连接：根据传入的 URL、用户名和密码，找到匹配的驱动并返回一个 Connection 对象。

	"jdbc:mysql://127.0.0.1:3306/school_db?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8"

//127.0.0.1:3306/：指定数据库服务器的地址和监听端口（默认 3306）。
school_db：要连接的具体数据库模式（Schema）名称。
useSSL=false：关闭 SSL 加密连接（开发环境下常用，减少性能开销）。
serverTimezone=UTC：指定服务器时区。若不设置，在某些 MySQL 版本中可能会抛出时区错误。
characterEncoding=UTF-8：强制使用 UTF-8 编码，防止中文乱码。

	// 1. 注册驱动 (JDBC 4.0 以后这一步可以省略)
	Class.forName("com.mysql.cj.jdbc.Driver"); 
	
	// 2. 通过 DriverManager 获取连接
	String url = "jdbc:mysql://localhost:3306/test_db";
	Connection conn = DriverManager.getConnection(url, "root", "password");

Connection

Connection 接口是 JDBC API 的核心，代表与特定数据库的物理会话（Session）。所有的 SQL 语句都在此连接的上下文中执行。

核心方法

方法	功能描述
`createStatement()`	创建一个基本的 `Statement` 对象，用于执行静态 SQL。
`prepareStatement(String sql)`	创建一个预编译的语句对象，支持参数化查询（防注入）。
`setAutoCommit(boolean)`	设置是否自动提交事务。默认为 `true`。
`commit()` / `rollback()`	手动提交或回滚当前事务中的所有更改。
`close()`	释放该连接占用的数据库和 JDBC 资源。
`isClosed()`	检查连接是否已关闭或失效。

JDBC的事务处理

	Connection conn = null;
	try {
	 conn = DriverManager.getConnection(url, user, pass);
	 // 1. 关闭自动提交，开启事务
	 conn.setAutoCommit(false);
	
	 // 2. 执行 SQL A (扣钱)
	 // 3. 执行 SQL B (加钱)
	
	 // 4. 业务全部成功，手动提交
	 conn.commit();
	} catch (Exception e) {
	 // 5. 一旦出异常，全部回滚
	 if (conn != null) {
	 try {
	 conn.rollback();
	 } catch (SQLException ex) {
	 ex.printStackTrace();
	 }
	 }
	} finally {
	 // 6. 记得关闭连接
	 if (conn != null) conn.close();
	}

Statement

Statement 是 JDBC 中最基础的执行对象，用于执行静态 SQL 语句。

	// 1. 通过连接创建一个邮差
	Statement stmt = conn.createStatement();
	
	// 2. 让邮差去送信（执行 SQL）
	String sql = "UPDATE user SET name = '张三' WHERE id = 1";
	int rows = stmt.executeUpdate(sql); // 返回受影响的行数
	
	// 3. 如果是查询，会带回一个结果集
	ResultSet rs = stmt.executeQuery("SELECT * FROM user");

特性	executeUpdate()	executeQuery()
SQL 类型	`INSERT, UPDATE, DELETE, DDL`	`SELECT`
返回类型	`int` (行数)	`ResultSet` (数据集合)
典型场景	转账、注册、修改密码、删帖	查余额、搜商品、看个人资料
为空时	返回 `0`	返回一个空的 `ResultSet`（`rs.next()` 为 false）

Resultset 结果集对象

ResultSet（结果集）是 JDBC 中用于存储和操作数据库查询结果的对象。它类似于一张虚拟的临时表，维持着一个指向当前数据行的光标（Cursor）

工作原理：光标机制 (The Cursor)

当你执行 executeQuery() 后，返回的 ResultSet 对象初始状态下，光标指向第一行数据的上方（即“Before First”位置）

next() 方法：将光标下移一行。
返回值：如果下一行有数据，返回 true；如果已经到达末尾，返回 false。
常用遍历模式：

 while (rs.next()) {
 // 处理当前行的数据
 rs.getXxx(参数);
 }

获取数据的方法 (Getter Methods)

ResultSet 提供了丰富的 getXXX 方法来获取不同类型的数据，通常支持两种定位方式：

获取方式	示例	优缺点
通过列索引	`rs.getString(1)`	性能略高，但代码可读性差，且依赖 SQL 字段顺序。
通过列标签	`rs.getInt("user_id")`	推荐方式。可读性强，不依赖 SQL 字段顺序。

常用类型映射：

getString() -> String (VARCHAR, TEXT)
getInt() -> int (INT)
getDouble() -> double (DOUBLE, DECIMAL)
getTimestamp() -> java.sql.Timestamp (DATETIME)
getObject() -> 通用类型，通常用于处理动态查询。

[!NOTE] 注意 JDBC 的列索引是从 1 开始的（1-based），而 Java 数组和集合是从 0 开始的（0-based）。如果在循环里混用了，会导致 SQLException: Column Index out of range

	Connection conn = DriverManager.getConnection(url,username,password); 
	
	String sql = "SELECT * FROM users"; 
	try (conn; Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(sql)) { 
	 while (rs.next()){ 
	 String user = rs.getString("username"); 
	 String passwd = rs.getString("password"); 
	 String date = rs.getString("created_at"); 
	 System.out.println(user + " " + passwd + " " + date); 
	 } 
	}

PreparedStatement 预编译语句对象

PreparedStatement 继承自 Statement 接口，是 JDBC 中最常用的 SQL 执行对象。它代表一条预编译的 SQL 语句，能够有效提高性能并彻底杜绝 SQL 注入风险

优势

相比于普通的 Statement，PreparedStatement 具有三大核心优势：

防止 SQL 注入：通过参数化查询，将 SQL 逻辑与数据分离，使恶意代码无法改变 SQL 结构。
性能优化：数据库会对预编译后的 SQL 进行缓存（执行计划）。后续执行相同结构的 SQL（仅参数不同）时，无需重新解析。
代码可读性：使用占位符 ? 代替繁琐的字符串拼接，代码更加整洁。

使用步骤

使用 PreparedStatement 遵循以下固定流程：

编写带占位符的 SQL：使用 ? 作为参数位置。
预编译 SQL：通过 Connection 对象获取 PreparedStatement 实例。
设置参数：调用 setXXX() 方法为每个 ? 赋值（注意：索引从 1 开始）。
执行 SQL：调用 executeQuery() 或 executeUpdate()（注意：执行时不需要再传入 SQL 字符串）。

代码示例：

	String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
	try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
	 // 1. 设置参数（索引从 1 开始）
	 pstmt.setString(1, "admin");
	 pstmt.setString(2, "123456");
	 
	 // 2. 执行查询
	 try (ResultSet rs = pstmt.executeQuery()) {
	 while (rs.next()) {
	 // 处理结果
	 }
	 }
	}

常用API

方法	功能描述
`setObject(int, Object)`	最通用的赋值方法，自动映射 Java 类型到数据库类型。
`setInt / setString / ...`	强类型赋值，确保数据类型安全。
`setNull(int, int)`	为数据库字段设置 NULL 值。
`addBatch()`	将当前参数组加入批处理队列。
`clearParameters()`	清除当前设置的所有参数，以便重用该对象。

`*`批处理

	String sql = "INSERT INTO students (name, score) VALUES (?, ?)";
	try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
	 for (Student s : studentList) {
	 pstmt.setString(1, s.getName());
	 pstmt.setInt(2, s.getScore());
	 pstmt.addBatch(); // 添加到批处理
	 }
	 pstmt.executeBatch(); // 一次性发送所有数据
	}

[!WARNING] 注意 SQL语句中的占位符只能给值/参数使用，不能给表名使用

原理

PreparedStatement 不仅仅是 Statement 的子接口，它在数据库层面引入了预编译（Prepare机制。

防注入原理：语义定型

这是 PreparedStatement 最核心的安全特性。

逻辑固定：在预编译阶段，SQL 的逻辑结构（如 SELECT...WHERE...AND）已经确定并被数据库理解。
字面量处理：随后传入的任何参数，无论包含什么特殊字符（如 ' OR '1'='1），都会被数据库引擎强制视为一个整体的字符串常量，而不会被当作 SQL 指令的一部分。
类型检查：setXXX 方法在 Java 端就进行了类型校验，不符合类型的参数无法通过编译。

数据库连接池

数据库连接池是程序启动时自动建立的一定数量的数据库连接，并将这些连接维持在一个“池”中。当应用程序需要访问数据库时，直接从池中借用，使用完毕后归还给池。

数据库连接池是个容器，负责分配、管理数据库连接 (Connection)。
它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。
释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏。

优势：

资源重用
提升系统响应速度
避免数据库连接遗漏

为什么走连接池？

在不使用连接池的情况下，每次数据库操作都遵循“六步走”：

加载驱动 (消耗 CPU)
建立物理连接 (涉及 TCP 三次握手，最耗时，通常需 0.1s - 0.5s)
身份验证 (安全开销)
执行 SQL
结果返回
销毁连接 (TCP 四次挥手)

弊端：在高并发场景下，频繁创建/销毁连接会产生巨大的网络负载，甚至导致数据库因连接数过多而宕机

主流连接池对比

HikariCP 追光者(推荐)：
- 特点：目前性能最强的连接池，字节码精简，速度极快。
- 地位：Spring Boot 2.0+ 默认连接池。
Druid 德鲁伊(阿里巴巴)：
- 特点：功能最全面，自带 SQL 监控、防御 SQL 注入、统计信息等。
- 地位：国内 Java 开发者的首选，利于排查慢 SQL。
C3P0 / DBCP：
- 特点：较老，配置繁琐，性能在现代高并发环境下略显不足。

核心参数配置

在使用连接池（如 Druid 或 HikariCP）时，这些参数直接决定了系统的吞吐量：

参数名称	描述	建议
initialSize	初始连接数	建议与 `minIdle` 一致。
maxActive	最大活跃连接数	根据数据库承载能力设置（如 50-100）。
maxWait	获取连接的最大等待时间	设置过长会导致前端请求挂起，建议 2000ms 左右。
minIdle	最小空闲连接数	始终保持在池中的“保底”连接。
validationQuery	验证连接是否有效的 SQL	MySQL 常用 `SELECT 1`。

	// 1. 加载配置文件
	Properties props = new Properties();
	props.load(new FileInputStream("druid.properties"));
	
	// 2. 获取数据源 (DataSource)
	DataSource ds = DruidDataSourceFactory.createDataSource(props);
	
	// 3. 从池中获取连接
	try (Connection conn = ds.getConnection()) {
	 // 这里的 close() 只是把连接归还给池
	 System.out.println("获取到连接：" + conn);
	}

MyBatis

`#{}`：预编译占位符（最常用、最安全）

这是 MyBatis 的默认推荐方式。

底层原理：它是基于 JDBC 的 PreparedStatement 实现的。MyBatis 会先将 SQL 语句中的 #{} 替换为 ?，发送给数据库进行预编译，然后再将参数值设置进去。
特点：
- 安全性高：自动处理 SQL 注入风险。
- 自动转义：如果传入的是字符串，它会自动加上单引号 ' '。
示例：

-- 输入参数 name = "Zhang"
SELECT * FROM user WHERE username = #{name}
-- 解析后的 SQL：SELECT * FROM user WHERE username = ?
-- 执行时：SELECT * FROM user WHERE username = 'Zhang'

特性	#{}	${}
处理方式	预编译 (PreparedStatement)	字符串替换 (Statement)
场景	参数值传递	表名、字段名动态设置时使用
安全性	高，防止 SQL 注入	低，有 SQL 注入风险
性能	高（预编译可重用执行计划）	低（每次都需要重新解析 SQL）
自动加引号	是	否
这些场景通常是 “参数不是作为值，而是作为 SQL 的语法组成部分” 时：

动态表名：SELECT * FROM ${tableName}
动态列名：SELECT ${columnName} FROM user
动态排序：ORDER BY ${orderColumn} ${sortType}（比如让用户点击表头按不同字段排序）

问：“为什么 `#{}` 能防止 SQL 注入，而 `${}` 不能？”

回答： “因为 #{} 采用了 JDBC 的 预编译 (PreparedStatement) 机制。在这种机制下，SQL 的结构在参数传入前就已经确定并发送给数据库解析了。参数被视为单纯的‘值’，即使参数里包含 OR 1=1 这样的指令，也只会被当作一段普通的文本处理，不会改变 SQL 的逻辑语义。而 ${} 只是简单的 字符串拼接，参数会直接参与 SQL 语句的解析和编译，从而可能改变 SQL 的执行意图，导致注入风险。”

增删改查

插入INSERT

Mapper接口：

	@Insert("INSERT INTO user(username,password,name,age) VALUES(#{username},#{password},#{name},#{age})") 
	public void insert(User user);//插入用户信息
	
Spring测试：

	@Test 
	public void testInsert(){ 
 User user = new User(null,"jjj","666888","鸡鸡鸡",18); 
 userMapper.insert(user);//调用UserMapper接口中的insert方法，插入用户信息 
	}

删除DELETE

Mapper接口：

	@Delete("DELETE FROM user WHERE id = #{id}") 
	public void deleteById(Integer id);
	
Spring测试：

	@Autowired 
	private UserMapper userMapper;//注入UserMapper接口的代理对象
	@Test 
	public void testDeleteById(){ 
	 userMapper.deleteById(5); 
	}

修改UPDATE

Mapper接口：

	@Update("UPDATE user set username = #{username},password = #{password},name = #{name},age = #{age} WHERE id = #{id}") 
	public void update(User user);
	
Spring测试：

	public void testUpdate(){ 
 User user = new User(1,"zhouyu","8989","周瑜",19); 
 userMapper.update(user);//调用UserMapper接口中的update方法，更新用户信息 
	}

查询SELECT

	@Select("SELECT * FROM user WHERE username = #{username} AND password = #{password}") 
	public User findByUsernameAndPassword( 
 @Param("username")String username, 
 @Param("password") String password);

❗说明: 基于官方骨架创建的springboot项目中，接口编译时会保留方法形参名，@Param注解可以省略(#{形参名})

@Param内部原理图解

调用接口：调用 findByUsernameAndPassword("Zhang", "123")。
封装 Map：MyBatis 内部会将这些参数封装成一个 Map。
- 没有 @Param：Map 为 {arg0: "Zhang", arg1: "123"}。
- 有 @Param：Map 为 {username: "Zhang", password: "123"}。
SQL 填充：执行时，MyBatis 从 Map 中根据 Key（即 username）取出 Value

问：“MyBatis 的 `@Param` 注解有什么用？”

回答： “@Param 主要用于多参数传递的场景。由于 Java 字节码在编译后可能会丢失方法参数名，导致 MyBatis 无法将 SQL 中的占位符与方法参数对应。通过 @Param 注解，我们可以显式地为参数命名，MyBatis 会将这些参数封装进一个 Map 中，从而在解析 SQL 语句时能够准确地通过 Key 找到对应的 Value。这增强了代码的可读性，并避免了多参数环境下参数找不到的异常。”

XML映射配置

基本组成结构

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.mapper.UserMapper">

 <select id="findById" resultType="com.example.pojo.User">
 SELECT * FROM user WHERE id = #{id}
 </select>

</mapper>

核心对应关系

为了让 Spring 容器能通过接口找到对应的 SQL，必须严格遵守以下约定：

名称空间一致：XML映射文件的 namespace 属性必须是接口的全路径名。
ID与方法名一致：XML映射文件中 SQL 标签的 id 属性必须与接口中的方法名完全一致。
包名类名一致： XML映射文件的名称与Mapper接口名称一致，并且将XML映射文件和Mapper放在相同包下（同包同名）
参数/结果一致：parameterType（通常可省略）和 resultType 要与接口的入参和出参对应

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE mapper 
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="org.example.mapper.UserMapper"> 
 
 <select id="findAll" resultType="org.example.pojo.User"> #往User封装 
 SELECT id,username,password,name,age FROM user 
 </select> 
</mapper>
相当于Mapper中的：@Select("SELECT id,username,password,name,age FROM user")

场景	推荐方式	原因
简单的根据 ID 查询、删除	注解	快速、省事，不用在文件间跳来跳去。
复杂的关联查询（Join）	XML	注解难以处理复杂的 `resultMap` 嵌套映射。
动态搜索、批量插入	XML	动态标签（`<if>`, `<foreach>`）是 XML 的杀手锏。
SQL 语句经常需要优化	XML	修改 SQL 时不影响 Java 逻辑，更易于维护。

辅助配置

	# 指定XML映射文件的位置 
	mybatis.mapper-locations=classpath:mapper/*.xml

XML 中的 SQL

<mapper namespace="asia.creat.mapper.EmpMapper"> 
	<select id="listByCondition" resultType="asia.creat.pojo.Emp"> 
 SELECT *FROM emp e LEFT JOIN dept d ON e.dept_id = d.id WHERE e.name 
 LIKE CONCAT('%',#{name},'%') AND e.gender = #{gender} 
 AND e.entry_date BETWEEN #{begin} AND #{end} 
 ORDER BY e.update_time DESC 
	</select> 
</mapper>

动态SQL

MyBatis 提供了几个强大的逻辑标签：

`<if>`：条件判断

最常用的标签。如果 test 属性中的表达式为真，则拼接标签内的 SQL

<select id="find" resultType="Emp">
 SELECT * FROM emp WHERE 1=1
 <if test="name != null">
 AND name LIKE #{name}
 </if>
 <if test="gender != null">
 AND gender = #{gender}
 </if>
</select>

`<where>`：智能处理

上面的写法里我们被迫写了 WHERE 1=1，这很丑。<where> 标签能自动完成两件事：

如果子标签有内容，才插入 WHERE 关键字
自动剔除内容开头多余的 AND 或 OR

<select id="find" resultType="Emp">
 SELECT * FROM emp
 <where>
 <if test="name != null">AND name = #{name}</if>
 <if test="gender != null">AND gender = #{gender}</if>
 </where>
</select>

`<set>`：动态更新

用于 UPDATE 语句。它会自动插入 SET 关键字，并聪明地删掉最后一个多余的逗号

<update id="update">
 UPDATE emp
 <set>
 <if test="username != null">username = #{username},</if>
 <if test="password != null">password = #{password},</if>
 </set>
 WHERE id = #{id}
</update>

`<foreach>`：循环遍历

专门处理 IN 查询或批量插入。

collection：参数名（如 List 或数组）
item：遍历出的每一项变量名
separator：分隔符（如逗号）
open：遍历开始前拼接的片段
close：遍历结束后拼接的片段

<delete id="deleteByIds">
 DELETE FROM emp WHERE id IN
 <foreach collection="ids" item="id" open="(" close=")" separator=",">
 #{id}
 </foreach>
</delete>

工作原理

解析：MyBatis 在执行前扫描 XML 标签
判断：根据你传入的参数对象（比如 EmpQueryParam）的值，计算 test 里的表达式
渲染：只保留符合条件的片段，拼接成最终的“原生 SQL”交给数据库执行

使用提示

字符串判空：对于 String 类型，习惯上写成 <if test="name != null and name != ''">，同时检查 null 和空字符串
SQL 注入：始终使用 #{} 传参，它会自动进行预编译。除非是要动态传表名或排序列名（这种极少数情况才用 ${}）
XML 还是注解？：
- 简单的 SQL 可以写在注解 @Select 里
- 复杂的动态 SQL 强烈建议写在 XML 里，因为 XML 的结构化标签比在 Java 字符串里拼 SQL 舒服且清晰得多

SpringBoot配置文件

配置格式

SpringBoot项目提供了多种属性配置方式(properties、yaml、yml)

核心语法规则（避坑指南）

YAML 的语法非常严苛，这些错误尤其会导致 Spring Boot 启动失败：

大小写敏感：Name 和 name 是不同的。
使用缩进表示层级：禁止使用 Tab 键，必须使用空格（通常缩进 2 个空格）。
冒号后必须有空格：这是最容易忘的！key: value 冒号后面必须跟着一个空格。
“#” 表示注释：与 Java 里的 // 作用一样。

YAML 的数据格式

纯量（普通键值对）

server:
 port: 8080 # 注意冒号后的空格
 address: 127.0.0.1

对象（层级关系）

YAML 天然适合表达这种父子结构：

student:
 name: ZhangKun
 age: 20
 major: SoftwareEngineering

数组 / 集合

使用 短横线 - 表示列表中的一个项：

subjects:
 - Java
 - MyBatis
 - SpringBoot

[!WARNING] 在yml格式的配置文件中，如果配置项的值是以0开头的，值需要使用’ ‘引起来，因为以0开头在yml中表示8进制的数据。

如果 src/main/resources 下同时存在 application.properties 和 application.yml：

Spring 会同时加载两个文件。
如果有重复配置，.properties 的优先级更高（它会覆盖 .yml 的内容）。

建议：项目中统一只用一种格式，避免逻辑混乱。

进阶-SQL优化

Sat, 04 Apr 2026 00:00:00 +0000

本文更新于 2026-04-04

插入数据

普通 Insert 优化 (批量插入)

如果需要插入多条数据，不要每一条都执行一次 INSERT 语句。

错误做法：循环执行 1000 次 INSERT INTO user VALUES (...);
优化做法：使用批量插入（建议一次批量 500-1000 条）。

	INSERT INTO user VALUES (1,'Tom'), (2,'Jerry'), (3,'Rose');

原理：减少了客户端与数据库之间的网络连接开销，降低了 SQL 解析的次数。

事务优化 (手动提交事务)

MySQL 默认是自动提交（autocommit）的，这意味着每执行一次 INSERT，数据库就会进行一次磁盘同步（Disk Flush）。

优化做法：手动开启并提交事务。

	START TRANSACTION;
	INSERT INTO user VALUES (...);
	INSERT INTO user VALUES (...);
	-- 执行成百上千条后再统一提交
	COMMIT;

原理：将多次磁盘 I/O 操作合并为一次，极大提升写入性能。

主键顺序插入

在设计表结构时，主键的选择直接影响插入效率。

优化建议：尽量使用自增主键，保证主键顺序插入。
原因：InnoDB 使用 B+Tree 索引。如果主键乱序（如 UUID），会导致频繁的页分裂 (Page Split) 和记录移动，增加磁盘开销。顺序插入则只需在索引页末尾追加。

大批量数据加载 (load data local infile)

如果你有成百万条数据存在文本文件（如 CSV）中，使用 INSERT 语句会非常缓慢。此时应使用 MySQL 提供的 load 指令。

操作步骤：
1. 客户端连接时开启本地文件加载：mysql --local-infile -u root -p
2. 设置全局参数：set global local_infile = 1;
3. 执行加载语句：

	load data local infile '/root/sql_data.log' 
	into table `user` 
	fields terminated by ',' 
	lines terminated by '\n';

性能：这种方式直接绕过了部分 SQL 解析逻辑，比普通的 INSERT 快一个数量级。

主键优化

InnoDB 数据组织方式 (Index Organized Table)

在 InnoDB 存储引擎中，表数据都是根据主键顺序组织存放的。这种存储方式的表称为 索引组织表 (Index Organized Table, IOT)

核心特征：
- 行数据即索引：在 InnoDB 的聚集索引中，叶子节点直接存储了整行数据。
- 主键即路径：当你通过主键查询时，不需要额外的寻址，找到索引即找到了数据。
- 强制性：由于数据必须按序存放，如果表没有显式定义主键，InnoDB 会自动寻找或生成隐式主键来组织数据。

数据存储原理：页分裂 (Page Split)

InnoDB 的最小存储单元是 页 (Page)，默认大小为 16KB。页可以为空，也可以填充一半，也可以填充100%。每个页包含了2-N行数据(如果一行数据多大，会行溢出)，根据主键排列。

顺序插入：如果主键自增，数据会按顺序填满物理页。当一页满时，直接开辟新页继续写入，效率极高。
乱序插入 (如 UUID)：如果主键是随机的，新行可能需要插入到已经写满的页中间。此时，InnoDB 必须将该页拆分为两页，并移动部分数据，这被称为页分裂。
后果：页分裂会导致大量的磁盘 I/O，并产生物理碎片。

数据存储原理：页合并 (Page Merge)

当删除一行记录时，实际上记录并未从磁盘物理删除，只是被标记为“已删除”，其空间可以被覆盖利用。

合并逻辑：当一个页中被删除的记录达到一定比例（默认为 MERGE_THRESHOLD 50%），InnoDB 会尝试寻找相邻的页，看是否可以将两个页合并以优化空间。
后果：频繁的页合并和分裂会使索引树结构变得不稳定。

主键设计原则 (Best Practices)

尽量降低主键长度

二级索引（辅助索引）的叶子节点存储的是主键值。如果主键过长，会导致所有的二级索引都占用巨大的空间，增加磁盘 I/O 并降低内存命中率。

尽量选择自增主键 (AUTO_INCREMENT)

保证顺序插入，完全规避页分裂问题。
写入速度最快，索引树最紧凑。

避免使用 UUID 或其他随机字符串

原因：UUID 是随机无序的，插入时会引发频繁的页分裂；且 UUID 通常较长（36位），会增加二级索引的负担。
方案：如果业务需要全局唯一标识，建议使用雪花算法 (Snowflake) 生成的趋势递增整数。

业务逻辑不要作为主键

不要使用身份证号、手机号等具有业务意义的字段作为主键。
原因：业务逻辑可能发生变化（如身份证号升位），一旦主键修改，所有二级索引都要同步更新，代价极大。

ORDER BY 优化

MySQL 的排序实现方式主要有两种：

Using index：通过有序索引顺序扫描直接返回有序数据，不需要额外排序，效率最高。
Using filesort：通过表的索引或全表扫描读取数据，然后在排序缓冲区 sort_buffer 中进行排序。

排序优化的核心原则

如果要实现 Using index 提升性能，必须满足以下条件：

最左前缀法则：ORDER BY 的字段顺序必须符合联合索引的列顺序。
方向一致性：如果排序包含多个列，这些列的排序方向（升序 ASC / 降序 DESC）必须一致（MySQL 8.0 引入了降序索引，可部分解决此问题）
降序索引：

	-- 创建联合索引：age 升序，phone 降序
	CREATE INDEX idx_user_age_phone_desc ON user(age ASC, phone DESC);

覆盖索引：SELECT 的字段最好只包含索引列，否则可能因为回表开销过大，导致优化器放弃索引排序而选择 filesort。

场景	索引 idx(a, b) 是否生效	备注
`ORDER BY a`	是	符合最左前缀
`WHERE a = 1 ORDER BY b`	是	`a` 已固定，`b` 在索引内有序
`ORDER BY a, b`	是	顺序一致
`ORDER BY b`	否	违背最左前缀
`WHERE a > 10 ORDER BY b`	否	`a` 是范围查询，其后的 `b` 在全局上是无序的
`ORDER BY a ASC, b DESC`	否	排序方向不一致（MySQL 8.0 以下）

优化建议总结 (Best Practices)

根据排序字段建立索引：尤其是针对 WHERE 过滤后还需要 ORDER BY 的场景，建立联合索引。
遵循最左前缀：确保排序字段在索引中的位置正确。
只取必要的字段：避免 SELECT *，尽量使用覆盖索引。
统一排序方向：除非使用了 MySQL 8.0 的降序索引功能，否则尽量保证所有排序字段都是 ASC 或都是 DESC。
不可避免 filesort 时：对于大数据量排序，适当调大 sort_buffer_size 减少磁盘 I/O。

GROUP BY优化

MySQL 在执行 GROUP BY 时，主要有两种方式：

Using index：通过索引直接进行分组，效率最高
Using temporary; Using filesort：需要建立临时表并在内存或磁盘中排序，性能较差

核心优化原则：利用索引

由于分组操作通常涉及排序，因此 最左前缀法则 在 GROUP BY 中同样适用。

场景分析

联合索引：idx_user_pro_age (pro, age)

场景类型	SQL 语句	执行状态	说明
全匹配（索引生效）	`SELECT pro, count(*) FROM user GROUP BY pro, age;`	`Using index`	-
符合最左前缀（索引生效）	`SELECT pro, count(*) FROM user GROUP BY pro;`	`Using index`	-
不符合最左前缀（索引失效）	`SELECT age, count(*) FROM user GROUP BY age;`	`Using temporary; Using filesort`	-
结合 WHERE 使用（索引生效）	`SELECT age, count(*) FROM user WHERE pro = '软件工程' GROUP BY age;`	`Using index`	虽然 `GROUP BY` 跳过了第一列，但 `WHERE` 子句已经补齐了最左前缀。

LIMIT优化

性能瓶颈：深度分页问题

当执行 LIMIT 1000000, 10 时，MySQL 并不是直接跳过前 100 万行，而是：

全表扫描（或索引扫描）：读取前 1000010 条记录。
回表查询：如果查询的是 SELECT *，则需要回表 1000010 次获取行数据。
丢弃数据：抛弃前 100 万条，仅返回最后 10 条。

结论：偏移量（Offset）越大，磁盘 I/O 越高，查询越慢。

2. 优化方案：覆盖索引 + 子查询 (延迟关联)

这是最通用的优化方案。通过子查询先在索引树上定位主键 ID（不回表），再关联原表获取数据。

优化前（慢）：

SELECT * FROM user LIMIT 1000000, 10;

优化后（快）：

	SELECT * FROM user t, (
		SELECT id FROM user ORDER BY id LIMIT 1000000, 10
	)a 
	WHERE t.id = a.id;

原理：子查询 (SELECT id ...) 利用了覆盖索引，极大地减少了回表次数。

COUNT 优化

存储引擎的差异

MyISAM：把一个表的总行数存在了磁盘上，因此执行 count(*) 时会直接返回这个数，效率极高（前提是没有 WHERE 条件）。
InnoDB：由于多版本并发控制 (MVCC) 的原因，InnoDB 表“应该返回多少行”是不确定的。它必须把数据一行一行从引擎里面读出来，然后累计计数。
- 优化结论：在 InnoDB 中，count(*) 是需要全表扫描或索引扫描的。

COUNT 的几种用法对比

假设执行 SELECT COUNT(X) FROM table;，性能排序通常为： count(*) ≈ count(1) > count(主键ID) > count(字段)

用法	执行逻辑	性能评估
count(主键ID)	遍历整张表，取每行的 ID，返回给服务层，服务层判断不为 NULL 后累加。	较快，但涉及取值。
count(字段)	遍历整张表，取该字段值。有 NOT NULL 约束则直接累加；没有则需判断是否为 NULL。	最慢，涉及取值和判断。
count(1)	遍历整张表，但不取值。服务层对返回的每一行放入一个数字“1”，直接累加。	极快，不涉及取值。
*count()**	MySQL 专门优化过。不取值，直接按行累加。它会选择体积最小的二级索引树进行扫描。	推荐使用，性能最高。

UPDATE 优化

核心原理：行锁与表锁

InnoDB 存储引擎支持行级锁 (Row Lock)，这是它支持高并发的关键。但需要注意：

行锁是针对索引加的锁：不是针对记录加的锁。
索引失效则锁全表：如果 UPDATE 语句的 WHERE 条件没有使用索引，或者索引失效，InnoDB 会对全表所有记录加锁，实际上变成了表级锁。

	-- 有索引 -> 行锁
	UPDATE course SET name = 'SpringBoot' WHERE id = 3;
	-- 无索引 -> 表锁
	UPDATE course SET name = 'SpringBoot' WHERE name = 'JavaEE';

进阶-锁

Sat, 04 Apr 2026 00:00:00 +0000

本文更新于 2026-04-05

锁是数据库引擎用来管理对共享资源并发访问的机制，旨在保证事务的隔离性（Isolation）和一致性（Consistency）

锁的粒度 (Lock Granularity)

锁定的资源范围大小决定了系统的并发度

粒度等级	描述	特点
行级锁 (Row Lock)	锁定单行记录。	并发度最高，但加锁开销大（消耗内存多）。
页级锁 (Page Lock)	锁定一组相邻的数据页。	介于行锁与表锁之间（常见于 BDB 存储引擎）。
表级锁 (Table Lock)	锁定整张表。	开销小，加锁快，但并发度低（会导致大量阻塞）。

全局锁

全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。

其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性

功能：让整个库处于只读状态。
受限操作：
- 数据更新语句（数据的增删改）。
- 数据定义语句（建表、修改表结构等）。
- 更新类事务的提交语句

	FLUSH TABLES WITH READ LOCK;
	
	UNLOCK TABLES;

特点： 数据库中加全局锁，是一个比较重的操作，存在以下问题:
- 如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆
- 如果在从库上备份，那么在备份期间从库不能执行主库同步过来的二进制日志(binlog)，会导致主从延迟。

–single-transaction

如果使用的引擎支持事务（如 InnoDB，在使用 mysqldump 时可以使用参数 --single-transaction：

原理：在导数据之前就会启动一个事务，确保拿到一致性视图（Read View）。
优势：由于 MVCC（多版本并发控制）的支持，数据库在备份期间依然可以正常更新数据，不会阻塞业务

表级锁

MySQL 的表级锁开销小，加锁快，不会出现死锁，但锁冲突的概率最高，并发度也最低。

表锁 (Table Lock)

显式加锁语法：

加锁：lock tables 表名 read/write;
释放：unlock tables;（或客户端断开连接）

锁类型	描述
表共享读锁 (Read Lock)	共享锁。所有客户端（包括自己）只能读，不能写。
表独占写锁 (Write Lock)	独占锁。只有当前客户端可以读写，其他客户端被阻塞。

元数据锁 (Metadata Lock, MDL)

MDL 是隐式加锁的，不需要显式调用。它的作用是防止 DDL（结构变更）与 DML（数据增删改）之间的冲突。

对表做 DML 操作时：自动加 MDL 读锁（共享），不影响多个线程同时增删改查。
对表做 DDL 操作时：自动加 MDL 写锁（排他），此时会阻塞所有的增删改查。

风险点：给大表加字段时，如果有一个长查询在运行，MDL 写锁会排队，进而导致后续所有的查询和更新都被堵住，甚至拖垮整个数据库。

意向锁 (Intention Lock)

意向锁是为了解决“行锁”与“表锁”共存时的效率问题。

意向共享锁 (IS)：事务准备给某些行加读锁前，先给表加 IS。
- 与表锁共享锁(read)兼容，与表锁排他锁(write)互斥。
- 执行 SELECT ... FOR SHARE 前自动加。
意向排他锁 (IX)：事务准备给某些行加写锁前，先给表加 IX。
- 与表锁共享锁(read)及排他锁(write)都互斥，意向锁之间不会互斥。
- 执行 INSERT/UPDATE/DELETE 前自动加。

锁类型	IS (意向共享)	IX (意向排他)	S (表级共享)	X (表级排他)
IS	兼容	兼容	兼容	冲突
IX	兼容	兼容	冲突	冲突
S	兼容	冲突	兼容	冲突
X	冲突	冲突	冲突	冲突
核心意义：当你想加表锁（如 `lock tables write`）时，不需要逐行检查是否有行锁，直接看表上是否有意向锁即可，极大提高了性能。

[!tip] 解释意向锁就像是酒店大堂的状态指示牌。如果没有它，你想包下整个酒店（表锁），得挨个敲门看有没有人住（行锁）；有了它，你看一眼前台的登记簿（意向锁）就全明白了。

AUTO-INC 锁

这是一种特殊的表级锁，主要用于处理带有 AUTO_INCREMENT 列的表。

当插入数据时，会加一个表级的 AUTO-INC 锁来获取自增值。
在高并发插入场景下，这可能成为性能瓶颈（现代 MySQL 可以通过 innodb_autoinc_lock_mode 参数进行优化，使用轻量级互斥锁代替）。

行级锁

行级锁是 MySQL 中锁粒度最小的一种锁，主要由 InnoDB 存储引擎实现

它的特点是锁冲突概率最低，并发处理能力最强，但开销相对较大，且可能会出现死锁

锁类型	名称	锁定范围	作用	支持
Record Lock	记录锁	仅锁定单个索引记录。	防止其他事务修改或删除该行。	在RC,RR隔离级别下都支持
Gap Lock	间隙锁	锁定索引记录之间的间隙（不含记录本身）。	防止其他事务在间隙内插入数据，解决幻读。	在RR隔离级别下支持
Next-Key Lock	临键锁	记录锁 + 间隙锁的组合。（锁住数据及前面的间隙）	锁定一个范围，并锁定记录本身。InnoDB 默认的锁算法。

行锁

行锁分类

行锁在逻辑上主要分为两类：

共享锁 (S 锁 / Shared Lock)：又称读锁。允许事务读取一行数据。多个事务可以同时持有同一行的 S 锁。
- 特点：兼容 S 锁，冲突 X 锁。
排他锁 (X 锁 / Exclusive Lock)：又称写锁。允许事务删除或更新一行数据。当一个事务持有 X 锁时，其他事务无法再对该行加任何锁。
- 特点：冲突一切锁（包括 S 和 X）。

SQL 语句	行锁类型	说明
`INSERT ...`	排他锁 (X)	自动加锁。
`UPDATE ...`	排他锁 (X)	自动加锁。
`DELETE ...`	排他锁 (X)	自动加锁。
`SELECT (正常)`	不加任何锁	基于 MVCC 实现的快照读，不阻塞其他事务。
`SELECT ... LOCK IN SHARE MODE`	共享锁 (S)	需要手动在 `SELECT` 之后添加（兼容 S，互斥 X）。
`SELECT ... FOR UPDATE`	排他锁 (X)	需要手动在 `SELECT` 之后添加（互斥 S 和 X）。

[!TIPS] InnoDB 的行锁是通过给索引上的索引项加锁来实现的，而不是针对记录本身。这意味着：如果你的 SQL 没有走索引，行锁就会升级为表锁。

间隙锁和临键锁

在 InnoDB 的 可重复读 (RR) 隔离级别下，间隙锁和临键锁是解决 幻读 (PR) 的核心机制。它们都是行级锁的变体，但是锁定的范围不同

间隙锁 (Gap Lock)

间隙锁锁定的不是记录本身，而是两条索引记录之间的“间隙”，或者是第一条记录之前、最后一条记录之后的空间。

目的：防止其他事务在间隙中插入（INSERT）新数据，从而避免幻读。
特性：
- 间隙锁之间是兼容的。一个事务持有的间隙锁不会阻止另一个事务在同一个间隙上获取间隙锁。
- 它们唯一的冲突点是：防止其他事务插入数据。
示例：

假设表中 id 有 1, 5, 10。执行 SELECT * FROM t WHERE id = 3 FOR UPDATE;。由于 id=3 不存在，InnoDB 会在 (1, 5) 这个间隙加锁。此时，任何想插入 id=2, 3, 4 的操作都会被阻塞。

临键锁 (Next-Key Lock)

临键锁是 记录锁 (Record Lock) 和 间隙锁 (Gap Lock) 的组合。它既锁定索引记录本身，也锁定记录之前的间隙。

公式：Next-Key Lock = Gap Lock + Record Lock。
范围：默认是左开右闭区间。
默认机制：InnoDB 在 RR 隔离级别下，对行扫描时默认加的就是 Next-Key Lock。
示例：

假设表中 id 有 1, 5, 10。执行范围查询 WHERE id > 5 AND id <= 10 FOR UPDATE。临键锁会锁定区间 (5, 10]。这包括了间隙 (5, 10) 和记录 id=10 本身。

锁的退化规则 (优化)

为了提高并发性能，InnoDB 在某些特定条件下会将临键锁“降级”：

唯一索引等值查询（记录存在）：当使用主键或唯一索引进行等值查询，且记录确实存在时，Next-Key Lock 会退化为 记录锁 (Record Lock)。
- 原因：既然记录是唯一的且已存在，就不可能再插入相同的记录，没必要锁间隙。
唯一索引等值查询（记录不存在）：当查询的记录不存在时，Next-Key Lock 会退化为 间隙锁 (Gap Lock)。
- 范围：锁定该值所在的那个间隙。
非唯一索引（普通索引）查询：即便命中记录，InnoDB 也会在记录两边加锁（Next-Key Lock 加上右侧的 Gap Lock），以确保不会有新的相同索引值插入。

总结对比

锁类型	锁定对象	包含记录本身	主要作用
记录锁 (Record Lock)	单行记录	是	防止其他事务修改或删除该行
间隙锁 (Gap Lock)	索引之间的间隙	否	防止其他事务插入数据，解决幻读
临键锁 (Next-Key Lock)	间隙 + 记录	是	RR 级别下的默认锁，结合了前两者优点

核心提示：间隙锁和临键锁只在 可重复读 (RR) 或更严苛的隔离级别下生效。在 读已提交 (RC) 级别下，间隙锁会被禁用（除非涉及外键约束或重复键检查）。

多表查询

Thu, 02 Apr 2026 00:00:00 +0000

本文更新于 2026-04-02

SQL 进阶 - 多表查询

多表关系

在真实业务中，合理的表结构设计是高并发、高性能查询的基石。

一对多 (One-to-Many)
- 案例：一个部门有多个员工；一个用户有多个收货地址。
- 实现：在“多”的一方（从表）建立外键，指向“一”的一方（主表）的主键。
- 实战细节：在分布式或高并发系统中，为了性能，通常不建立物理外键约束，而是由应用层代码来保证逻辑外键的完整性。
多对多 (Many-to-Many)
- 案例：学生选课；电商系统中商品与订单。
- 实现：必须通过第三张中间表（关联表）来实现。中间表通常包含两个外键，分别对应两张原表的主键。
- 实战细节：中间表除了存储双方的 ID，往往还会挂载业务字段，比如“选课时间”、“购买数量”等。
一对一 (One-to-One)
- 案例：用户基础表与用户隐私详情表。
- 实现：在任意一方加入外键，并设置唯一约束 (UNIQUE)。
- 实战细节：主要用于冷热数据分离（垂直拆分）。将不常用的、大体积的字段（如用户简介）拆分出来，提升主表的查询效率。

多表查询概述与性能陷阱

多表查询的本质是将多张表按照某种逻辑横向“拼接”起来。

笛卡尔积 (Cartesian Product)
- 原理：不加任何条件的 SELECT * FROM A, B;。如果 A 表有 1 万条数据，B 表有 1 万条数据，结果将产生 1 亿条垃圾数据。
- 避坑：在编写任何多表查询时，永远先写连接条件（ON 或 WHERE），防止产生笛卡尔积导致数据库瞬间卡死。

内连接 (Inner Join)

最基础的连接，查询的是两张表完全匹配的交集。

隐式内连接（传统的 SQL92 标准，可读性较差）：

 SELECT e.name, d.name 
 FROM emp e, dept d 
 WHERE e.dept_id = d.id AND e.salary > 5000;

显式内连接（SQL99 标准，强烈推荐，逻辑清晰）：

 SELECT e.name, d.name 
 FROM emp e 
 [INNER] JOIN dept d ON e.dept_id = d.id -- INNER 可省略
 WHERE e.salary > 5000;

原理：MySQL 会用小表作为驱动表，去大表中进行匹配（通常配合索引提高速度）。

外连接 (Outer Join)

当你想保留某张表的全部数据，即使另一张表没有对应的数据时，使用外连接。

左外连接 (LEFT JOIN)：
- 特点：包含左表的全部行。如果右表没有匹配，右表的列显示为 NULL。
- 经典案例：查询所有员工及其对应的部门（包括刚入职、还没分配部门的新员工）。

	SELECT e.name, d.name 
	FROM emp e 
	LEFT JOIN dept d ON e.dept_id = d.id;

右外连接 (RIGHT JOIN)：
- 特点：包含右表的全部行。
- 实战建议：在实际开发中，我们 95% 的情况下都使用 LEFT JOIN。因为只需要调整表的先后顺序，LEFT JOIN 完全可以替代 RIGHT JOIN，代码风格更统一。

自连接 (Self Join)

这是一道极为经典的高频面试题。当表中的某列关联了本表的另一列时使用。

典型场景：
- 员工表（包含 emp_id 和 manager_id，领导也是员工）。
- 地区表（包含 area_id 和 parent_id，省、市、区都在一张表里）。
核心技巧：必须把一张表当成两张完全独立的表来看待，通过别名加以区分。
案例：查询员工姓名及其直属领导的姓名。

	-- 这里 a 代表员工表，b 代表领导表
	SELECT a.name AS '员工', b.name AS '领导'
	FROM emp a 
	LEFT JOIN emp b ON a.manager_id = b.id;

联合查询 (Union)

用于把多次 SELECT 的结果集纵向拼接在一起，变成一个大结果集。

UNION：自动去除重复的行，性能稍低，因为包含去重排序的操作。
UNION ALL：直接拼接，不进行去重。
性能军规：除非业务明确要求去重，否则在实际开发中一律优先使用 UNION ALL，性能远高于 UNION。
限制条件：
1. 两次查询的列数必须相同。
2. 对应列的字段类型或语义必须一致。

子查询 (Subquery) 全景解析

子查询是多表查询中极具技巧性的部分。根据子查询返回结果的不同，分为以下四类：

标量子查询

特征：子查询只返回一个孤零零的值。
案例：查询薪资比“张三”高的所有员工

	SELECT * FROM emp 
	WHERE salary > (SELECT salary FROM emp WHERE name = '张三');

列子查询

特征：子查询返回的是一列数据（多行单列）。
核心操作符：
- IN：在指定的集合范围内。
- NOT IN：不在范围内。
- ANY / SOME：满足其中任意一个即可。
- ALL：必须满足所有的条件。
案例：查询研发部和销售部所有员工的工资。

	SELECT name, salary FROM emp 
	WHERE dept_id IN (SELECT id FROM dept WHERE name IN ('研发部', '销售部'));

行子查询

特征：子查询返回的是一行数据（单行多列）。
案例：查询与“李四”的薪资且直属领导完全相同的员工。

	SELECT * FROM emp 
	WHERE (salary, manager_id) = (SELECT salary, manager_id FROM emp WHERE name = '李四');

表子查询

特征：子查询返回的是一个二维表格（多行多列）。
经典用法：作为 FROM 后面的临时表使用，或者用 IN 配合多列。
案例：查询入职日期在“2025-01-01”之后的员工，并关联他们的部门信息。

	-- 将子查询的结果作为一张临时表 temp
	SELECT t.name, d.dept_name 
	FROM (
		SELECT * FROM emp 
		WHERE entry_date > '2025-01-01'
	)t
	LEFT JOIN dept d ON t.dept_id = d.id;

外键约束

一对多

父表（Parent Table / Referenced Table）：被引用的表，通常主键（Primary Key）所在的表
子表（Child Table / Foreign Key Table）：引用父表的表，外键所在的表
外键列：子表中存储父表主键值的列

-- 父表
CREATE TABLE Departments (
 DeptID INT PRIMARY KEY,
 DeptName VARCHAR(50) NOT NULL
);

-- 子表
CREATE TABLE Emp(
 EmpID INT PRIMARY KEY,
 EmpName VARCHAR(50),
 DeptID INT,
 -- 定义外键约束
 CONSTRAINT fk_dept 
 FOREIGN KEY (DeptID) REFERENCES Departments(DeptID)
 ON DELETE CASCADE -- 部门删除时，员工也自动删除
);

如果表已经创建好了，可以使用 ALTER TABLE：

-- 添加外键
ALTER TABLE Emp ADD CONSTRAINT fk_dept FOREIGN KEY (DeptID) REFERENCES Departments(DeptID)
 
-- 删除外键
ALTER TABLE Emp DROP FOREIGN KEY fk_dept

一对一

一个用户只能有一个身份证号，一个身份证号也只能对应一个用户

-- 用户表（主表）
CREATE TABLE Users (
 user_id INT PRIMARY KEY AUTO_INCREMENT,
 username VARCHAR(50) NOT NULL
);

-- 身份证表（从表）
CREATE TABLE IDCards (
 card_id INT PRIMARY KEY AUTO_INCREMENT,
 card_number CHAR(18) NOT NULL UNIQUE,
 user_id INT UNIQUE, -- 关键点：UNIQUE 约束确保一对一
 CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES Users(user_id)
);

多对多

-- 学生表
CREATE TABLE Students (
 student_id INT PRIMARY KEY AUTO_INCREMENT,
 name VARCHAR(50)
);

-- 课程表
CREATE TABLE Courses (
 course_id INT PRIMARY KEY AUTO_INCREMENT,
 title VARCHAR(50)
);

-- 中间表（维护多对多关系）
CREATE TABLE Student_Courses (
 student_id INT,
 course_id INT,
 PRIMARY KEY (student_id, course_id), -- 联合主键防止重复选课
 CONSTRAINT fk_student 
	 FOREIGN KEY (student_id) REFERENCES Students(student_id),
 CONSTRAINT fk_course 
	 FOREIGN KEY (course_id) REFERENCES Courses(course_id)
);

联合主键（Composite Primary Key）：中间表通常建议使用 (ID_A, ID_B) 作为联合主键，这样可以从物理层面防止数据重复（例如：防止同一个学生对同一门课选两次）
冗余字段：中间表不一定只能有两个 ID。它还可以存储“关系本身”的属性。例如：在 Student_Courses 中增加 score（成绩）或 enroll_date（选课时间）字段
查询方式：查询多对多数据通常需要 两次 JOIN。
- 查询张三选了哪些课： Students JOIN Student_Courses JOIN Courses

物理外键的缺点

性能瓶颈：在高并发写入时，外键校验会导致频繁的行锁竞争，降低吞吐量
分库分表困难：当数据量大到需要拆分到不同物理数据库时，跨库的物理外键是无法实现的
死锁风险：复杂的级联更新容易导致数据库产生死锁，排查极其困难
测试麻烦：手动构造测试数据时，必须先造父表再造子表，流程繁琐

个人常犯的错误

题目要求：查询拥有员工的部门

内连接！
INNER JOIN = 只查两边都匹配的数据（最适合本题）
RIGHT JOIN 会把没有部门的员工也带进来，产生 NULL 部门
题目要有员工的部门 → 必须用 INNER JOIN 或加 IS NOT NULL

	SELECT DISTINCT d.dept_name FROM department d 
	INNER JOIN employee e 
	ON e.dept_id = d.dept_id;

JOIN的使用

	SELECT e.emp_name FROM employee e 
	JOIN( 
	 SELECT dept_id,AVG(salary) AS avg_salary 
	 FROM employee 
	 GROUP BY dept_id 
	)t ON e.dept_id = t.dept_id 
	WHERE e.salary < t.avg_salary;

此SQL语句等价于

	SELECT e.emp_name FROM employee e 
	WHERE e.salary < (SELECT AVG(salary) FROM employee WHERE dept_id = e.dept_id);

`COUNT(*)`是什么？

写法	意思
`COUNT(*)`	数总行数，包括 NULL
`COUNT(字段)`	数这个字段不为 NULL 的行数
`COUNT(1)`	效果基本同 `COUNT(*)`，也是数行数
`COUNT()`：统计当前组里一共有多少条记录*

	-- 查询每个部门的人数
	SELECT d.dept_name,COUNT(*) 
	FROM employee e,department d 
	WHERE e.dept_id = d.dept_id GROUP BY d.dept_name;

进阶-存储引擎

Thu, 02 Apr 2026 00:00:00 +0000

本文更新于 2026-04-02

MySQL 体系结构

连接层 (Connection Layer)

最上层由一些客户端和链接服务组成，主要完成连接处理、授权认证及相关的安全方案。服务器会为每个成功接入的客户端验证其所具有的操作权限，确保数据访问的安全性。

服务层 (Service Layer)

第二层架构是 MySQL 的大脑，主要完成大多数的核心服务功能：

功能组件：包括 SQL 接口、解析器、优化器以及部分内置函数的执行（如日期、时间、数学函数等）。
跨引擎实现：所有跨存储引擎的功能都在这一层实现，例如存储过程、触发器、视图等。
查询缓存：完成对 SQL 查询缓存的处理和匹配。

存储引擎层

引擎层 (Engine Layer)

存储引擎层真正负责了 MySQL 中数据的存储和提取，是插件式的架构。

通信方式：服务器通过 API 与不同的存储引擎进行通信。
灵活选择：不同的存储引擎具有不同的特性和功能（如 InnoDB 支持事务，而 MyISAM 不支持），我们可以根据业务需求选取合适的存储引擎。

存储层 (Storage Layer)

最底层是数据存储层，主要将数据存储在文件系统之上（如磁盘、日志文件等），并完成与上层存储引擎的数据交互。

存储引擎

存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式。存储引擎是基于表的，而不是基于数据库的，所以存储引擎也可以被称为表类型。

核心：InnoDB 存储引擎

InnoDB 是 MySQL 5.5 之后默认的存储引擎，也是最通用的引擎。

特点：
- 事务 (ACID)：DML操作支持事务安全，具有提交、回滚和崩溃恢复能力。
- 外键 (Foreign Key)：支持外键约束，保证数据的完整性。
- 行级锁 (Row-level Locking)：提高多用户并发操作的性能。
文件存储：
- 每一张 InnoDB 表对应一个 .ibd 表空间文件（存储表结构(frm,sdi)、数据和索引）
- 参数：innodb_file_per_table
逻辑存储结构：
- TableSpace（表空间） -> Segment（段） -> Extent（区，1MB） -> Page（页，16KB，磁盘操作的最小单元） -> Row（行）

MyISAM 存储引擎

MyISAM 是 MySQL 早期的默认存储引擎。它不支持事务，但在读取性能和空间占用上具有一定优势。

介绍：主要用于以读为主的业务场景。
特点：
- 不支持事务，不支持外键。
- 支持表级锁，不支持行级锁。
- 访问速度快，占用空间相对较小。
文件存储：每一张 MyISAM 表对应三个文件：
- xxx.sdi：存储表结构信息（JSON 格式）。
- xxx.MYD：存储数据 (MYData)。
- xxx.MYI：存储索引 (MYIndex)。

Memory 存储引擎

Memory 引擎将表数据存储在内存中，由于不需要磁盘 I/O，其访问速度极快。

介绍：通常用于存储临时数据、缓存或中间计算结果。
特点：
- 内存存放：速度极快，但安全性低。
- 易失性：一旦数据库重启或崩溃，内存表中的数据会全部丢失，但表结构会保留。
- 默认使用 Hash 索引（适合等值查询，不适合范围查询）。
- 支持表级锁。
文件存储：
- xxx.sdi：只存储表结构信息。数据全部驻留在内存中，不生成物理数据文件。重点

存储引擎选择建议

InnoDB：首选。
如果应用对事务的完整性有要求，或者需要处理高并发的增删改查操作，InnoDB 是唯一的选择。
MyISAM：过去MySQL的引擎
如果应用是以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完整性、并发性要求不是很高，那么可以选择 MyISAM（但在现代开发中已逐渐被 InnoDB 取代）
Memory：将所有数据保存在内存中，访问速度极快。
通常用于存储临时数据或缓存，由于数据在断电或重启后会丢失，因此不适合存储持久化数据。

存储引擎相关 SQL 操作

查看当前数据库支持的存储引擎：
```
SHOW ENGINES;
```

创建表时指定存储引擎：

CREATE TABLE 表名 (
 ...
) ENGINE = INNODB;

查询建表语句（查看当前表引擎）：
```
SHOW CREATE TABLE 表名;
```

进阶-索引

Thu, 02 Apr 2026 00:00:00 +0000

本文更新于 2026-04-02

MySQL 索引概述 (Index)

索引是帮助 MySQL 高效获取数据 的 数据结构 (有序)。（⭐⭐⭐）

在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引

索引的优缺点

特性	优点	缺点
查询效率	提高数据检索的效率，降低数据库的 IO 成本。	索引列也是要占用空间的。
排序效率	通过索引列对数据进行排序，降低 CPU 的消耗。	索引大大提高了查询效率，但降低了更新表的速度（如 INSERT、UPDATE、DELETE）。

索引的本质：数据结构

假设有一张包含数百万条记录的表，如果没有索引，数据库必须进行全表扫描 (Full Table Scan)，即从第一行开始逐行比对，效率极低。

无索引：$O(n)$ 的时间复杂度。
有索引：通过 B+Tree 等结构，将复杂度降低至 $O(\log n)$。

索引结构

在存储引擎层实现，不同的存储引擎有着不同的索引结构

索引结构	描述
B+Tree 索引	最常见的索引类型，大部分引擎都支持。
Hash 索引	底层采用哈希表实现，只有 Memory 引擎支持，不支持范围查询。
R-tree 索引	空间索引，主要用于地理信息数据类型（MyISAM 支持）。
Full-text 索引	全文索引，通过建立倒排索引快速匹配文本中的关键词。类似于：Lucence，Solr，ES

注意：InnoDB 具有自适应哈希索引 (Adaptive Hash Index) 功能。当 InnoDB 注意到某些索引值被频繁查询时，会在内存中自动基于 B+Tree 索引建立哈希索引，以加速等值寻找。

B-Tree

二叉树缺点：顺序插入时，会形成一个链表，查询性能大大下降。大数据量情况下，层级较深，检索速度慢
红黑树：大数据量情况下，层次较深，检索速度慢

B-Tree:

点击查看演示
B树是一种多路平衡查找树。这里的“多路”是指一个节点可以有多个子节点（不像二叉树只有 2 个）
以一颗最大度数(max-degree)为5(5阶)的b-tree为例(每个节点最多存储4个key，5个指针)

核心特征：

节点包含数据： 每个节点既存储了索引键 (Key)，也存储了对应的整行数据 (Data)
自平衡： 无论插入多少数据，树的高度始终保持平衡，确保查询效率稳定在 $O(\log n)$。
搜索规则： 类似于二叉查找树。比当前节点小的走左边，大的走右边，中间的走中间分支。

B+Tree

点击查看演示
相对于B树的区别：
- 所有的数据都会出现在叶子节点
- 叶子节点形成一个单向链表
以一颗最大度数（max-degree）为4（4阶）的B+Tree为例：
B+Tree 将所有数据记录节点按照键值大小顺序存放在同一层的叶子节点上，而非叶子节点只存储索引（中间键）和指向下一层的指针。

B+Tree（B+树）是 B-Tree 的变体，也是 MySQL InnoDB 存储引擎索引的底层实现。

在原B+Tree的基础上，增加一个指向相邻叶子节点的链表指针，就形成了带有顺序指针的B+Tree，提高区间访问的性能 -> 利于数据库排序

[!NOTE] 关键区别 B树：数据分布在所有节点中。适合单一 Key 查找（像 MongoDB 部分场景）。 B+树：数据仅在叶子节点中。适合范围扫描和大规模排序（MySQL 的标准选择）。

Hash索引

哈希索引（Hash Index）是建立在哈希表结构上的索引。
它通过哈希算法将列值转换为哈希码（Hash Code），并将其映射到对应的桶（Bucket）中
如果两个(或多个)键值，映射到一个相同的槽位上，他们就产生了hash冲突(也称为hash碰撞)，可以通过链表来解决

工作原理

计算哈希值：对索引列的每一行数据计算一个哈希码。
存储映射：在哈希表中存储哈希码以及指向对应数据行的指针。
查询匹配：查询时，对目标值计算哈希码，直接定位到对应的桶，获取行指针

Hash 索引的特点

优势：查询速度极快

等值查询：对于 =、IN、<=> 操作，通常只需要一次检索即可定位数据。（前提不出现哈希冲突）
复杂度：理想情况下，时间复杂度为 $O(1)$，性能优于 B+Tree 的 $O(\log n)$。

局限性（重点）

不支持范围查询：
- 哈希码的大小顺序与原始值的大小顺序无关，因此无法处理 >、<、BETWEEN 或 LIKE 前缀匹配。
无法利用索引排序：
- 由于存储是无序的，数据库无法利用哈希索引来加速 ORDER BY 操作。
不支持部分索引列匹配：
- 对于复合索引，Hash 索引必须使用全部索引列才能计算哈希值。例如索引 (A, B)，只查 A 无法使用索引。
哈希碰撞（Hash Collision）：
- 如果大量不同键值的哈希码相同，会导致碰撞，此时需要遍历链表，查询效率会随之下降。

在MySQL中，支持hash索引的是Memory引擎，而innoDB中具有自适应hash功能，hash索引是存储引擎根据B+Tree索引在指定条件下自动构建的

问题…

为什么InnoDB存储引擎选择使用B+tree索引结构?

虽然 Hash 索引查询单条数据是 $O(1)$，但它不支持模糊查询（LIKE）和范围查询（> <），且容易产生哈希冲突。因此 InnoDB 只将其作为“自适应哈希索引”插件使用，核心结构依然是 B+Tree

对于B-tree，无论是叶子节点还是非叶子节点，都会保存数据，这样导致一页中存储的键值减少，指针跟着减少，要同样保存大量数据，只能增加树的高度，导致性能降低

相对Hash索引，B+Tree支持范围匹配及排序操作

为什么数据库初衷想用 B树？

相比于二叉树（如红黑树、AVL树），B树在数据库中有巨大优势：

降低树的高度： 数据库数据量极大。二叉树太高了，意味着找个数据要进行很多次磁盘 IO。B树通过增加“路数”，让树变得“矮胖”，通常 3-4 层就能支撑百万级数据。

磁盘预读策略： 数据库每次从磁盘读数据都是按“页（Page）”读的。B树的节点大小可以设计得刚好等于一个磁盘页，一次 IO 就能把一整个节点加载到内存。

索引分类

从逻辑业务层面分类

索引名称	关键字	功能描述	限制
主键索引	`PRIMARY KEY`	针对表的主键创建的索引。	默认自动创建，唯一且不允许 NULL。
唯一索引	`UNIQUE`	避免同一个表中某列的数据重复。	允许有 NULL 值，但值必须唯一。
常规索引	`INDEX` / `KEY`	快速定位特定数据，最常用的类型。	无限制，可重复。
全文索引	`FULLTEXT`	用于在大量文本中查找关键词。	主要用于 `CHAR`、`VARCHAR`、`TEXT`。

从物理存储层面分类 (InnoDB 引擎核心)

类型	定义	特点	选取/规则
聚集索引	数据与索引存放在一起，叶子节点存储完整行数据	每张表有且只有一个	1. 主键优先 2. 无主键则用第一个唯一索引 3. 都无则自动生成隐式 rowid
二级索引	数据与索引分开存储，叶子节点存储主键值	一张表可以有多个	查找非索引字段需要执行回表查询

问题…

为什么不建议在所有列上都建索引？

虽然索引能加快查询，但每增加一个索引，都会增加 INSERT/UPDATE/DELETE 的开销，因为数据库在修改数据的同时还要维护索引树的有序性。

同时，索引也会占用额外的物理磁盘空间

以下SQL语句，哪个执行效率高，为什么？

	SELECT * FROM user WHERE id = 10;
	
	SELECT * FROM user WHERE name = 'Arm';
	-- 备注：id 为主键，name字段创建的有索引

第一条语句：基于 id（聚簇索引）

搜索路径：直接在主键 B+Tree 中搜索。
结果获取：由于主键索引是聚簇索引，它的叶子节点直接存放了这一行的完整数据。
效率：只需搜索一棵树，找到 id=10 的节点后，直接取出整行记录。

第二条语句：基于 name（二级索引/辅助索引）

第一步（搜索二级索引）：在 name 字段的 B+Tree 中搜索 'Arm'。二级索引的叶子节点存放的是该行对应的主键值（即 id=10）。
第二步（回表查询）：拿到主键值后，程序必须再跑去主键索引树里搜一遍，才能拿到 SELECT * 所需的完整行数据。
效率：需要搜索两棵树。这个过程被称为 “回表”（Look-up），多了一次树的遍历和可能的磁盘 I/O。

步骤	WHERE id = 10	WHERE name = ‘Arm’
第一步	查找主键 B+Tree	查找 `name` 索引 B+Tree
第二步	直接返回数据	获取主键值
第三步	-	回到主键 B+Tree 查找完整数据（回表）
I/O 次数	较少	较多

InnoDB主键索引的B+tree高度为多高

InnoDB 的 B+Tree 高度通常在 3 到 4 层，因为根节点和二级节点存的是‘主键+指针’（16KB 的页约能存 1170 个分支），只有叶子节点存‘整行数据’（约能存 16 行），这种‘矮胖’结构使得 3 层树就能支撑约 2190 万行数据的极速查询。

索引语法

创建索引

	CREATE [UNIQUE | FULLTEXT] INDEX 索引名 ON 表名 (字段名,...);
	
	
	-- 
	-- 为 user 表的 name 字段创建常规索引 
	CREATE INDEX idx_user_name ON tb_user(name);
	
	-- 为 user 表的 phone 字段创建唯一索引
	CREATE UNIQUE INDEX idx_user_phone ON tb_user(phone);
	
	-- 为 user 表的 name, age, status 创建联合索引
	CREATE INDEX idx_user_name_age_sta ON tb_user(name, age, status);

字段说明：
- UNIQUE：可选，创建唯一索引
- FULLTEXT：可选，创建全文索引
- (字段名,...)：如果是多个字段，则为联合索引

查看索引

	SHOW INDEX FROM 表名;
	
	-- 格式化输出
	SHOW INDEX FROM 表名\G;

删除索引

	DROP INDEX 索引名 ON 表名;

SQL性能分析

查看 SQL 执行频率

了解当前数据库是以查询为主，还是以增删改为主，决定了优化的侧重点。

命令：

	-- 查看全局 session 的状态信息
	SHOW GLOBAL STATUS LIKE 'Com_______';

说明：通过 Com_select (查询)、Com_insert (插入)、Com_update (更新)、Com_delete (删除) 的次数，可以判断数据库的负载特征。如果以查询为主，则应重点关注索引优化。

慢查询日志(Slow Query Log)

慢查询日志记录了所有执行时间超过指定参数（long_query_time，单位：秒，默认10秒）的 SQL 语句。

查看开关状态：show variables like 'slow_query_log';* 开启配置（在 /etc/my.cnf 中）：

	# 开启慢查询日志
	slow_query_log=1

	# 设置慢查询阈值为2秒
	long_query_time=2

show profiles (查看执行耗时)

show profiles 能够帮助我们了解 SQL 在执行过程中，时间具体消耗在了哪个环节（如：Sending data, Sorting, Copying to tmp table）。

查看支持情况：SELECT @@have_profiling;
开启：SET profiling = 1;
使用步骤：
1. 执行 SQL 语句。
2. 查看所有 SQL 的简要耗时：SHOW PROFILES;
3. 查看特定 query_id 的详细阶段耗时：SHOW PROFILE FOR QUERY [query_id];
4. 查看 CPU 消耗：SHOW PROFILE CPU FOR QUERY [query_id];

explain 执行计划

这是最常用的性能分析手段。在 SELECT 语句前加上 EXPLAIN 关键字，MySQL 会模拟执行并返回该 SQL 的执行计划。

	EXPLAIN SELECT 字段 FROM 表 WHERE 条件;

重点关注字段说明：

字段	含义	状态解析
id	查询序列号	id 相同，执行顺序由上至下；id 不同，值越大优先级越高。
select_type	查询类型	SIMPLE (简单查询), PRIMARY (主查询), UNION, SUBQUERY。
type	连接类型	性能由好到差：`NULL`>`system` > `const` > `eq_ref` > `ref` > `range` > `index` > `ALL`。至少达到 range 级别，要求 ref。
possible_keys	可能用到的索引	显示可能应用在这张表上的索引。
key	实际用到的索引	如果为 NULL，则没有使用索引。
key_len	索引使用的字节数	越短越好（不损失精确性的前提下）。
rows	扫描行数	预估扫描的行数，越小越好。
Extra	额外信息	`Using filesort` (效率低), `Using temporary` (效率低), `Using index` (性能好)。

索引使用规则

最左前缀法则 (Most Left Prefix Rule)

如果索引了多列（联合索引），要遵守最左前缀法则。指的是查询从索引的最左列开始，并且不跳过索引中的列。如果跳过，索引将部分失效

匹配规则：必须包含索引最左边的列。如果跳过了某列，该列及后面所有的索引失效。
案例：
- 建立联合索引 idx_user_pro_age_sta (profession, age, status)

	*建立索引* profession -> age -> stats
	
	WHERE profession = '软件工程' AND age = 31 AND status = '0' （全生效）
	
	-- 字段顺序不会影响索引
	WHERE age = 31 AND status = '0' AND profession = '软件工程';(全生效)
	
	WHERE profession = '软件工程' （生效）
	
	WHERE age = 31 AND status = '0' （失效，跳过了最左列）
	
	WHERE profession = '软件工程' AND status = '0'（只有 profession 生效，status 失效）

范围查询 (Range Query)

联合索引中，出现范围查询（>, <），范围查询右侧的列索引失效。

案例：WHERE profession = '软件工程' AND age > 30 AND status = '0'
- 此时 status 字段无法用到索引。
- 规避方案：在业务允许的情况下，尽量使用 >= 或 <=，这样可以避免索引失效。

索引失效场景

函数/运算操作：在索引列上进行运算或使用函数，索引失效。
- 失效：WHERE substring(phone, 10, 2) = '15'
- 失效：WHERE age + 1 = 20
字符串不加引号：字符串类型字段查询时不加单引号，MySQL 会进行隐式类型转换，导致索引失效。
- 失效：WHERE phone = 13800001111 （应为 '13800001111'）
模糊查询：如果仅仅是尾部模糊匹配，索引不会失效。如果是头部模糊匹配，索引失效。
- 有效：WHERE name LIKE '张%'
- 失效：WHERE name LIKE '%张' 或 WHERE name LIKE '%张%'
OR 连接条件：用 OR 分割开的条件，如果 OR 前的列有索引，而后面的列没有索引，那么涉及的索引都不会被用到。
- 解决方案：对于无索引的列也建立索引
- 注意：两侧必须有各自的索引
数据分布影响：如果 MySQL 评估使用索引比全表扫描更慢（例如查询的数据占全表绝大多数），则不会使用索引

SQL 提示 (SQL Hint)

当一个字段有多个索引可选时，我们可以通过 SQL 提示来“建议”或“强制” MySQL 使用哪个索引。

USE INDEX（建议）：

	SELECT * FROM tb_user USE INDEX(idx_user_name) WHERE name = '张三';

IGNORE INDEX（忽略）：

	SELECT * FROM tb_user IGNORE INDEX(idx_user_name) WHERE name = '张三';

FORCE INDEX（强制）：

	SELECT * FROM tb_user FORCE INDEX(idx_user_name) WHERE name = '张三';

覆盖索引 (Covering Index)

覆盖索引是性能优化的极致目标。

尽量使用覆盖索引(查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到)，减少SELECT*

原理：无需回表查询（无需回到聚集索引中找行数据）。
判定：在 EXPLAIN 的 Extra 列中出现 Using index。

Using index condition：查找使用了索引，但是需要回表查询数据
Using where ; using index：查找使用了索引，但是需要的数据在索引列中能找到，所以不需要回表查询

问题

一张表,有四个字段(id,username,password,status)由于数据量大,需要对以下SQL语句进行优化
该如何进行才是最优方案:

	select id,username,password from tb user where username = 'itcast';

方案	索引配置	查询行为	评价
方案一（差）	无索引	全表扫描	随着数据量增大，性能直线下降。
方案二（中）	`INDEX(username)`	索引查找 + 回表	能定位，但需要回表去查 `password`，有额外 I/O。
方案三（优）	`INDEX(username, password)`	覆盖索引扫描	最快。无需回表，数据直接从索引树取出。

前缀索引

当字段类型为长文本（如 TEXT 或很长的 VARCHAR）时，建立完整索引会导致索引文件巨大，查询浪费大量磁盘IO，效率低。此时可以只将字符串的前一部分建立索引，这样可以大大节约索引空间，从而提高索引效率

语法：CREATE INDEX idx_xxx ON table_name(column(n));
选择性：前缀的长度 n 取决于字段的选择性（不重复的索引值 / 总行数），选择性越高效率越高。

/*
	索引选择性 = 不重复的索引值数量（基数） / 总记录数
	取值范围：0 ~ 1
	选择性越接近 1，索引的区分度越高，查询效率越好
	唯一索引的选择性是 1，是最优情况
*/

-- 计算完整 email 字段的选择性
select count(distinct email) / count(*) from tb_user;

-- 计算 email 前 5 个字符的选择性
select count(distinct substring(email,1,5)) / count(*) from tb_user;

维度	完整列索引 (Full Index)	前缀索引 (Prefix Index)	影响分析
存储空间	较大（占用磁盘多）	极小（显著节省空间）	数据量越大，前缀索引的成本优势越明显。
写入性能 (DML)	较慢（索引树维护重）	较快（索引页更紧凑）	插入和更新长字符串时，前缀索引负担更轻。
查询定位速度	极快（精准匹配）	快（但存在哈希冲突风险）	如果前缀区分度高，两者定位速度接近。
覆盖索引	支持 (Using index)	不支持 (必须回表)	前缀索引无法提供完整字段值，必须回主表二次验证。
排序 (ORDER BY)	支持	不支持	数据库无法利用前缀的顺序来完成全字段的排序。
分组 (GROUP BY)	支持	不支持	必须拉取完整数据到内存中进行分组计算。
区分度 (Selectivity)	最高	取决于截取长度	截取太短会导致索引失效（类似全表扫描）。

单列索引与联合索引

维度	单列索引 (Single-Column Index)	联合索引 (Composite/Joint Index)
定义	基于表中的一个列建立的索引。	基于表中的两个或多个列建立的索引。
B+树键值	节点中只包含 `[该列值 \| 主键ID]`。	节点中包含 `[列1, 列2, 列3... \| 主键ID]`。
排序规则	按该列的逻辑顺序排列。	按创建索引时的列顺序，逐级排序（字典序）。

优缺点

维度	单列索引	联合索引
优点	灵活，适用于多种不同的简单查询；索引维护成本相对低。	复合查询性能极强；支持覆盖索引；减少索引文件总数（相比建多个单列）。
缺点	在多条件复合查询下，过滤效率不如联合索引。	遵循最左前缀，灵活性差；索引列多时，单条记录变宽，单页存储数量下降。
适用场景	字段分布散、查询条件单一、或该列在多个不同场景被单独引用。	存在高频的多个字段组合查询；需要通过索引覆盖来规避大表回表。

设计原则

数据规模与查询频次

原则： 针对于数据量较大，且查询比较频繁的表建立索引。
解读： 小表或极少查询的表建立索引的意义不大，反而会增加维护开销。

关键操作字段

原则： 针对于常作为查询条件（where）、排序（order by）、**分组（group by）**操作的字段建立索引。
解读： 索引不仅能加速过滤，还能利用 B+ 树的有序性加速排序和分组过程。

选择性与区分度

原则： 尽量选择区分度高的列作为索引，尽量建立唯一索引。
解读： 区分度越高（重复值越少），MySQL 优化器使用索引的效率越高。

字符串长字段处理

原则： 如果是字符串类型的字段，且字段长度较长，可以针对字段的特点建立前缀索引。
解读： 通过截取字段的前一部分建立索引，可以节省存储空间并提升 I/O 效率。

联合索引优先

原则： 尽量使用联合索引，减少单列索引。
解读： 联合索引在很多时候可以实现覆盖索引（Covering Index），从而避免回表查询，节省存储空间并显著提高查询效率。

控制索引数量

原则： 要控制索引的数量，索引并不是多多益善。
解读： 索引越多，维护索引结构的代价（磁盘 I/O 和 CPU）也就越大，会直接影响**增删改（INSERT/DELETE/UPDATE）**的效率。

NULL 值约束

原则： 如果索引列不能存储 NULL 值，请在创建表时使用 NOT NULL 约束它。
解读： 当优化器知道每列是否包含 NULL 值时，它可以更好地确定哪个索引最有效地用于查询。此外，索引 NULL 值在存储和计算上更复杂。

事务

Thu, 02 Apr 2026 00:00:00 +0000

本文更新于 2026-04-02

简介

事务是一组 SQL 语句组成的逻辑处理单元。这组操作要么全部执行成功，要么全部失败回滚，不能只执行其中的一部分
典型场景：银行转账。A 账户减 100 元，B 账户加 100 元。这两个操作必须同时成功，否则钱就“凭空消失”了

事务操作

在 MySQL 中，默认是 自动提交 (autocommit) 的。

查看/设置自动提交：SELECT @@autocommit; (1为自动, 0为手动)
开启事务：START TRANSACTION; 或 BEGIN;
提交事务：COMMIT;（将更改永久保存到数据库）
回滚事务：ROLLBACK;（撤销所有未提交的操作，恢复到事务开始前的状态） 1.修改提交方式

	SELECT @@autocommit; -- 查看当前的自动提交状态 
	SET @@autocommit = 0; -- 关闭自动提交 
	 
	SELECT * FROM account WHERE name = '张三'; 
	-- 查询姓名为张三的账户信息 
	 
	UPDATE account SET money = money - 1000 WHERE name = '张三'; 
	-- 给张三的账户减少1000元 
	报错语句...; 
	UPDATE account SET money = money + 1000 WHERE name = '李四';
	-- 给李四的账户增加1000元 
	 
	ROLLBACK ; -- 回滚事务，撤销之前的修改 
	COMMIT; -- 提交事务，保存修改

2.开启事务的方式

	START TRANSACTION; -- 开始一个新的事务
	...同上

事务的四大特性 (ACID)

这是数据库事务的基石，必须死记硬背：

原子性 (Atomicity)：事务是最小的执行单位，不可分割。要么全部完成，要么全部不执行。
一致性 (Consistency)：事务执行前后，数据库从一个一致性状态转换到另一个一致性状态（如转账前后总金额不变)
(事务完成时必须是所有的数据保持一致状态)
隔离性 (Isolation)：并发访问数据库时，多个事务之间相互隔离，互不干扰（通过锁机制和多版本并发控制 MVCC 实现）
持久性 (Durability)：一旦事务提交或回滚，其对数据库中数据的改变就是永久性的，即使系统崩溃也不会丢失。

`ROLLBACK` 符合持久性，是因为：

结果永久化： 回滚后的数据状态和提交后的状态一样，都受到系统故障保护，不会在重启后失效。
物理一致性： 数据库确保了“回滚”这一决策在物理磁盘上是完整执行且不可逆转的。

并发事务引发的问题

当多个事务同时操作同一批数据时，如果不加控制，会产生以下问题：

脏读 (Dirty Read)：一个事务读取到了另一个事务尚未提交的数据
类似于：读到了草稿纸上的数据
不可重复读 (Non-Repeatable Read)：一个事务先后读取同一条记录，但两次读取的数据不同（中间有另一个事务更新并提交了该数据）。
幻读 (Phantom Read)：一个事务按照条件查询数据时，没有对应的数据行，但在插入数据时又发现这行数据已经存在（中间有另一个事务插入并提交了数据）。

类似于：更改密码的时候不可以使用旧密码

事务隔离级别

为了解决上述并发问题，数据库提供了四种隔离级别。级别越高，数据越安全，但并发性能越低。

隔离级别（√表示会出现）	脏读	不可重复读	幻读	性能
Read Uncommitted (读未提交)	√	√	√	最高
Read Committed (读已提交)	×	√	√	高（Oracle默认）
Repeatable Read (可重复读)	×	×	√	中 (MySQL默认)
Serializable (串行化)	×	×	×	最低

注意：MySQL 的 InnoDB 引擎在 Repeatable Read 级别下，通过间隙锁（Next-Key Locks）在很大程度上规避了幻读问题。

	-- 查看事物隔离级别
	SELECT @@TRAN_ISOLATION_LEVEL;
	-- 设置事务隔离级别
	SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL 
	[READ UNCOMMITTED|READ COMMITTED|
	REPEATABLE READ|SERIALIZABLE];
	
	-- 精简：‘’中不能有空格，用 - 代替
	SET @@SESSION.TRANSACTION_ISOLATION = 'READ-COMMITTED |...';

事务原理简介

MySQL 如何实现 ACID？

原子性：由 undo log（回滚日志）保证。
持久性：由 redo log（重做日志）保证。
隔离性：由 锁机制 + MVCC（多版本并发控制）保证。
一致性：由原子性、持久性、隔离性共同支撑，外加数据库逻辑约束。

函数

Sun, 29 Mar 2026 00:00:00 +0000

本文更新于 2026-03-29

字符串函数

基础处理函数

函数	功能	示例代码块
CONCAT(s1, s2…sn)	字符串拼接，将多个字符串合并为一个	`SELECT CONCAT('Hello', ' ', 'World');`
LOWER(str)	将字符串全部转换为小写	`SELECT LOWER('MySQL');` → `mysql`
UPPER(str)	将字符串全部转换为大写	`SELECT UPPER('mysql');` → `MYSQL`
TRIM(str)	去除字符串左右两边的空格	`SELECT TRIM(' abc ');` → `abc`
截取与填充函数

函数	功能	示例代码块
SUBSTR(s, start, len)	从 start 位置开始截取 len 长度的字符串	`SELECT SUBSTR('HelloSQL', 1, 5);` → `Hello`
LPAD(str, len, pad)	左填充，用 pad 将 str 填充到 len 长度	`SELECT LPAD('01', 5, '-');` → `---01`
RPAD(str, len, pad)	右填充，用 pad 将 str 填充到 len 长度	`SELECT RPAD('01', 5, '-');` → `01---`

注意点： 1.索引位置：在 SQL 的 SUBSTR 函数中，索引是从 1 开始的，而不是像 Java 或 Python 那样从 0 开始。

2.NULL 值陷阱：在使用 CONCAT 拼接时，如果其中任何一个参数是 NULL，在很多数据库（如 MySQL）中整个结果都会变成 NULL。

 _解决方法_：使用 `CONCAT_WS`（可以指定分隔符并跳过空值）。

3.多字节字符（中文）：有些数据库的 SUBSTR 是按字符截取，有些是按字节截取。在 MySQL 中，SUBSTR 通常按字符截取，非常友好。

数值函数

函数	功能	示例代码块
CEIL(x)	向上取整（返回大于等于 x 的最小整数）	`SELECT CEIL(1.1);` → `2`
FLOOR(x)	向下取整（返回小于等于 x 的最大整数）	`SELECT FLOOR(1.9);` → `1`
MOD(x, y)	取模（返回 x 除以 y 的余数）	`SELECT MOD(10, 3);` → `1`
RAND()	随机数（返回 0~1 之间的随机浮点数）	`SELECT RAND();`
ROUND(x, y)	四舍五入（对 x 求值，保留 y 位小数）	`SELECT ROUND(2.345, 2);` → `2.35`
ABS(x)	绝对值	`SELECT ABS(-5);` → `5`

SQL

Sat, 28 Mar 2026 00:00:00 +0000

本文更新于 2026-03-28

基础书写规则

分号结束：每条 SQL 语句通常以分号 ; 结尾（虽然某些单条执行环境不强制，但在脚本中是必需的）。
不区分大小写：SQL 关键字（如 SELECT, FROM）不区分大小写，但为了代码可读性，习惯上关键字大写，表名和列名小写。
- 推荐写法： SELECT name FROM users;
空格与缩进：SQL 对空格和换行不敏感。合理的缩进能显著提高代码的可读性。
注释规范：
- 单行注释：-- 注释内容 或 # 注释内容（仅限 MySQL）。
- 多行注释：/* 注释内容 */。

缩写	全称	操作对象	常用动词	场景示例
DDL	`Definition`	表结构/数据库	`CREATE`, `DROP`	“建个名为‘用户’的表”
DML	`Manipulation`	行记录	`INSERT`, `UPDATE`	“把小明的年龄改成18”
DQL	`Query`	数据结果集	`SELECT`	“找出所有北京的用户”
DCL	`Control`	权限/安全	`GRANT`, `REVOKE`	“允许小李查看工资表”

数据类型

整型

类型名称	取值范围	大小
`TINYINT`	-128〜127	1个字节
`SMALLINT`	-32768〜32767	2个宇节
`MEDIUMINT`	-8388608〜8388607	3个字节
`INT` (`INTEGER`)	-2147483648〜2147483647	4个字节
`BIGINT`	-9223372036854775808〜9223372036854775807	8个字节

无符号在数据类型后加 unsigned 关键字。

浮点型

类型名称	说明	存储需求
`FLOAT`	单精度浮点数	4 个字节
`DOUBLE`	双精度浮点数	8 个字节
`DECIMAL` (`M`, `D`)，`DEC`	压缩的“严格”定点数	`M`+2 个字节

日期和时间

类型名称	日期格式	日期范围	存储需求
`YEAR`	`YYYY`	1901 ~ 2155	1 个字节
`TIME`	`HH`:`MM`:`SS`	-838:59:59 ~ 838:59:59	3 个字节
`DATE`	`YYYY`-`MM`-`DD`	1000-01-01 ~ 9999-12-3	3 个字节
`DATETIME`	`YYYY`-`MM`-`DD` `HH`:`MM`:`SS`	1000-01-01 00:00:00 ~ 9999-12-31 23:59:59	8 个字节
`TIMESTAMP`	`YYYY`-`MM`-`DD` `HH`:`MM`:`SS`	1980-01-01 00:00:01 `UTC` ~ 2040-01-19 03:14:07 `UTC`	4 个字节

字符串

类型名称	说明	存储需求
`CHAR`(`M`)	固定长度非二进制字符串	`M` 字节，1<=`M`<=255
`VARCHAR`(`M`)	变长非二进制字符串	`L`+1字节，在此，`L` <= `M`和 1<=`M`<=255
`TINYTEXT`	非常小的非二进制字符串	`L`+1字节，在此，`L`<2^8
`TEXT`	小的非二进制字符串	`L`+2字节，在此，`L`<2^16
`MEDIUMTEXT`	中等大小的非二进制字符串	`L`+3字节，在此，`L`<2^24
`LONGTEXT`	大的非二进制字符串	`L`+4字节，在此，`L`<2^32
`ENUM`	枚举类型，只能有一个枚举字符串值	1或2个字节，取决于枚举值的数目 (最大值为65535)
`SET`	一个设置，字符串对象可以有零个或多个`SET`成员	1、2、3、4或8个字节，取决于集合成员的数量（最多64个成员）

二进制类型

类型名称	说明	存储需求
`BIT`(`M`)	位字段类型	大约 (`M`+7)/8 字节
`BINARY`(`M`)	固定长度二进制字符串	`M` 字节
`VARBINARY` (`M`)	可变长度二进制字符串	`M`+1 字节
`TINYBLOB` (`M`)	非常小的`BLOB`	`L`+1 字节，在此，`L`<2^8
`BLOB` (`M`)	小 `BLOB`	`L`+2 字节，在此，`L`<2^16
`MEDIUMBLOB` (`M`)	中等大小的`BLOB`	`L`+3 字节，在此，`L`<2^24
`LONGBLOB` (`M`)	非常大的`BLOB`	`L`+4 字节，在此，`L`<2^32

DDL

CREATE（创建）

用于建立新的数据库对象。

-- 创建一个名为 users 的表
CREATE TABLE users (
 id INT PRIMARY KEY AUTO_INCREMENT, -- 主键，自动增长
 username VARCHAR(50) NOT NULL, -- 不允许为空
 email VARCHAR(100) UNIQUE, -- 唯一约束
 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP -- 默认值
);

ALTER（修改）

用于修改现有的表结构，例如增加新列、更改数据类型或重命名。

1.添加字段

ALTER TABLE 表名 ADD 字段名类型（长度） [comment] [约束];
2.修改数据类型

ALTER TABLE MODIFY 字段名新数据类型（长度）;
3.修改字段名和字段类型

ALTER TABLE　表名　CHANGE　旧字段名　新字段名　类型（长度）[comment][约束];
4.删除字段

ALTER TABLE 表名 DROP 字段名;
5.修改表名

ALTER TABLE 表名 RENAME TO 新表名

-- 在 users 表中增加一行“手机号”
ALTER TABLE users ADD phone_number VARCHAR(20);

-- 修改字段类型
ALTER TABLE users MODIFY COLUMN username VARCHAR(100);

-- 删除某一列
ALTER TABLE users DROP COLUMN email;

DROP（删除）

将整个对象从数据库中彻底抹去。

-- 删除整个 users 表（结构和数据全部消失）
DROP TABLE users;

-- 删除整个数据库
DROP DATABASE my_app;

TRUNCATE（清空）

用于删除表中的所有数据，但保留表结构。

与 DELETE 的区别：DELETE 是一行行删，速度慢；TRUNCATE 是直接销毁表并重建一个空的，速度极快且不记录逐行日志。

TRUNCATE TABLE users;

DML

DML 主要由三个核心关键字组成：INSERT（增）、UPDATE（改）、DELETE（删）。

INSERT (插入数据)

用于向表中添加新行。

指定列插入：（推荐，更安全）

	INSERT INTO 表名 (字段名1, 字段名2, ...) VALUES (值1, 值2, ...);
	
	INSERT INTO users (username, age, email) 
	VALUES ('张三', 25, 'zhangsan@example.com');

全列插入：（必须按表结构顺序提供所有值）

	INSERT INTO 表名 VALUES (值1, 值2, ...);

	INSERT INTO users VALUES (NULL, '李四', 30, 'lisi@example.com', NOW());

批量插入：

 -- 指定字段的批量插入（推荐）
	INSERT INTO 表名 (字段名1, 字段名2, ...) 
	VALUES 
		(值1, 值2, ...),
		(值1, 值2, ...),
		(值1, 值2, ...);
	
	INSERT INTO student (name, age, gender) 
	VALUES 
		('张三', 20, '男'),
		('李四', 19, '女'), 
		('王五', 21, '男');
	
	-- 省略字段的批量插入(所有字段)
	INSERT INTO 表名 
	VALUES 
		(值1, 值2, ...),
		(值1, 值2, ...),
		(值1, 值2, ...);
		
	INSERT INTO student
	VALUES
	 (4, '赵六', 20, '男'),
	 (5, '钱七', 18, '女');

[!IMPORTANT]

添加数据时，字段名与值的顺序、个数必须一一对应。

字符串类型和日期类型的值，需要包含在引号中。

插入的数据必须在字段允许的范围之内。

UPDATE (更新数据)

用于修改表中已存在的记录。

关键点： 永远不要忘记 WHERE 子句，否则全表数据都会被修改！

	
	UPDATE 表名 SET 字段名1 = 值1, 字段名2 = 值2, ... [WHERE 条件];

	UPDATE users SET age = 26, email = 'san_new@example.com' 
	WHERE username = '张三'; -- 只更新张三的数据

[!NOTE] 注意:修改语句的条件可以有，也可以没有，如果没有条件，则会修改整张表的所有数据。

DELETE (删除数据)

用于删除表中的特定行。

关键点： 同样必须配合 WHERE 使用，否则会清空整个表的数据。

	DELETE FROM 表名 [WHERE 条件];


 DELETE FROM users 
 WHERE id = 101; -- 删除 ID 为 1

[!NOTE]

DELETE 语句的条件可以有，也可以没有，如果没有条件，则会删除整张表的所有数据。

DELETE 语句不能删除某一个字段的值（可以使用 UPDATE）。

对比

维度	DELETE (DML)	TRUNCATE (DDL)
底层逻辑	逐行扫描与标记。像“精细手术”，逐条检查并标记删除。	数据页释放。像“拆迁重建”，直接解除数据页与表的映射。
事务日志 (Logging)	全额记录。记录每一行数据的变化，以便回滚。	最小化记录。仅记录页面释放的操作，日志开销极小。
执行速度	慢。随着数据量增加，性能呈线性下降。	极快。无论数据量是 1 万还是 1 亿，耗时基本一致。
空间回收 (HWM)	不释放。高水位线（High Water Mark）不变，表占用的物理空间不减小。	立即释放。重置高水位线，将空间还给表空间/操作系统。
自增列 (Identity)	不重置。删除后插入新数据，ID 会接着原来的序号递增。	重置。将自增计数器恢复到初始状态（通常是 1）。
触发器 (Triggers)	激活。每一行被删除时都会触发对应的 `DELETE` 触发器。	忽略。不会激活任何触发器，因为不进行逐行操作。
WHERE 子句	支持。可以精确删除某一部分符合条件的数据。	不支持。只能“一锅端”，清空整个表。
回滚能力 (Rollback)	支持。在未提交的事务中可以完全撤销。	视数据库而定。MySQL 等多数库不支持，PostgreSQL/SQL Server 支持。
外键约束	支持。受外键约束限制，若有关联数据会报错。	受限。如果表被外键引用，通常必须先删除外键才能执行。
锁机制	行级锁。执行时只锁定被操作的行，并发性较高。	表级锁。执行时通常会锁定整张表，阻止其他访问。

什么时候必须用 `DELETE`？

需要根据特定条件（如 status = 'expired'）删除数据时。
当你需要依赖 事务安全性（即如果操作失败，必须能撤回所有更改）时。
表中有复杂的 触发器 逻辑需要维持数据的一致性或审计。

什么时候必须用 `TRUNCATE`？

清理日志表/临时表：当数据已经过期且量级巨大（百万、千万级以上）时。
重置环境：在开发测试阶段，希望快速清空表并让自增主键归零。
优化存储：当表删除大量数据后，物理空间依然占用过高，需要通过 TRUNCATE 彻底释放磁盘空间。

DQL

基本查询

设置别名(别名会在表头显示)

	SELECT 字段1 [AS 别名1], 字段2 [AS 别名2] ... FROM 表名;

	-- 使用 AS 给列起中文名
	SELECT name, age AS '年龄' FROM users; 
	
	-- 直接空格加别名
	SELECT name '姓名', entrydate '入职日期' FROM emp;

**去除重复记录 **(DISTINCT)

	SELECT DISTINCT 字段列表 FROM 表名;
	
	-- 查询公司有哪些不同的工作岗位 单字段去重
	SELECT DISTINCT job FROM emp;
	
	-- 只有当 job 和 dept 同时相同时才会被去重 多字段去重
	SELECT DISTINCT job, dept FROM emp;

条件查询

语法

	SELECT 字段列表 FROM 表名 WHERE 条件列表;

条件

比较运算符

运算符	功能描述	示例代码块
`>`, `>=`, `<`, `<=`	大于、大于等于、小于、小于等于	`WHERE age >= 18`
`=`, `<>` 或 `!=`	等于、不等于	`WHERE job != '经理'`
BETWEEN … AND …	在范围内（含最小值和最大值）	`WHERE age BETWEEN 20 AND 30`
IN(…)	在指定的集合/列表中，多选一	`WHERE city IN ('北京', '上海', '广州')`
LIKE 占位符	模糊匹配（`_` 匹配单个字符，`%` 匹配任意字符）	`WHERE name LIKE '张%'` (姓张的)
IS NULL	判断值是否为空	`WHERE email IS NULL`

逻辑运算符

运算符	功能描述	示例代码块
AND 或 `&&`	并且（多个条件必须同时成立）	`WHERE age > 18 AND gender = '女'`
OR 或 `		`
NOT 或 `!`	非、不是（取反）	`WHERE age NOT BETWEEN 20 AND 30`

聚合函数

常见聚合函数

函数	功能	示例代码
COUNT()	统计数量（行数）	`SELECT COUNT(*) FROM emp;`
SUM()	求和	`SELECT SUM(salary) FROM emp;`
AVG()	求平均值	`SELECT AVG(salary) FROM emp;`
MAX()	求最大值	`SELECT MAX(age) FROM emp;`
MIN()	求最小值	`SELECT MIN(age) FROM emp;`

基础语法

聚合函数通常直接紧跟在 SELECT 之后：

	SELECT 聚合函数(字段列表) FROM 表名 [WHERE 条件];

聚合函数注意点：

NULL 值被忽略：所有的聚合函数（尤其是 COUNT, AVG, SUM）都会自动忽略 NULL 值。

_例子_：如果 10 个人里有 2 个人没发工资（NULL），`AVG(salary)` 的结果是 `总工资 / 8`，而不是除以 10。

WHERE 的限制：聚合函数不能直接写在 WHERE 子句中。

_错误写法_：`SELECT * FROM emp WHERE salary > AVG(salary);` (这是初学者最容易犯的错)。

正确做法：需要使用子查询或使用 HAVING。

单值输出：聚合函数的结果是一个单行单列的数值。除非配合 GROUP BY，否则不能在 SELECT 中同时查询聚合函数和普通字段（如 SELECT name, COUNT(*) 在大多数数据库中是逻辑错误的）。

分组查询

基本查询

	SELECT 字段列表 FROM 表名 [WHERE 条件] GROUP BY 分组字段名 [HAVING 分组后过滤条件];
	
--	执行时机不同：where 是分组之前进行过滤，不满足 where 条件，不参与分组；而 having 是分组之后对结果进行过滤。
--	判断条件不同：where 不能对聚合函数进行判断，而 having 可以.
	WHERE > 聚合函数 > HAVING

注意点：

	-- 逻辑 1：统计行数（包含 NULL）
	-- 只要这一组有 2 行，哪怕地址全是空，结果也显示 2
	SELECT workaddress, COUNT(*) 
	FROM emp 
	GROUP BY workaddress 
	HAVING COUNT(*) >= 2;
	
	-- 逻辑 2：统计非空值数量
	-- 虽然这一组有 2 行（满足 HAVING），但由于这两行地址是 NULL，
	-- COUNT(workaddress) 统计不到任何非空值，结果显示 0
	SELECT workaddress, COUNT(workaddress) 
	FROM emp 
	GROUP BY workaddress 
	HAVING COUNT(*) >= 2;

排序查询

基本查询

	SELECT 字段列表 FROM 表名 [WHERE 条件] [GROUP BY 分组字段] [HAVING 过滤条件] ORDER BY 字段1 排序方式1, 字段2 排序方式2;
	
	ASC: 升序（默认值）
	DESC:降序
	
	-- 需求：查询所有员工信息，并按照年龄升序排序
	SELECT * FROM emp ORDER BY age ASC;
	
	-- 需求：查询所有员工，按入职时间降序排序（最近入职的在前）
	SELECT * FROM emp ORDER BY entrydate DESC;

多字段排序（二次排序）

	-- 需求：按照年龄升序排序；如果年龄相同，再按照入职时间降序排序
	SELECT * FROM emp ORDER BY age ASC, entrydate DESC;

[!NOTE] NULL：在 MySQL 中，NULL 被视为最小值 执行顺序：ORDER BY 是在 SELECT 之后执行的。这意味着你可以在 ORDER BY 中使用你在 SELECT 里起的别名。

分页查询

基础语法

	SELECT 字段列表 FROM 表名 LIMIT 起始索引, 查询记录数;

	-- 查询第一页 (前 10 条)
	-- 起始索引为 0 时，可以省略不写
	SELECT * FROM emp LIMIT 0, 10;
	-- 等价于：
	SELECT * FROM emp LIMIT 10;
	
	-- 查询第二页 (第 11-20 条)
	-- 从索引 10 开始（即第 11 条），往后查 10 条
	SELECT * FROM emp LIMIT 10, 10;
	
	-- 查询第三页 (第 21-30 条)
	SELECT * FROM emp LIMIT 20, 10;

计算公式: 起始索引 = (查询页码 - 1) * 每页显示记录数

例子：想看第 5 页，每页 10 条。
计算：(5 - 1) * 10 = 40。
SQL：SELECT * FROM emp LIMIT 40, 10;

另外注意点：

方言限制：LIMIT 是 MySQL 的方言。如果用的是 Oracle，需要用 ROWNUM；如果是 SQL Server，需要用 TOP
执行顺序：LIMIT 永远是 SQL 语句中最后执行的一个环节
大分页性能：当数据量达到百万级，LIMIT 1000000, 10 会变得很慢，因为数据库需要先扫描前 100 万条再丢弃，后续需要通过索引优化或子查询来解决

执行顺序 (逻辑顺序)

理解 DQL 的关键不在于怎么写，而在于数据库怎么读。书写顺序和执行顺序是不一样的：

	SELECT
	 字段列表 -- 5. 确定要显示的字段
	FROM
	 表名列表 -- 1. 确定去哪张表找
	WHERE
	 条件列表 -- 2. 第一次行过滤
	GROUP BY
	 分组字段列表 -- 3. 数据分组
	HAVING
	 分组后过滤条件 -- 4. 第二次组过滤
	ORDER BY
	 排序字段列表 -- 6. 对结果进行排序
	LIMIT
	 起始索引, 记录数; -- 7. 截取最终结果

执行步骤	关键字	作用
Step 1	FROM	确定去哪张表找数据。	表名列表
Step 2	WHERE	按照条件过滤原始行数据。	条件列表
Step 3	GROUP BY	将过滤后的数据分组（如按部门）。	分组字段列表
Step 4	HAVING	对分组后的结果再次进行过滤。	分组后条件列表
Step 5	SELECT	选出最终要显示的列。	字段列表
Step 6	ORDER BY	对最终结果进行排序。	排序字段列表
Step 7	LIMIT	限制显示的行数（分页）。	分页参数

DCL

管理用户

查询用户

	USE mysql;
	SELECT * FROM user;

创建用户

	CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码'; 
	
	
	-- 示例：创建一个只能在当前主机(localhost)登录的用户
	CREATE USER 'work_user'@'localhost' IDENTIFIED BY '123456';
	
	-- 示例：创建一个可以在任意主机(%)登录的用户
	CREATE USER 'remote_user'@'%' IDENTIFIED BY '123456';

修改/删除用户

	-- 修改用户密码 (MySQL 8.0+)
	ALTER USER 'work_user'@'localhost' 
	IDENTIFIED WITH mysql_native_password BY 'new_password';
	
	-- 删除用户
	DROP USER 'work_user'@'localhost';

权限控制

常用权限

权限名称	作用描述
SELECT	查询数据（最常用）
INSERT	插入新数据
UPDATE	修改现有数据
DELETE	删除现有数据
ALTER	修改表结构（如增加列）
DROP	删除表或数据库
CREATE	创建新表或数据库
ALL [PRIVILEGES]	所有权限（最高权限）

查询权限

	-- 查询指定用户的权限
	SHOW GRANTS FOR 'heima'@'localhost';

授予权限

	GRANT 权限列表 ON 数据库名.表名 TO '用户名'@'主机名';
	
	-- 1. 授予单个权限：允许用户查询 test 库中的 emp 表
	GRANT SELECT ON test.emp TO 'heima'@'localhost';
	
	-- 2. 授予多个权限：允许用户对 test 库所有表进行查询、插入、修改
	GRANT SELECT, INSERT, UPDATE ON test.* TO 'heima'@'localhost';
	
	-- 3. 授予所有权限：允许用户操作所有数据库的所有表（DBA 级别）
	GRANT ALL ON *.* TO 'admin'@'%';

撤销权限

	REVOKE 权限列表 ON 数据库名.表名 FROM '用户名'@'主机名';
	
	-- 撤回用户对 test 库所有表的插入(INSERT)权限
	REVOKE INSERT ON test.* FROM 'heima'@'localhost';
	
	-- 撤回所有权限
	REVOKE ALL ON *.* FROM 'admin'@'%';

Posts on Creat

基础知识拓展

基本语法

数组

索引

地址符:

数组默认动态初始化值：

Java内存分配

方法

方法是程序运行的最小执行单元(类似于c中的函数)

面向对象

面向对象

类和对象

封装

private关键字

就近原则和this关键字

成员变量和局部变量

构造方法

标准JavaBean

标准的Javabean类

Java内存分配

一些实例…

键盘录入:

字符串

字符串

String

创建String对象的两种方式

字符串的比较

equals 与 equalsIgnoreCase

遍历字符串

替换字符串

StringBulider

StringBuilder 常用方法

StringJoiner

StringJoiner 的构造方法

StringJoiner 的成员方法

字符串原理

补充内容

ArrList集合

集合

ArrayList

成员方法（增删改查）

基本数据类型对应的包装类

面向对象进阶

static（静态）

静态变量

静态方法

工具类

static的注意事项

内存的加载

main方法

继承

继承特点

在继承中 成员变量的访问特点

在继承中成员方法的访问特点

方法重写的本质

在继承中构造方法的访问特点

this 与 super

多态

多态调用成员变量的特点

包

final

权限修饰符

代码块

静态代码块

抽象类和抽象方法

接口

成员特点和接口中的各种关系

接口和类的关系

接口中的默认方法

接口中默认方法的注意事项

接口中的静态方法

接口的应用（接口多态）

适配器设计模式

内部类

成员内部类

静态内部类

局部内部类（了解）

匿名内部类**

接口（实现关系）

在继承中成员变量的访问特点