add logseq-java

2024-02-02 00:12:49 +08:00
parent 1cd5bb460f
commit c7947017c3
875 changed files with 57100 additions and 0 deletions
--- a/logseq-java/logseq/bak/journals/2022_03_28/2022-04-01T01_14_49.508Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_28/2022-04-01T01_14_49.508Z.md
@@ -0,0 +1,31 @@
+- ## [[蜗牛java培训笔记]]
+- 学习阶段
+	- 第一阶段
+		- 重点：JavaSE 集合 数据库 Mybatis
+		- 个人项目
+	- 第二阶段
+		- 重点 SSM SpringBoot
+		- 个人项目
+	- 第三阶段
+		- 重点 Linux Redis ES全文检索引擎 前后端分离开发
+		- 团队项目简历项目
+	- 第四阶段
+		- 重点 SpringCloud Alibaba RabbitMQ服务器 分布式事务
+		- 团队项目简历项目
+- 上课模式
+	- 不用PPT 笔记代码纯手打，画图现画
+	- 上课时间 45min 休息10min
+- 整理笔记
+	- 一个知识点一个笔记
+	- 每个笔记包含
+		- 笔记名称（重要程度：低中高）
+		- 课程目标
+		- 课程内容
+		- 课程小结
+- 课程资料
+	- 视频15min范围内
+		- 20220328-01-知识点名称(一)
+		- 20220328-01-知识点名称(二)
+		- 20220328-01-知识点名称(三)
+	- [课程视频](https://www.woniuxy.com/book/)
+	- [预习资料](https://www.woniuxy.com/book/)
--- a/logseq-java/logseq/bak/journals/2022_03_28/2022-04-07T14_01_46.249Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_28/2022-04-07T14_01_46.249Z.md
@@ -0,0 +1,32 @@
+### [[第一天 [[Mar 28th, 2022]]]]
+id:: c32dfd00-a428-41f7-b330-7d06e289dc90
+- 学习阶段
+	- 第一阶段
+		- 重点：JavaSE 集合 数据库 Mybatis
+		- 个人项目
+	- 第二阶段
+		- 重点 SSM SpringBoot
+		- 个人项目
+	- 第三阶段
+		- 重点 Linux Redis ES全文检索引擎 前后端分离开发
+		- 团队项目简历项目
+	- 第四阶段
+		- 重点 SpringCloud Alibaba RabbitMQ服务器 分布式事务
+		- 团队项目简历项目
+- 上课模式
+	- 不用PPT 笔记代码纯手打，画图现画
+	- 上课时间 45min 休息10min
+- 整理笔记
+	- 一个知识点一个笔记
+	- 每个笔记包含
+		- 笔记名称（重要程度：低中高）
+		- 课程目标
+		- 课程内容
+		- 课程小结
+- 课程资料
+	- 视频15min范围内
+		- 20220328-01-知识点名称(一)
+		- 20220328-01-知识点名称(二)
+		- 20220328-01-知识点名称(三)
+	- [课程视频](https://www.woniuxy.com/book/)
+	- [预习资料](https://www.woniuxy.com/book/)
--- a/logseq-java/logseq/bak/journals/2022_03_28/2022-04-19T01_19_35.129Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_28/2022-04-19T01_19_35.129Z.md
@@ -0,0 +1,68 @@
+- [[计算机基础理论]]
+  collapsed:: true
+	- 课堂总结
+		- 1. 硬件&软件
+		  2. 软件
+		  3. 编程语言
+- [[DOS命令]]
+- [[windows快捷键]]
+  collapsed:: true
+	- 课堂总结
+		- 1. 打开DOS
+		  2. DOS命令
+		  3. 快捷键
+- [[Java发展历程]]
+  collapsed:: true
+	- 课堂总结
+		- 1. JDK里程版本
+		  2. Java三个开发方向：桌面，手机，企业/互联网
+		  3. Java语言特点
+		      简单...
+		  4. JDK>JRE>JVM
+- [[JDK环境搭建]]
+  collapsed:: true
+	- 课堂小结
+		- 变量配置
+			- JAVA_HOME
+			- Path
+			- CLASSPATH
+		- 编译javac
+		- 运行java
+- [[HelloWorld详解]]
+  collapsed:: true
+	- 课堂小结
+		- Java编写执行:编译-->解释
+		- 编译:源代码-->Class字节码
+		- 解释:将Class字节码中信息解释为01二进制信息给JVM执行
+		- 编译javac.exe执行
+		  解释java.exe执行
+- 学习阶段
+	- 第一阶段
+		- 重点：JavaSE 集合 数据库 Mybatis
+		- 个人项目
+	- 第二阶段
+		- 重点 SSM SpringBoot
+		- 个人项目
+	- 第三阶段
+		- 重点 Linux Redis ES全文检索引擎 前后端分离开发
+		- 团队项目简历项目
+	- 第四阶段
+		- 重点 SpringCloud Alibaba RabbitMQ服务器 分布式事务
+		- 团队项目简历项目
+- 上课模式
+	- 不用PPT 笔记代码纯手打，画图现画
+	- 上课时间 45min 休息10min
+- 整理笔记
+	- 一个知识点一个笔记
+	- 每个笔记包含
+		- 笔记名称（重要程度：低中高）
+		- 课程目标
+		- 课程内容
+		- 课程小结
+- 课程资料
+	- 视频15min范围内
+		- 20220328-01-知识点名称(一)
+		- 20220328-01-知识点名称(二)
+		- 20220328-01-知识点名称(三)
+	- [课程视频](https://www.woniuxy.com/book/)
+	- [预习资料](https://www.woniuxy.com/book/)
--- a/logseq-java/logseq/bak/journals/2022_03_29/2022-04-07T14_01_46.295Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_29/2022-04-07T14_01_46.295Z.md
@@ -0,0 +1 @@
+- ### [[第二天 [[Mar 29th, 2022]]]]
--- a/logseq-java/logseq/bak/journals/2022_03_30/2022-04-07T14_01_46.315Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_30/2022-04-07T14_01_46.315Z.md
@@ -0,0 +1 @@
+- ### [[第三天[[Mar 30th, 2022]]]]
--- a/logseq-java/logseq/bak/journals/2022_03_31/2022-04-07T14_01_46.327Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_31/2022-04-07T14_01_46.327Z.md
@@ -0,0 +1 @@
+- ((62443d8f-0b57-4183-9c26-4d6c709a7e0d))
--- a/logseq-java/logseq/bak/journals/2022_03_31/2022-04-19T01_19_37.388Z.md
+++ b/logseq-java/logseq/bak/journals/2022_03_31/2022-04-19T01_19_37.388Z.md
@@ -0,0 +1,97 @@
+- [[位运算符]]
+- [[逻辑运算符]]
+- [[IF判断]]
+- [[嵌套判断]]
+- [[switch]]
+- [[while循环]]
+- [[for循环]]
+- [[do while 循环]]
+-
+- ## 总结
+  collapsed:: true
+	- 位运算符
+		- & | ^的两侧可以放置数值,也可以放布尔表达式
+		- 按位与 &
+			- 按照二进制比较,同为1则为1,否则为0
+		- 按位或 |
+			- 按照二进制比较,有1就是1,否则为0
+		- 异或 ^
+			- 按照二进制比较,01的结果为1,11和00都是0
+		- 取反 ~
+			- 将二进制0变成1,1变成0
+	- 移位运算
+		- << 表示将数字的二进制整体向左移动
+		- \>> 表示将数字的二进制整体向右移动,原本符号不变
+		- \>>> 表示将数字的二进制整体向右移动,不考虑符号
+	- 逻辑运算符
+		- 两侧只能放布尔表达式
+		- 逻辑与 &&
+			- 两个都为true式整个结果才是true
+			- 短路与,前面表达式为false时,后面表达式不会执行
+		- 逻辑或 ||
+			- 两个只要有true,整个结果就是true
+			- 短路与,前面表达式为true时,后面表达式不会执行
+		- 逻辑非 !
+			- 假变真,真变假
+	- IF逻辑判断
+		- Java代码执行顺序
+			- 从上至下,从左至右
+		- IF流程控制
+			- 单分支
+				- ```java
+				  if(布尔表达式){
+				    //代码
+				  }
+				  ```
+			- 双分支
+				- ```java
+				  if(布尔表达式){
+				      //代码1
+				  }else{
+				      //代码2
+				  }
+				  ```
+		- 三目运算符
+			- if双分支的简写
+			- ```java
+			  数据类型 变量 = (布尔表达式)? 值1 : 值2;
+			  ```
+		- 多分支和嵌套
+			- 当要判断的条件很多时,嵌套判断阅读维护性差
+			- 多分支
+				- ```java
+				  if(布尔表达式1){
+				      //代码1
+				  }else if(布尔表达式2){
+				      //代码2
+				  }else if(布尔表达式3){
+				       //代码3
+				  }……{
+				  }else{
+				      //代码n
+				  }
+				  ```
+		- switch
+			- switch与if区别在于switch判断的是几个固定的值
+			- ```java
+			  int num = 值;
+			  switch(num){
+			      case 值1:
+			          //代码1
+			      break;
+			      case 值2:
+			          //代码2
+			      break;    
+			      case 值3:
+			          //代码3
+			      break;   
+			      ……    
+			      default:
+			          //默认语句代码
+			      break;      
+			  }
+			  ```
+	-
+	-
+-
+	-
--- a/logseq-java/logseq/bak/journals/2022_04_01/2022-04-07T14_01_46.329Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_01/2022-04-07T14_01_46.329Z.md
@@ -0,0 +1,2 @@
+- day4
+- Apr 1st, 2022
--- a/logseq-java/logseq/bak/journals/2022_04_04/2022-04-19T01_19_37.391Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_04/2022-04-19T01_19_37.391Z.md
@@ -0,0 +1,19 @@
+- [[格式化输出]]
+- [[数组排序]]
+- [[多维数组]]
+- [[命令行参数]]
+- [[面向对象编程]]
+- [[方法]]
+- [[构造方法]]
+- [[方法重载]]
+- [[继承]]
+- [[多态]]
+- [[抽象类]]
+- [[接口]]
+- [[静态字段]]
+- [[静态方法]]
+- [[包]]
+- [[作用域]]
+- [[classpath]]
+- [[jar]]
+- [[模块]]
--- a/logseq-java/logseq/bak/journals/2022_04_04/2022-07-07T01_32_54.205Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_04/2022-07-07T01_32_54.205Z.md
@@ -0,0 +1,17 @@
+- [[格式化输出]]
+- [[数组排序]]
+- [[多维数组]]
+-
+- [[方法]]
+-
+- [[继承]]
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
--- a/logseq-java/logseq/bak/journals/2022_04_05/2022-04-19T01_19_37.394Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_05/2022-04-19T01_19_37.394Z.md
@@ -0,0 +1,16 @@
+- [[命令行参数]]
+- [[面向对象编程]]
+- [[方法]]
+- [[构造方法]]
+- [[方法重载]]
+- [[继承]]
+- [[多态]]
+- [[抽象类]]
+- [[接口]]
+- [[静态字段]]
+- [[静态方法]]
+- [[包]]
+- [[作用域]]
+- [[classpath]]
+- [[jar]]
+- [[模块]]
--- a/logseq-java/logseq/bak/journals/2022_04_05/2022-07-07T01_32_54.209Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_05/2022-07-07T01_32_54.209Z.md
@@ -0,0 +1,12 @@
+- [[命令行参数]]
+-
+- [[方法]]
+- [[继承]]
+-
+-
+- [[静态方法]]
+-
+-
+-
+- [[jar]]
+- [[模块]]
--- a/logseq-java/logseq/bak/journals/2022_04_06/2022-04-19T01_19_37.399Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_06/2022-04-19T01_19_37.399Z.md
@@ -0,0 +1,25 @@
+- [[面向对象编程]]
+- [[面向对象的定义]]
+  id:: 624d850f-e491-432e-9d59-15f986d5ec41
+- [[类和对象的创建]]
+- [[数组排序]]
+- [[数组内存分析]]
+- 总结
+  collapsed:: true
+	- 数组的排序
+		- 获取数组的最值
+			- 定义最值为数组第一个，for循环遍历比较，使用中间变量交换最值
+		- 查询数组中的元素
+		- 数组反转
+			- 交换元素中从头开始和从尾开始对应的元素
+		- 冒泡排序
+			- 两两比较，并交换位置
+		- 选择排序
+			- 通过比较确定最值的下标，并在比较结束后交换最值的位置
+	- 数组内存分析
+		- 数组内存
+			- 数组为自定义变量，在栈中存储的是内存中的地址
+			- 当给一个数组重新定义时，会改变栈中指向堆中的地址，原来的数据失去引用会被回收
+		- 常见错误
+			- 下标越界：下标超出程序中数组的下标范围
+			- 空指针：数组没有具体存储空间
--- a/logseq-java/logseq/bak/journals/2022_04_06/2022-07-07T01_32_54.212Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_06/2022-07-07T01_32_54.212Z.md
@@ -0,0 +1,30 @@
+- [[面向对象]]
+- id:: 624d850f-e491-432e-9d59-15f986d5ec41
+- [[类和对象的创建]]
+- [[数组排序]]
+- [[数组内存分析]]
+-
+-
+-
+-
+-
+-
+- 总结
+  collapsed:: true
+	- 数组的排序
+		- 获取数组的最值
+			- 定义最值为数组第一个，for循环遍历比较，使用中间变量交换最值
+		- 查询数组中的元素
+		- 数组反转
+			- 交换元素中从头开始和从尾开始对应的元素
+		- 冒泡排序
+			- 两两比较，并交换位置
+		- 选择排序
+			- 通过比较确定最值的下标，并在比较结束后交换最值的位置
+	- 数组内存分析
+		- 数组内存
+			- 数组为自定义变量，在栈中存储的是内存中的地址
+			- 当给一个数组重新定义时，会改变栈中指向堆中的地址，原来的数据失去引用会被回收
+		- 常见错误
+			- 下标越界：下标超出程序中数组的下标范围
+			- 空指针：数组没有具体存储空间
--- a/logseq-java/logseq/bak/journals/2022_04_07/2022-04-19T01_19_37.401Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_07/2022-04-19T01_19_37.401Z.md
@@ -0,0 +1,72 @@
+- [[属性与方法]]
+- [[传参]]
+- [[调试]]
+- [[方法的重载]]
+- [[面向对象的定义]]
+- 总结
+	- 参数的传参
+		- 方法的定义
+			- 主函数
+			  ```java
+			  public static void main(String[] args){
+			      //主函数的代码
+			  }
+			  ```
+			- 定义方法
+			  ```java
+			  访问修饰符 static 返回类型 方法的方法名(参数列表){
+			      //方法的代码块
+			  }
+			  ```
+			- 参数列表：数据类型 参数名, 数据类型 参数名,数据类型 参数名……
+		- 分类
+			- 有参有返回
+			- 有参无返回
+			- 无参有返回
+			- 无参无返回
+		- 如果知道一个方法,需要传递什么参数?
+			- 方法在完成业务时,需要外部提供什么,就定义什么
+	- 调试Debug
+		- F5
+			- 进入断点方法内部
+		- F6
+			- 逐行执行代码,不进入方法内部
+		- F7
+			- 推出当前断电方法的内部
+		- F8
+			- 到达下一个断点
+	- 方法的重载
+		- 在同一个类中，相同的方法，不同的参数列表(参数的类型，参数的个数，参数的顺序)的方法
+	- 面向对象
+		- 面向过程
+			- 强调完成事务的过程,注重的是步骤
+		- 面向对象
+			- 在合适的时间找合适的人或物干对应的事情
+		- 万物皆对象
+			- 万物皆对象,但对象因我的关注而存在
+	- 类和对象
+		- 类是对大量对象的一种抽象,归纳
+		- 对象是类的一种具体实例
+		- 需要抽象对象的东西
+			- 属性
+				- 一大帮对象拥有的共同值,强调Has,是对对象的一种静态描述
+			- 行为
+				- 一大帮对象能干什么事,强调Do,是对对象的一种动态描述
+		- 创建类
+			- ```java
+			  访问修饰符 class 类的类名{
+			      //属性
+			      访问修饰符 数据类型 属性的名称;
+			      //行为
+			      访问修饰符 返回类型 方法的方法名称(参数列表){
+			            //    方法中的代码
+			          return 返回值;
+			      }
+			  }
+			  ```
+		- 创建对象
+			- new
+				- ```java
+				  类名 对象名 = new 类()
+				  ```
+-
--- a/logseq-java/logseq/bak/journals/2022_04_07/2022-07-07T01_32_54.215Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_07/2022-07-07T01_32_54.215Z.md
@@ -0,0 +1,79 @@
+-
+- [[传参]]
+- [[调试]]
+- [[方法重载]]
+- [[面向对象的定义]]
+-
+-
+-
+-
+-
+-
+- 总结
+  collapsed:: true
+	- 参数的传参
+		- 方法的定义
+			- 主函数
+			  ```java
+			  public static void main(String[] args){
+			      //主函数的代码
+			  }
+			  ```
+			- 定义方法
+			  ```java
+			  访问修饰符 static 返回类型 方法的方法名(参数列表){
+			      //方法的代码块
+			  }
+			  ```
+			- 参数列表：数据类型 参数名, 数据类型 参数名,数据类型 参数名……
+		- 分类
+			- 有参有返回
+			- 有参无返回
+			- 无参有返回
+			- 无参无返回
+		- 如果知道一个方法,需要传递什么参数?
+			- 方法在完成业务时,需要外部提供什么,就定义什么
+	- 调试Debug
+		- F5
+			- 进入断点方法内部
+		- F6
+			- 逐行执行代码,不进入方法内部
+		- F7
+			- 推出当前断电方法的内部
+		- F8
+			- 到达下一个断点
+	- 方法的重载
+		- 在同一个类中，相同的方法，不同的参数列表(参数的类型，参数的个数，参数的顺序)的方法
+	- 面向对象
+		- 面向过程
+			- 强调完成事务的过程,注重的是步骤
+		- 面向对象
+			- 在合适的时间找合适的人或物干对应的事情
+		- 万物皆对象
+			- 万物皆对象,但对象因我的关注而存在
+	- 类和对象
+		- 类是对大量对象的一种抽象,归纳
+		- 对象是类的一种具体实例
+		- 需要抽象对象的东西
+			- 属性
+				- 一大帮对象拥有的共同值,强调Has,是对对象的一种静态描述
+			- 行为
+				- 一大帮对象能干什么事,强调Do,是对对象的一种动态描述
+		- 创建类
+			- ```java
+			  访问修饰符 class 类的类名{
+			      //属性
+			      访问修饰符 数据类型 属性的名称;
+			      //行为
+			      访问修饰符 返回类型 方法的方法名称(参数列表){
+			            //    方法中的代码
+			          return 返回值;
+			      }
+			  }
+			  ```
+		- 创建对象
+			- new
+				- ```java
+				  类名 对象名 = new 类()
+				  ```
+-
--- a/logseq-java/logseq/bak/journals/2022_04_08/2022-07-07T01_32_54.218Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_08/2022-07-07T01_32_54.218Z.md
@@ -0,0 +1,91 @@
+- [[属性和行为]]
+- [[对象的内存模型分析]]
+- [[static]]
+- [[访问修饰符]]
+- [[this]]
+- [[getter与setter]]
+- [打字练习](https://github.com/Kaiyiwing/qwerty-learner)
+-
+-
+-
+-
+- 总结
+  id:: 624faffe-39f4-4020-9f12-39a039a8a618
+  collapsed:: true
+	- 属性和行为
+	  id:: 624fb005-9338-408d-9042-057369983bc9
+		- 属性的使用
+		  id:: 624fb021-f3cc-4cc9-b8e9-7041e05ef903
+			- 对象.属性
+			  id:: 624fb035-d5f0-45db-b52f-bab47d78d7aa
+		- 行为的使用
+		  id:: 624fb024-208d-48c5-8cfe-3032cee5f1d9
+			- 对象.行为
+			  id:: 624fb041-6174-4622-9a10-498d2d7fd57d
+	- 对象的内存模型
+	  id:: 62512765-08f0-4106-a64a-b64e16d1f202
+		- JVM内存分配
+		  id:: 62512770-0853-4244-ae3d-793aa9f81512
+			- 栈
+			  id:: 6251277a-226a-44a2-85ee-bf9bb5db25e5
+				- 用来存储方法的调用关系，以及方法内部的变量
+				  id:: 62512783-8b92-4702-8208-57139384662b
+			- 堆
+			  id:: 6251279d-e3c1-4454-805d-478eceaeecb7
+				- 放置使用new关键字创建出来的对象，全局动态字符串常量池
+				  id:: 625127a9-c892-492e-afaf-2ca61f481311
+			- 本地方法栈
+			  id:: 625127d6-fdcb-4f58-8b11-b43a0136d3a3
+				- 放置跟操作系统进行交互的本地方法
+				  id:: 625127df-acc1-4ab2-a351-d78fe5ae4296
+			- 程序计数器
+			  id:: 625127f3-4b2d-4351-ae12-9fcf6ae3db04
+				- 放置代码的执行顺序
+				  id:: 625127fd-6e4c-4c95-bc1d-d009ecc27e2f
+			- 元空间
+			  id:: 62512807-ee93-4f57-88e6-43b03c7cca0b
+				- 放置类的类对象
+				  id:: 62512813-5158-4785-ae45-d7ecb4c0b13e
+	- 对象的内存模型
+	  id:: 62512820-ddbf-427c-bbbb-5df3124a61cc
+	- static关键字
+	  id:: 62512837-668a-423e-9a0c-5a8844cb1c27
+		- 如果某个方法有写static，表示这个方法是一个静态方法，没有则是动态方法
+		  id:: 62512841-f8a7-4dfa-85ed-c314f65c66ba
+		- 如果一个方法不能和任何一个对象挂靠，那么这个方法就应该是个静态方法
+		  id:: 62512872-e7c9-491f-819e-61352e3ea925
+		- 静态方法的使用
+		  id:: 6251289b-4037-4a04-b61c-335032ae043c
+			- 通过类名.静态方法调用，也称类方法
+			  id:: 625128a4-904e-4e79-8be4-6df24b009c7d
+		- 静态方法和非静态方法的调用
+		  id:: 625128b6-23e5-405c-8f00-8d4630226c2e
+			- 静态方法不能直接调用非静态方法，可以直接调用静态方法
+			  id:: 625128eb-7774-4247-9d74-3a9f117d2803
+			- 非静态方法可以直接调用静态方法
+			  id:: 6251291d-2634-4cc7-880e-da2c02576d3f
+	- 访问修饰符
+	  id:: 6251293b-dde1-4786-9e7d-461977662314
+		- ((624ff0b4-39b0-4eef-9c71-0990589ca29a))
+		  id:: 6251296b-d185-4cc4-938d-63955c0d0237
+	- 封装
+	  id:: 62512971-334b-45d7-b0f9-735d5d0d2d6a
+		- 隐藏 private
+		  id:: 62512993-3596-47c6-b503-b4e17f70d632
+		- 包装 使用方法针对属性控制
+		  id:: 62512980-86af-43dc-983f-50a9a380b536
+		- 变量的二义性
+		  id:: 625129b8-349c-4fef-bdfe-14e8a70e488b
+	- this
+	  id:: 625129d9-78fa-47e5-880d-47eaa0c19b59
+		- 谁在调用this 所在方法，这个this 就是谁
+		  id:: 625129dd-b45d-4a50-9bae-5ef2fb5bbdde
+	- getter和setter
+	  id:: 625129e5-e317-48d6-b7f3-0acf62c247c1
+		- Setter方法 ： 专门用来修改对象的私有属性的值
+		  id:: 625129f1-475d-4d1b-b950-1392bd7c988a
+		- Getter 方法： 专门用来获得对象的私有属性的值
+		  id:: 625129fe-6918-4d7e-9211-d5620c7b7361
+		-
+		- id:: 62512953-95f2-44c4-aef3-8feebcb9e676
+		- id:: 62512943-6cf5-4c98-8c16-702d6edfb023
--- a/logseq-java/logseq/bak/journals/2022_04_12/2022-04-19T01_19_37.413Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_12/2022-04-19T01_19_37.413Z.md
@@ -0,0 +1,96 @@
+- [[final]]
+- [[抽象类]]
+- [[接口]]
+- [[多态]]
+-
+- 预习
+	- [[向上转型]]
+	- [[向下转型]]
+	- [[字符串]]
+	- [[String类]]
+	- [[StringBuilder]]
+	- [[StringBuffer]]
+	- [[Object类常用API]]
+	- [[Arrays]]
+	- [[System]]
+	- [[UUID]]
+	- [[Math]]
+	- [[random]]
+-
+-
+-
+- 总结
+	- final
+		- 最终的，最后的
+		- 修饰类
+			- 表示该类为最终类，不能被继承
+		- 修饰方法
+			- 表示该方法不能被子类重写
+		- 修饰变量
+			- 表示该量为一个常量
+	- 抽象类
+		- 具有抽象方法的类
+		- 当某一方法没有具体的实现案例时，此方法为一个抽象方法
+		- 不能被实例化，因为有方法不确定
+		- 抽象类中的抽象方法在子类中重写去实现
+		- 特点
+			- 具有抽象方法的类，一定是个抽象类
+			- 抽象类不一定具有抽象方法
+			- 抽象类通过abstract定义，并且抽象方法一定要在子类中实现
+			- 假如子类也实现不了这个方法，将子类也定义为抽象类
+			- 抽象类无法实例化
+		- 可放置的元素
+			- 抽象方法
+			- 非抽象方法
+			- 成员属性
+			- 构造器
+		- 面试题
+			- 抽象方法，可以定义成私有的不？
+				- 答：私有代表无法被重写，抽象方法是一定要子类重写！
+			- 抽象方法，可以定义为static的么？
+				- 答：static方法的调用方式：类名.方法名 意味着：这个方法一定有过实现；但是抽象方法实现了么？
+			- 抽象方法，可以定义为final的么？
+				- 答：final 定义在方法上，表示这个方法不能被重写；但是抽象方法一定需要子类重写！
+	- 接口
+		- 也是一种抽象，比抽象类还要抽象
+		- 作用：帮系统拓展新的功能
+		- 使用
+			- ```java
+			  public interface 接口的接口名{
+			    //需要拓展的功能
+			  }
+			  ```
+			- ```java
+			  访问修饰符 class 类的类名 extends 父类 implements 接口{
+			    //原有及接口拓展的功能
+			  }
+			  ```
+		- 特点
+			- 接口不能被实例化
+			- 接口中抽象方法，默认为publlic abstract
+			- 接口中抽象方法，必须要通过类给与实现
+			- 接口中的抽象方法，实现类可以变成抽象类，及可以实现接口中的方法
+			- 类只能单继承，但是接口可以多实现
+			- 类只能单继承，但是接口可以多继承
+	- 多态
+		- 多种形态
+		- > 相同的行为，不同的实现
+		- 静态多态
+			- 重载
+		- 动态多态
+			- 根据传入的对象不一样，调用相同的行为，拥有不同的实现
+		- 动态多态先决条件
+			- 必须要继承，必须要有方法的重写
+			- 父类的引用，可以指向子类的实现
+				- 父类的引用，看不到子类独有的东西
+				- 子类的引用，可以看到父类的东西，也可以看到自己独有的
+			- 动态绑定技术
+				- 父类的引用，指向不同子类的是实现，会自动调用对应子类的行为
+		- 用处
+			- 多态集合
+				- ```java
+				  Object[] objts = new Object[10];
+				  ```
+			- 多态参数
+				- 在一个方法中，将父类定为参数，调用的时候，传入对应子类的实现
+				- 由于多态的特点，做到：传入不同的子类，调用相同的行为，可以做到不同的实现
--- a/logseq-java/logseq/bak/journals/2022_04_13/2022-04-13T11_09_40.744Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_13/2022-04-13T11_09_40.744Z.md
@@ -0,0 +1,84 @@
+- [[向上转型与向下转型]]
+- [[面向对象的特征]]
+- [[静态代码块]]
+- [[实例代码块]]
+- [[Object类常用API]]
+- [[字符串概述]]
+-
+-
+- 总结
+	- 向上转型
+		- 基本数据类型的向上转型
+			- 隐式转换
+		- 引用数据类型的向上转型
+			- 只能发生在父子之间
+	- 向下转型
+		- 基本数据类型的向下转型
+			- 显式转换
+		- 引用数据类型的向上转型
+	- instanceof关键字
+		- 判断某一个对象是否是某一种类型的对象
+	- 面向对象的特征
+		- 封装
+		- 继承
+		- 抽象
+		- 多态
+	- 静态代码块
+		- 执行在类加载期间，先加载父类，后加载子类
+		- ```java
+		  static{
+		      //执行的代码
+		  }
+		  ```
+	- 实例代码块
+		- ```java
+		  {
+		      //执行的代码
+		  }
+		  ```
+	- Object类常用API
+		- API
+			- Application Programming Interface 应用编程接口
+			- 目的：
+				- 简化程序员的开发
+		- Object类
+			- 是所有Java类的超类，基类，父类。所以所有的类，都拥有它的方法
+			- toString
+				- 打印对象的内存地址
+				- toString的重写
+			- equals
+				- 比较2个对象，是否是同一个对象！
+				- == 在比较基本数据类型时，直接比较变量的值！
+				- == 在比较引用数据类型时，比较的是 地址值！
+				- equals的重写
+			- finalize
+		- IDEA生成API文档
+	- 字符串概述
+		- 字符串
+			- 将多个字符串到一起
+		- String
+			- String类型的字符串：长度固定，内容固定
+			- 字面量写法
+			- 通过new关键创建对象
+		- String常见方法
+			- [[indexOf()]]
+			- [[charAt()]]
+			- [[concat()]]
+			- [[contains()]]
+			- [[equals()]]
+				- 判断两字符串内容是否相同
+			- [[equalsIgnoreCase()]]
+			- [[startWith()]]
+			- [[endWith()]]
+			- [[getBytes()]]
+			- [[toCharArry()]]
+			- [[isEmpty()]]
+			- [[trim()]]
+			- [[split()]]
+			- [[substring()]]
+			- [[replace()]]
+			- [[lastIndexOf()]]
+			- [[toUpperCase()]]
+			- [[toLowerCase()]]
+			- [[valueOf()]]
+			- [[intern()]]
--- a/logseq-java/logseq/bak/journals/2022_04_20/2022-04-20T12_36_29.950Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_20/2022-04-20T12_36_29.950Z.md
@@ -0,0 +1,64 @@
+- [[TreeSet]]
+- [[HashMap]]
+- [[TreeMap]]
+- [[LinkedHashMap]]
+- [[HashTable]]
+- [[集合的交并差]]
+- [[IO流]]
+- [[字节流]]
+-
+-
+-
+- 总结
+	- TreeSet
+		- 红黑二叉树
+			- 所有节点要么红,要么黑
+			- 根节点一定为黑
+			- 红色节点的子节点,一定要为黑
+			- 从任何一种末梢子节点开始到根节点的过程中一定要有相同个数的黑色节点树
+		- {{embed ((625fe239-5548-4c66-ba66-f6fb1629b682))}}
+		- API方法与HashSet一致
+		- 排序借助ArrayList实现
+		- 去重
+			- 不依靠hashcode 以及equals
+			- 依靠比较器Comparable
+				- 元素一定要实现Comparable接口
+	- HashMap
+		- Map
+			- 基于Key-Vaalue的结构
+			- 特点
+				- Key不能重复
+				- Value可以重复
+		- 底层结构
+			- JDK1.7之前：数组 + 链表
+			- JDK1.7之后：数组 + 链表 + 红黑二叉树
+		- API方法
+			- put
+			- get
+			- replace
+			- delete
+			- deleteAll
+			- keySet
+			- values
+		- 去重
+			- 依靠hashcode和equals
+			- Key一定要重写 hashcode ，equals 方法
+		- 遍历
+			- forEach
+			- 获得Key的集合
+			- 通过Set集合获得每个元素
+	- TreeMap
+		- 特点
+			- Key去重,Value不去重
+	- LinkedHashMap
+		-
+	- HashTable
+		-
+	- 集合的交并差
+		- 交集
+		- 并集
+		- 差集
+	- IO流
+		- Input
+		- Out
+	- 字节流
--- a/logseq-java/logseq/bak/journals/2022_04_24/2022-07-07T01_32_54.221Z.md
+++ b/logseq-java/logseq/bak/journals/2022_04_24/2022-07-07T01_32_54.221Z.md
@@ -0,0 +1,2 @@
+- [[汽车租车系统]]
+-
--- a/logseq-java/logseq/bak/journals/2022_05_10/2022-05-10T07_01_57.796Z.md
+++ b/logseq-java/logseq/bak/journals/2022_05_10/2022-05-10T07_01_57.796Z.md
@@ -0,0 +1,4 @@
+- [[反射]]
+- [[Class]]
+- [[泛型]]的上下限
+	- List<? super>
--- a/logseq-java/logseq/bak/journals/2022_06_18/2022-07-07T01_32_54.224Z.md
+++ b/logseq-java/logseq/bak/journals/2022_06_18/2022-07-07T01_32_54.224Z.md
@@ -0,0 +1,3 @@
+- [[Spring]]
+- [[Feishu+Logseq]]
+-
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T01_41_26.647Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T01_41_26.647Z.Desktop.md
@@ -0,0 +1,20 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量，M越大，高度越低
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T01_59_07.092Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T01_59_07.092Z.Desktop.md
@@ -0,0 +1,43 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
+		- 范围查询大的时候需要返回根节点再次便利
+		- 存储了data信息，记录增多的时候树的高度会变高
+	- B+树
+		- 数据全部存在子节点中，非子节点只存储键值和指针
+		- 子节点之间添加链表结构，解决范围查询时需要返回根节点
+		- 范围查询效率提高很多，单个查询比B+树提高不大
+- 那些情况适合建立索引，那些不适合建立索引
+	- 频繁使用where
+	- 分组字段，分组的前提为排序
+	- 统计字段
+		- 加了索引不需要产生中间表去重
+	- 频繁更新字段
+	- 数据单一固定
+	- 数据量大(数据类型text)
+	- where条件不怎么用的
+- 索引分类，最左前缀，聚簇索引
+	- 主键索引
+		- 唯一
+	- 唯一索引
+	- 普通索引
+	- 联合索引
+	- 最左前缀
+		- 第一个值为从小到大
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T02_35_30.202Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T02_35_30.202Z.Desktop.md
@@ -0,0 +1,60 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
+		- 范围查询大的时候需要返回根节点再次便利
+		- 存储了data信息，记录增多的时候树的高度会变高
+	- B+树
+		- 数据全部存在子节点中，非子节点只存储键值和指针
+		- 子节点之间添加链表结构，解决范围查询时需要返回根节点
+		- 范围查询效率提高很多，单个查询比B+树提高不大
+- 那些情况适合建立索引，那些不适合建立索引
+	- 频繁使用where
+	- 分组字段，分组的前提为排序
+	- 统计字段
+		- 加了索引不需要产生中间表去重
+	- 频繁更新字段
+	- 数据单一固定
+	- 数据量大(数据类型text)
+	- where条件不怎么用的
+- 索引分类，最左前缀，聚簇索引
+	- 主键索引
+	- 唯一索引(一级索引)
+	- 普通索引(二级索引)
+	- 联合索引(需要符合最左前缀原则)
+	- 最左前缀
+		- 第一个值为从小到大排序，第二个不是
+		- 第一个值确定的情况下，第二个值是有序的
+		- 从最左边开始连续的索引都可以匹配上，直到遇到范围查询，> < between
+		- 已经排序好的字段是会生效的，
+			- a=1 and b>1 ab都会生效
+			- a>1 and b=1 b索引会失效，a>1 时b为无序的
+	- MyISAM和InnoDB数据结构
+		- MYD数据 MYI索引
+		- ibd数据和索引，读一个文件速度更快
+	- 聚簇索引
+		- 根据主键索引可以直接拿到数据，索引和数据放在一起
+		- InnoDB
+			- 定义主键为聚簇索引
+			- 未定义索引，选择第一个部位null唯一索引
+			- 以上都没用，使用一个6字节长整型的隐式字段ROWID字段构建聚簇索引，该RPWID字段会在插入新行时自动递增
+	- 非聚簇索引(辅助索引)
+		- 除聚簇索引外
+		- 只存储主键ID
+		- 查询可能需要回表，通过辅助索引查询得到ID去
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T02_47_04.702Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T02_47_04.702Z.Desktop.md
@@ -0,0 +1,73 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
+		- 范围查询大的时候需要返回根节点再次便利
+		- 存储了data信息，记录增多的时候树的高度会变高
+	- B+树
+		- 数据全部存在子节点中，非子节点只存储键值和指针
+		- 子节点之间添加链表结构，解决范围查询时需要返回根节点
+		- 范围查询效率提高很多，单个查询比B+树提高不大
+- 那些情况适合建立索引，那些不适合建立索引
+	- 频繁使用where
+	- 分组字段，分组的前提为排序
+	- 统计字段
+		- 加了索引不需要产生中间表去重
+	- 频繁更新字段
+	- 数据单一固定
+	- 数据量大(数据类型text)
+	- where条件不怎么用的
+- 索引分类，最左前缀，聚簇索引
+	- 主键索引
+	- 唯一索引(一级索引)
+	- 普通索引(二级索引)
+	- 联合索引(需要符合最左前缀原则)
+	- 最左前缀
+		- 第一个值为从小到大排序，第二个不是
+		- 第一个值确定的情况下，第二个值是有序的
+		- 从最左边开始连续的索引都可以匹配上，直到遇到范围查询，> < between
+		- 已经排序好的字段是会生效的，
+			- a=1 and b>1 ab都会生效
+			- a>1 and b=1 b索引会失效，a>1 时b为无序的
+	- MyISAM和InnoDB数据结构
+		- MYD数据 MYI索引
+		- ibd数据和索引，读一个文件速度更快
+	- 聚簇索引
+		- 根据主键索引可以直接拿到数据，索引和数据放在一起
+		- InnoDB
+			- 定义主键为聚簇索引
+			- 未定义索引，选择第一个部位null唯一索引
+			- 以上都没用，使用一个6字节长整型的隐式字段ROWID字段构建聚簇索引，该RPWID字段会在插入新行时自动递增
+	- 非聚簇索引(辅助索引)
+		- 除聚簇索引外
+		- 只存储主键ID
+		- 查询可能需要回表，通过辅助索引查询得到ID去主键索引中查找
+		- MyISAM中通过主键查询得到数据在硬盘中的地址，再根据该地址去磁盘中寻找
+		- 主键索引唯一，辅助索引可能等值也会查询出多个数据
+	- 索引覆盖
+		- 通过辅助索引可以获得全部数据，不需要回表
+	- 索引失效
+		- select *
+		- %左边
+		- 未最左匹配
+		- 数据库认为不要
+		- 计算
+		- or
+		- ！=  > <
+	-
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T07_06_29.086Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T07_06_29.086Z.Desktop.md
@@ -0,0 +1,132 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
+		- 范围查询大的时候需要返回根节点再次便利
+		- 存储了data信息，记录增多的时候树的高度会变高
+	- B+树
+		- 数据全部存在子节点中，非子节点只存储键值和指针
+		- 子节点之间添加链表结构，解决范围查询时需要返回根节点
+		- 范围查询效率提高很多，单个查询比B+树提高不大
+- 那些情况适合建立索引，那些不适合建立索引
+	- 频繁使用where
+	- 分组字段，分组的前提为排序
+	- 统计字段
+		- 加了索引不需要产生中间表去重
+	- 频繁更新字段
+	- 数据单一固定
+	- 数据量大(数据类型text)
+	- where条件不怎么用的
+- 索引分类，最左前缀，聚簇索引
+	- 主键索引
+	- 唯一索引(一级索引)
+	- 普通索引(二级索引)
+	- 联合索引(需要符合最左前缀原则)
+	- 最左前缀
+		- 第一个值为从小到大排序，第二个不是
+		- 第一个值确定的情况下，第二个值是有序的
+		- 从最左边开始连续的索引都可以匹配上，直到遇到范围查询，> < between
+		- 已经排序好的字段是会生效的，
+			- a=1 and b>1 ab都会生效
+			- a>1 and b=1 b索引会失效，a>1 时b为无序的
+	- MyISAM和InnoDB数据结构
+		- MYD数据 MYI索引
+		- ibd数据和索引，读一个文件速度更快
+	- 聚簇索引
+		- 根据主键索引可以直接拿到数据，索引和数据放在一起
+		- InnoDB
+			- 定义主键为聚簇索引
+			- 未定义索引，选择第一个部位null唯一索引
+			- 以上都没用，使用一个6字节长整型的隐式字段ROWID字段构建聚簇索引，该RPWID字段会在插入新行时自动递增
+	- 非聚簇索引(辅助索引)
+		- 除聚簇索引外
+		- 只存储主键ID
+		- 查询可能需要回表，通过辅助索引查询得到ID去主键索引中查找
+		- MyISAM中通过主键查询得到数据在硬盘中的地址，再根据该地址去磁盘中寻找
+		- 主键索引唯一，辅助索引可能等值也会查询出多个数据
+	- 索引覆盖
+		- 通过辅助索引可以获得全部数据，不需要回表
+	- 索引失效
+		- select *
+		- %左边
+		- 未最左匹配
+		- 数据库认为不要
+		- 计算
+		- or
+		- ！=  > <
+	- 优化
+		- 辅助索引覆盖
+		- 自增主键ID
+		- 避免select *
+		- 少用子查询，能使用外连接就外连接，避免笛卡尔积
+		- 使用短索引，非叶子节点存储更多索引降低树的高度
+	- 为什么推荐使用自增主键作为索引
+		- 页分裂
+		- 降低复杂度
+- List集合
+	- 结合源码，回答核心流程，夹带关键字
+	- ArrayList
+		- 如何扩容，大小如何自动增加
+			- 1. 初始化，未给定长度，默认调用午餐构造器
+				- elementdata 常量数组为空
+				- new之后数组长度为0
+			- 2. 添加第一个元素
+				- 计算容量，比较长度后返回初始化长度为10
+			- 3. 数组扩容
+				- grow方法增加长度
+				- 新容量为老容量加上老容量右移以为，即1.5倍
+				- 掉用复制数组的方法
+	- 复制某个ArrayList到另一个里面去
+		- clong，addAll，copy，stream流
+		- 重写Clone方法
+		- 浅复制
+			- 返回一个一样的ArrayList，其中一个改变了元素，另一个也会改变
+			- 两个集合中存储同一份元素引用
+		- 深复制
+			- 重写clone方法，使用迭代器便利，重新创建引用对象，逐个添加
+	- 索引中ArrayList增加或删除某个元素的运行过程，效率很低吗
+		- 效率很低，添加或删除某个元素都需要对数组中的元素进行移位，需要不断进行ArrayCopy很浪费时间
+		- 添加，后面元素都后移一位，再添加
+		- 删除，后面元素都前移一位覆盖
+	- 很大的数组需要拷贝，如何快速拷贝
+		- 创建时就指定数组的大小
+	- 获得线程安全的ArrayList
+		- synchorizoned关键字
+	- LinkedList和ArrayList如何选择
+		- ArrayList底层为数组，查询效率高，增删效率低
+		- LinkedList底层为链表，查询效率低，增删效率高
+	- Vector
+		- 扩容为2倍，线程安全
+- Set
+	- HashSet
+		- 无序，去重，非线程安全
+		- new新建HashMap
+		- 底层通过HashMap的key值实现的，值为常量PRESENT(一个空的Object对象)
+			- put调用setValue方法
+		- 添加时为什么要给个value为PRESENT常量
+			- PRESENT决定返回oldValue还是null判断是否已经存在
+		- HashSet remove方法比较PRESENT
+			- HashMap的删除方法成功会返回value，失败返回null，通过返回判断是否删除
+		- 去重原理
+			- hashcode和equals方法
+			- 先判断hash值，再通过==和wquals判断，返回true则为重复元素
+		- HashSet和TreeSet
+			- 无序HashSet，有序TreeSet
+		- 如何得到一个线程安全的Set集合
+			- Collections.synchorizeonedSet()~
--- a/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T07_33_43.993Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2022_09_13/2022-09-13T07_33_43.993Z.Desktop.md
@@ -0,0 +1,143 @@
+- 索引的概念
+	- 用于提高查找速度的一种数据结构
+	-
+- 为什么要用B+树，B-树和B+树区别，为什么不用红黑树
+	- Hash表结构存储数据
+		- 通过key的hash计算得到存储下表
+		- Hash只能进行等值查询，切换速度非常快，但是无法用于范围查询
+	- 二叉查找树
+		- 左边小，右边大，自身带排序
+		- 二分查找
+		- 极端情况
+			- 根节点的选取，如果选取不好就会不平衡
+			- 出现某一个方向子树过长
+	- 平衡二叉树
+		- 改善二叉树极端情况
+		- 降低IO次数，每走一个节点进行一次IO
+		- 数的高度过高，IO性能下降
+	- B树
+		- 存放指针及数据，保存了排序功能
+		- 指定阶数M，一个节点包含的子节点最大数量M越大，高度越低
+		- 范围查询大的时候需要返回根节点再次便利
+		- 存储了data信息，记录增多的时候树的高度会变高
+	- B+树
+		- 数据全部存在子节点中，非子节点只存储键值和指针
+		- 子节点之间添加链表结构，解决范围查询时需要返回根节点
+		- 范围查询效率提高很多，单个查询比B+树提高不大
+- 那些情况适合建立索引，那些不适合建立索引
+	- 频繁使用where
+	- 分组字段，分组的前提为排序
+	- 统计字段
+		- 加了索引不需要产生中间表去重
+	- 频繁更新字段
+	- 数据单一固定
+	- 数据量大(数据类型text)
+	- where条件不怎么用的
+- 索引分类，最左前缀，聚簇索引
+	- 主键索引
+	- 唯一索引(一级索引)
+	- 普通索引(二级索引)
+	- 联合索引(需要符合最左前缀原则)
+	- 最左前缀
+		- 第一个值为从小到大排序，第二个不是
+		- 第一个值确定的情况下，第二个值是有序的
+		- 从最左边开始连续的索引都可以匹配上，直到遇到范围查询，> < between
+		- 已经排序好的字段是会生效的，
+			- a=1 and b>1 ab都会生效
+			- a>1 and b=1 b索引会失效，a>1 时b为无序的
+	- MyISAM和InnoDB数据结构
+		- MYD数据 MYI索引
+		- ibd数据和索引，读一个文件速度更快
+	- 聚簇索引
+		- 根据主键索引可以直接拿到数据，索引和数据放在一起
+		- InnoDB
+			- 定义主键为聚簇索引
+			- 未定义索引，选择第一个部位null唯一索引
+			- 以上都没用，使用一个6字节长整型的隐式字段ROWID字段构建聚簇索引，该RPWID字段会在插入新行时自动递增
+	- 非聚簇索引(辅助索引)
+		- 除聚簇索引外
+		- 只存储主键ID
+		- 查询可能需要回表，通过辅助索引查询得到ID去主键索引中查找
+		- MyISAM中通过主键查询得到数据在硬盘中的地址，再根据该地址去磁盘中寻找
+		- 主键索引唯一，辅助索引可能等值也会查询出多个数据
+	- 索引覆盖
+		- 通过辅助索引可以获得全部数据，不需要回表
+	- 索引失效
+		- select *
+		- %左边
+		- 未最左匹配
+		- 数据库认为不要
+		- 计算
+		- or
+		- ！=  > <
+	- 优化
+		- 辅助索引覆盖
+		- 自增主键ID
+		- 避免select *
+		- 少用子查询，能使用外连接就外连接，避免笛卡尔积
+		- 使用短索引，非叶子节点存储更多索引降低树的高度
+	- 为什么推荐使用自增主键作为索引
+		- 页分裂
+		- 降低复杂度
+- List集合
+	- 结合源码，回答核心流程，夹带关键字
+	- ArrayList
+		- 如何扩容，大小如何自动增加
+			- 1. 初始化，未给定长度，默认调用午餐构造器
+				- elementdata 常量数组为空
+				- new之后数组长度为0
+			- 2. 添加第一个元素
+				- 计算容量，比较长度后返回初始化长度为10
+			- 3. 数组扩容
+				- grow方法增加长度
+				- 新容量为老容量加上老容量右移以为，即1.5倍
+				- 掉用复制数组的方法
+	- 复制某个ArrayList到另一个里面去
+		- clong，addAll，copy，stream流
+		- 重写Clone方法
+		- 浅复制
+			- 返回一个一样的ArrayList，其中一个改变了元素，另一个也会改变
+			- 两个集合中存储同一份元素引用
+		- 深复制
+			- 重写clone方法，使用迭代器便利，重新创建引用对象，逐个添加
+	- 索引中ArrayList增加或删除某个元素的运行过程，效率很低吗
+		- 效率很低，添加或删除某个元素都需要对数组中的元素进行移位，需要不断进行ArrayCopy很浪费时间
+		- 添加，后面元素都后移一位，再添加
+		- 删除，后面元素都前移一位覆盖
+	- 很大的数组需要拷贝，如何快速拷贝
+		- 创建时就指定数组的大小
+	- 获得线程安全的ArrayList
+		- synchorizoned关键字
+	- LinkedList和ArrayList如何选择
+		- ArrayList底层为数组，查询效率高，增删效率低
+		- LinkedList底层为链表，查询效率低，增删效率高
+	- Vector
+		- 扩容为2倍，线程安全
+- Set
+	- HashSet
+		- 无序，去重，非线程安全
+		- new新建HashMap
+		- 底层通过HashMap的key值实现的，值为常量PRESENT(一个空的Object对象)
+			- put调用setValue方法
+		- 添加时为什么要给个value为PRESENT常量
+			- PRESENT决定返回oldValue还是null判断是否已经存在
+		- HashSet remove方法比较PRESENT
+			- HashMap的删除方法成功会返回value，失败返回null，通过返回判断是否删除
+		- 去重原理
+			- hashcode和equals方法
+			- 先判断hash值，再通过==和wquals判断，返回true则为重复元素
+		- HashSet和TreeSet
+			- 无序HashSet，有序TreeSet
+		- 如何得到一个线程安全的Set集合
+			- Collections.synchorizeonedSet()
+- HashMap的底层结构
+	- jdk1.7 数组+单向链表
+	- jdk1.8 数组+链表(单向/双向)+红黑树
+	- 内部定义静态Node类
+		- Node<K, V>
+		- TreeNode有TreeNode left，TreeNode right继承LinkedHashMap.Entry继承HashMap.Node
+	- 如何解决Hash碰撞，何时从单链表转化为红黑树
+		- 存放元素需要通过Hash计算来得到Hash值，Hash值为元素要存放的位置，当两个不同元素经过Hash计算得到的Hash值相同，两个元素要存放在同一个位置，产生冲突
+		- HashMap的put方法
+			- 初始化table数组长度为16，第一次添加table为null，通过resize()方法,给新容量16，阈值16*0.75
+			- threadhold，扩容因子0.75
--- a/logseq-java/logseq/bak/journals/2023_09_15/2023-09-15T02_17_01.178Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_09_15/2023-09-15T02_17_01.178Z.Desktop.md
@@ -0,0 +1,345 @@
+- Java并发编程基础
+	- 1．谈谈你对AQS的理解
+	- 2．lock和synchronized区别
+	- 3．线程池如何知道一个线程的任务已经执行完成
+	- 4．什么叫做阻塞队列的有界和无界
+	- 5．ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？
+	- 6．能谈一下CAS机制吗？
+	- 7．死锁的发生原因和怎么避免
+	- 8．lock和Synchronized 区别
+	- 9．讲一下wait和notify这个为什么要在synchronized代码块中？
+	- 10．你是怎么理解线程安全问题的？
+	- 11．什么是守护线程，它有什么特点
+	- 12．谈谈你对AQS的理解
+	- 13．AbstractQueuedSynchronized 为什么采用双向链表
+	- 14．lock和synchronized 区别
+	- 15．线程池如何知道一个线程的任务已经执行完成
+	- 16．什么叫做阻塞队列的有界和无界
+	- 17．ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？
+	- 18．能谈一下CAS机制吗？
+	- 19．死锁的发生原因和怎么避免
+	- 20．volatile 关键字有什么用？它的实现原理是什么？
+	- 21．讲一下wait和notify这个为什么要在synchronized代码块中？
+	- 22．ThreadLocal是什么？它的实现原理呢？
+	- 23．基于数组的阻塞队列 ArrayBlockingQueue 原理
+	- 24．怎么理解线程安全？
+	- 25．请简述一下伪共享的概念以及如何避免
+	- 26．什么是可重入，什么是可重入锁？它用来解决什么问题？
+	- 27．请说一下ReentrantLock的实现原理？
+	- 28．简述一下你对线程池的理解？
+	- 29．如何中断一个正在运行的线程？
+	- 30．为什么引入偏向锁、轻量级锁，介绍下升级流程
+	- 31．什么是守护线程，它有什么特点
+	- 32．请谈谈AQS是怎么回事儿？
+	- 33．ReentrantLock 是如何实现锁公平和非公平性的？
+	- 34．说一下你对 CompletableFuture的理解
+	- 35．线程状态，BLOCKED和WAITING有什么区别
+	- 36．Thread和Runnable的区别
+	- 37．Thread和Runnable的区别
+	- 38．AQS为什么要使用双向链表？
+	- 39．ConcurrentHashMap的size（）方法是线程安全的吗？为什么
+	- 40．wait和sleep是否会触发锁的释放以及CPU资源的释放？
+	- 41．DCL单例模式设计为什么需要 volatile 修饰实例对象
+	- 42．讲下线程池的线程回收
+	- 43．如果一个线程两次调用start（），会出现什么问题？
+	- 44．Java 官方提供了哪几种线程池，分别有什么特点？
+	- 45．请你说一下你对Happens-Before的理解。
+	- 46．线程池是如何实现线程复用的？
+	- 47．可以说下阻塞队列被异步消费怎么保持顺序吗？
+	- 48．当任务数超过线程池的核心线程数时，如何让它不进入队列，而是直接启用最大线程数
+	- 49．SimpleDateFormat 是线程安全的吗？为什么？
+	- 50．并行和并发有什么区别？
+	- 51．如何解决死锁问题？
+	- 52．为什么 ConcurrentHashMap中key不允许为null
+	- 53．ThreadLocal会出现内存泄漏吗？
+	- 54．什么是CompletableFuture？
+	- 55．什么条件下会产出死锁，如何避免死锁？
+	- 56．ConcurrentHashMap是如何保证线程安全的？
+	- 57．ThreadLocal真的会造成内存泄漏吗？
+	- 58．为什么 ConcurrentHashMap 不允许插入null值？
+	- 59．synchronized和Lock的区别
+	- 60．如何安全地中断一个正在运行的线程？
+- JVM面试题合集
+	- 1．CPU飙高系统反应慢怎么排查？
+	- 2．关于什么是JVM？看看普通人和高手的回答。
+	- 3．有没有排查过线上oom的问题，如何排查的
+	- 4．说一下你对双亲委派的理解
+	- 5．CPU飙高系统反应慢怎么排查？
+	- 6．什么是双亲委派？
+	- 7．JVM 如何判断一个对象可以被回收
+	- 8．G1 垃圾收集的特点，为什么低延迟
+	- 9．JVM分代年龄为什么是15次？可以25次吗？
+	- 10．一个空Object对象的占多大空间？
+	- 11．什么是Java虚拟机，为什么要使用？
+	- 12．JVM 为什么使用元空间替换了永久代？
+	- 13．Java 常见的垃圾收集器有哪些？
+	- 14．如何破坏双亲委派模型
+	- 15．JVM 中一次完整的GC流程是怎样的，对象如何晋升到老年代
+	- 16．如果发生内存泄漏怎么排查
+	- 17．JVM中的三色标记法是什么？
+	- 18．说一些CMS垃圾回器的工作原理
+	- 19．什么是内存溢出，什么是内存泄漏？
+	- 20．什么是双亲委派机制？
+- Java 基础面试题
+	- 1．fail-safe 机制与fail-fast 机制分别有什么作用
+	- 2．HashMap 是怎么解决哈希冲突的？
+	- 3．面试官：你能说一下什么是受检异常和非受检异常吗？
+	- 4．为什么阿里巴巴的Java开发手册不建议使用Java自带的线程池
+	- 5．fail-safe 机制与fail-fast机制分别有什么作用
+	- 6．HashMap是怎么解决哈希冲突的？
+	- 7．JDK动态代理为什么只能代理有接口的类？
+	- 8．请说一下对象的创建过程（阿里）
+	- 9．new String（＂abc＂）到底创建了几个对象？
+	- 10．请简单说一下你对受检异常和非受检异常的理解
+	- 11．HashMap 是如何解决 hash 冲突的？
+	- 12．String、StringBuffer、StringBuilder 区别
+	- 13．Integer使用不当导致生产的事故
+	- 14．可以讲一下ArrayList的自动扩容机制吗？
+	- 15．什么是深拷贝和浅拷贝？
+	- 16．HashMap中的hash方法为什么要右移16位异或？
+	- 17．HashMap 啥时候扩容，为什么扩容？
+	- 18．强引用、软引用、弱引用、虚引用有什么区别？
+	- 19．Java有几种文件拷贝方式，哪一种效率最高？
+	- 20．聊聊你知道的设计模式
+	- 21．finally块一定会执行吗？
+	- 22．在Java 中实现单例模式有哪些方法
+	- 23．Java SPI是什么？有什么用？
+	- 24．Integer和int的区别？Java为什么要设计封装类？
+	- 25．Integer a1＝100 Integer a2＝100， a1＝＝a2？的运行结果？
+	- 26．HashMap 与HashTable 区别
+	- 27．Java反射的优缺点？
+	- 28．为什么重写 equals（）就一定要重写 hashCode（）方法？
+	- 29．介绍下策略模式和观察者模式？
+	- 30．谈谈什么是零拷贝？
+	- 31．SortedSet和List异同点？
+	- 32．为什么阿里Java手册禁止使用存储过程？
+	- 33．为什么阿里巴巴强制要求使用包装类型定义属性？
+	- 34．刚折腾完Log4J，又爆Spring RCE核弹级漏洞
+	- 35.3分钟轻松理解单线程下的HashMap工作原理
+	- 36．两个Integer对象比较大小，为什么100等于100，1000不等于1000？
+	- 37．为什么 HashMap会产生死循环？
+	- 38．哪些情况下的单例对象可能会破坏？
+	- 39．责任链模式的实现原理
+	- 40．new String（＂hello＂）之后，到底创建了几个对象？
+	- 41．什么是Java SPI，它有什么作用？
+- Mysql数据库面试题
+	- 1．innoDB 如何解决幻读
+	- 2．b树和b＋树的理解
+	- 3．你是否在面试中也被过MySQL优化相关的问题呢？
+	- 4．关于“你对MVCC的理解，看看普通人和高手是如何回答这个问题的？
+	- 5．关于索引的底层实现，为什么选择B＋Tree而不是红黑树？
+	- 6．请你说一下Mysql中的性能调优方法？
+	- 7．为什么一线互联网公司严禁使用存储过程？
+	- 8．Mysql 中的RR隔离级别，到底有没有解决幻读问题？
+	- 9．为什么索引要用B＋树来实现呢，而不是B树？
+	- 10．Mysql是如何解决幻读问题的？
+	- 11．什么是聚集索引和非聚集索引
+	- 12．请你简单说一下Mysql的事务隔离级别
+	- 13．binlog 和 redolog有什么区别？
+	- 14．说一下你日常工作中是怎么优化SQL的
+	- 15．Mysql 主从集群同步延迟问题怎么解决
+	- 16．MySQL 数据库 cpu 飙升的话，要怎么处理呢？
+	- 17．innoDB 如何解决幻读
+	- 18．Mysql的binlog 有几种格式？分别有什么区别
+	- 19．索引有哪些缺点以及具体有哪些索引类型
+	- 20．b树和b＋树的理解
+	- 21．什么是聚集索引和非聚集索引
+	- 22．请你简单说一下Mysql的事务隔离级别
+	- 23．Mysql为什么使用B＋Tree作为索引结构
+	- 24．数据库连接池有什么用？它有哪些关键参数？
+	- 25．请说一下Mysql索引的优点和缺点？
+	- 26．Mysql事务的实现原理
+	- 27．请你说一下数据库优化
+	- 28．说一下你对行锁、临键锁、间隙锁的理解
+	- 29．索引什么时候失效？
+	- 30．Mysql 如何解决幻读问题
+	- 31．请简要说明Mysql中MyISAM和InnoDB引擎的区别
+	- 32．存储MD5的值应该用VARCHAR还是CHAR
+	- 33．Mysql 索引在什么情况下会失效
+	- 34．MySql 存储引擎 InnoDB 与MyISAM 有什么区别
+	- 35．MVCC过程中会加锁吗？
+	- 36．MySQL update 是锁行还是锁表？
+	- 37．为什么 SQL 语句不要过多的join？
+	- 38．什么情况下不建索引？
+	- 39．为什么MySQL索引结构采用B＋树？
+	- 40．谈谈你对MySQL事务隔离级别的理解
+	- 41．为什么SQL语句命中索引比不命中索引要快？
+	- 42．B 树和B＋树的区别什么？
+	- 43．执行SQL响应比较慢，你有哪些排查思路？
+- Spring Cloud生态必问面试题
+	- 1．谈谈你对Seata的理解
+	- 2．Dubbo的服务请求失败怎么处理？
+	- 3．Redis和Mysql 如何保证数据一致性能
+	- 4．什么是Dubbo？它有哪些核心功能？
+	- 5．既然说到Dubbo的功能，请详细说说Dubbo负载均衡的几种策略
+	- 6．最后在说说 Dubbo与Spring Cloud的区别吧！
+	- 7．Dubbo的工作原理是什么样的？
+	- 8.5分钟带你快速弄懂RPC
+	- 9．分布式事务的原理
+	- 10．关于“你对Spring Cloud的理解”
+	- 11．关于“谈谈你对ES的理解，看看普通人和高手是如何回答这个问题的？”
+	- 12.5分钟带你快速了解什么是Kubernetes
+	- 13．还原面试现场，带大家理解何为Docker
+	- 14．什么是负载均衡
+	- 15．RPC 和HTTP 协议有什么区别？
+	- 16．Dubbo的服务请求失败怎么处理？
+	- 17．说一下你对SPI机制的理解以及Dubbo中有哪些SPI机制的实现
+	- 18．谈谈你对Seata的理解
+	- 19．Dubbo的服务请求失败怎么处理？
+	- 20．什么是服务网格？
+	- 21．Dubbo 是如何动态感知服务下线的？
+	- 22．简单说一下你对序列化和反序列化的理解
+	- 23．说一说你对Spring Cloud的理解
+	- 24．什么是SPI，它有什么用？
+	- 25．Eureka server 数据同步原理能说下吗
+	- 26．说说你对一致性Hash算法的理解
+	- 27．请说一下你对分布式和微服务的理解
+	- 28．Nacos配置更新的工作流程
+	- 29．谈谈常用的分布式ID设计方案
+	- 30．Http 协议和RPC协议有什么区别？
+	- 31．如何解决TCC中的悬挂问题
+	- 32．请你说一下你对服务降级的理解
+	- 33．服务注册中心应该是AP还是CP
+	- 34．说说你对CAP的理解
+	- 35．请说一下分布式事务的理解和解决方案？
+	- 36．什么是微服务，说一下你对微服务的理解？
+	- 37．Dubbo和SpringCloud的优缺点对比
+	- 38．谈谈分布式事务的3种解决方案
+	- 39．谈谈你对NoSQL的理解
+	- 40．谈谈你对 Spring Cloud的理解
+	- 41．放弃FastDFS，拥抱MinlO的7大理由
+- Spring Boot面试题
+	- 1．Spring Boot的约定优于配置，你的理解是什么？
+	- 2．Spring Boot中自动装配机制的原理
+	- 3．Spring Boot的约定优于配置，你的理解是什么？
+	- 4．Spring Boot中自动装配机制的原理
+	- 5．如何理解 Spring Boot中的Starter？
+	- 6．SpringBoot如何解决跨域问题？
+	- 7．Spring Boot自动装配原理
+- Spring 面试题
+	- 1．能回答一下Spring Bean生命周期的执行流程吗
+	- 2．请简述你对Spring MVC的理解，看看普通人和高手是如何回答的？
+	- 3．Spring 是如何解决循环依赖问题的？
+	- 4．Spring中事务的传播行为有哪些？
+	- 5．说说Spring MVC的执行流程？
+	- 6．为什么要使用Spring 框架？
+	- 7．Spring 中事务的传播行为有哪些？
+	- 8．Spring 中Bean的作用域有哪些？
+	- 9．Spring中有哪些方式可以把Bean注入到IOC容器？
+	- 10．Spring 中 BeanFactory和FactoryBean的区别
+	- 11．说说你对Spring MVC的理解
+	- 12．介绍下Spring loC的工作流程
+	- 13．＠Resource 和＠Autowired 的区别
+	- 14．Spring 中，有两个id 相同的bean，会报错吗，如果会报错，在哪个阶段报错
+	- 15．Spring 里面的事务和分布式事务的使用如何区分，以及这两个事务之间有什么关联？
+	- 16．谈谈你对Spring IOC和DI的理解？
+	- 17．Spring 如何解决循依赖问题
+	- 18．＠Conditional 注解有什么用？
+	- 19．为什么有些公司禁止使用＠Transactional 声明式事务？
+- Mybatis 面试题
+	- 1．说一说Mybatis里面的缓存机制
+	- 2．说一说Mybatis里面的缓存机制
+	- 3．Mybatis中＃｛和＄0｝的区别是什么？
+	- 4．Mybatis是如何进行分页的
+	- 5．MyBatis 配置中的＃0和＄0有什么区别？
+	- 6．MyBatis 何时使用一级缓存，何时使用二级缓存？
+- 网络10相关面试题
+	- 1．请说一下网络四元组
+	- 2．［连环问］介绍一下自己对Netty的认识吧
+	- 3．什么是服务网格？
+	- 4．请说一下网络四元组
+	- 5.10和NIO有什么区别？
+	- 6．TCP协议为什么要设计三次握手？
+	- 7．Cookie和Session的区别
+	- 8．请说一下Netty中Reactor模式的理解
+	- 9．什么是I0的多路复用机制？
+	- 10．select 和 epoll 的区别
+	- 11．什么是拆包和粘包？怎么解决？
+	- 12．为什么Netty线程池默认大小为CPU核数的2倍
+- Redis面试题
+	- 1．说一下你对Redis的理解
+	- 2．字节一面，Redis为什么这么快？
+	- 3．Redis和Mysql 如何保证数据一致性
+	- 4．Redis 存在线程安全问题吗？为什么？
+	- 5．RDB 和AOF的实现原理以及优缺点
+	- 6．Redis和Mysql 如何保证数据一致性
+	- 7．Redis的内存淘汰算法和原理是什么？
+	- 8．请说一下你对分布式锁的理解，以及分布式锁的实现
+	- 9．说说缓存雪崩和缓存穿透的理解，以及如何避免？
+	- 10说说缓存雪崩和缓存穿透的理解，以及如何避免？
+	- 11．Redis存在线程安全问题吗？为什么？
+	- 12．请说一下你对分布式锁的理解，以及分布式锁的实现
+	- 13．RDB和AOF的实现原理、优缺点
+	- 14．请描述一下Redis中AOF 重写的过程
+	- 15．Redis有哪些持久化策略，说一下他们的工作原理？
+	- 16．Redis多线程模型怎么理解，那它会有线程安全问题吗？
+	- 17．怎么防止缓存击穿的问题？
+	- 18．请描述Redis 的缓存淘汰策略
+	- 19．Redis 哨兵机制和集群有什么区别？
+	- 20．Redis 主从复制的原理
+	- 21．Redis 有哪些过期策略
+	- 22．Redis 遇到Hash冲突怎么办？
+	- 23．什么是热 Key 问题，如何解决热 key 问题
+	- 24．Redis中的哨兵选举算法是如何实现的？
+	- 25．为什么 Redis 集群的最大槽数是16384个？
+	- 26．谈谈你对Redis的理解
+- Zookeeper面试题
+	- 1．实现分布式锁的解决方案中，你认为Zookeeper和Redis 哪种更好？
+	- 2．Zookeeper和Redis 哪种更好？
+	- 3．关于“你对Zookeeper的理解，看看普通人和高手是如何回答这个问题的？
+	- 4．Zookeeper中的Watch机制的原理？
+	- 5．Zookeeper 如何实现 Leader选举
+	- 6．Zookeeper 如何实现分布式锁
+	- 7．谈谈你对Zookeeper的理解
+- 分布式消息队列面试题
+	- 1．什么是消息队列？
+	- 2．滴滴二面：kafka的零拷贝原理？
+	- 3．滴滴二面：kafka的零拷贝原理？
+	- 4．Kafka 如何保证消息不丢失？
+	- 5．Kafka 怎么避免重复消费
+	- 6．什么是ISR，为什么需要引入ISR
+	- 7．Kafka 如何保证消息消费的顺序性？
+	- 8．RabbitMQ的消息如何实现路由？
+	- 9．如何保证 RabbitMQ的消息可靠传输
+	- 10．RabbitMQ如何实现高可用
+	- 11．如何处理消息队列的消息积压问题
+	- 12．Kafka 消息队列怎么保证 exactlyOnce，怎么实现顺序消费
+	- 13．说一下Kafka中Parttion 分区副本的Leader选举算法
+	- 14．Kafka中一个Topic有三个Partition，同一个消费组中两个消费者如何消费的？
+	- 15．多线程异步和MQ有什么区别？
+	- 16．谈谈你对MQ（消息中间件）的理解
+- 一线大厂场景问题详解
+	- 1．扫码登录到底是怎么实现的？
+	- 2．订单超时自动取消功能如何设计？
+	- 3．怎么理解接口幂等，项目中如何保证的接口幂等
+	- 4．消息推送中的已读消息和未读消息设计难题
+	- 5．布隆过滤器到底是什么东西？它有什么用
+	- 6．从B站崩溃的故障排查和恢复过程中学到什么？
+	- 7．limit 1000000，10 加载很慢该怎么优化
+	- 8．会员批量过期的方案怎么实现？
+	- 9．什么是幂等？如何解决幂等性问题？
+	- 10．常见的限流算法有哪些？
+	- 11．说说你对一致性Hash算法的理解
+	- 12．如果让你设计一个秒杀系统，怎么设计？
+	- 13．如果问你项目的重点和难点，该如何回答呢？
+	- 14．如果让你设计一个秒杀系统，怎么设计？
+	- 15．来一个亿级数据存储问题讲解，每天新增6000万数据
+	- 16．什么情况下会出现Full GC，怎么解决？
+	- 17．如果问你项目的重点和难点，该如何回答呢？
+	- 18．生产环境服务器变慢，如何诊断处理？
+	- 19．将user表进行了分库分表，那么手机号的唯一索引是不是就失效了
+	- 20．在2G大小的文件中，找出高频top100的单词
+	- 21．数据量达到多少的时候要开始分库分表
+	- 22．表数据量大的时候，影响查询效率的主要原因有哪些
+	- 23．应用程序中存在包冲突的情况下，怎么发现和解决
+	- 24．Java之父直播面试被吊打？
+	- 25．字节跳动一面真题，如何提升接口的性能？
+	- 26．对接第三方接口要考虑什么？
+- 常见算法面试题
+	- 1．什么是时间轮，请你说一下你对时间轮的理解
+	- 2．什么是令牌桶限流算法
+	- 3．请你说一下你对滑动窗口算法的理解
+	- 4．简述雪花算法的实现原理
+	- 5．SkipList的索引过程，能否越两级搜索
+	- 6．对称加密与非对称加密有什么区别
+	- 7．敏感数据怎么加解密和传输？
--- a/logseq-java/logseq/bak/journals/2023_09_26/2023-10-17T03_37_18.530Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_09_26/2023-10-17T03_37_18.530Z.Desktop.md
@@ -0,0 +1,64 @@
+- DOING Spring
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:14]
+  :END:
+	- https://www.bilibili.com/video/BV1rb4y147F2
+	- [[Spring是如何创建一个bean对象的]]
+	- [[Spring源码]]
+	- 微服务SpringCloud
+	- 什么是单例池，作用是什么
+	- Bean和普通对象之间的区别是什么
+	- @PostConstruct注解是如何工作的
+	- Bean的初始化是如何工作的
+	- Bean的初始化和实例化的区别是什么
+	- 什么是初始化后
+	- 推断构造方法是什么意思
+	- 什么是先bytype再byname
+	- Spring Aop底层是怎么工作的
+	- Spring事务底层是怎么工作的
+	- @Configuration注解的作用是什么
+	- Spring为什么要用三级缓存来解决循环依赖
+	- @Async为什么回导致循环依赖解决不了
+	- 构造方法和多例导致的循环依赖
+	- SpringMVC处理请求底层原理流程
+	- SpringMVC容器创建源码分析
+	- SpringMVC父子容器原理分析
+	- SpringMVC父子容器源码分析
+	- SpringMVC的零配置
+	- 手写代码模拟SpringBoot
+	- Springboot如何选择TomCAT还是Jett底层
+	- @ConditionOnClass注解底层原理
+	- SpringBoot零配置底层原理实现
+	- Spring是什么
+	- Spring的事务传播机制
+	- Spring框架中Bean的创建过程
+	- Spring中的Bean是线程安全的吗
+	- Spring中的单例Bean是线程安全的吗
+	- Spring框架中使用了哪些设计模式及应用场景
+	- Spring容器启动流程是怎样的
+	- Spring如何处理事务
+	- Spring如何处理循环依赖问题
+	- Spring事务的实现原理及隔离级别
+	- Spring事务什么时候会失效
+	- Spring用到了哪些设计模式
+	- Spring支持的Bane的作用域
+	- Spring中Bean是线程安全的吗
+	- Spring中的Bean创建的声明周期有哪些步骤
+	- Spring中的事务时如何实现的
+	- Spring中说明时候@Transactional会失效
+	- Spring中后置处理器的作用
+	- 如何实现AOP，项目哪些地方用到了AOP
+	- 说说常用的SpringBoot注解，及其实现
+	- 还读过哪些框架源码，介绍一下你还熟悉的
+	- 介绍一下Spring，读过源码介绍一下大致流程
+	- 什么时候@Transactional失效
+	- 说一下Spring的事务机制
+	- 对AOP的理解
+	- 对IOC的理解
+	- 简述Spring bean的生命周期
+	- Spring用到了哪些设计模式
+	- Spring中Bean是线程安全的吗
+	- 如何理解SpringBoot的starter
+	- 如何实现一个IOC容器
+	- 什么是bean的自动装配，有哪些方式
+	- 如何实现一个自定义的starter
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-19T14_02_50.922Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-19T14_02_50.922Z.Desktop.md
@@ -0,0 +1,171 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DONE 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]--[2023-10-19 Thu 17:21:38] =>  292:10:21
+  :END:
+	- [[Java创建线程的方式有哪些]]
+	- [[线程生命周期状态]]
+	- [[什么是线程安全，线程安全的本质]]
+	- [[ThreadLocal使用场景]]
+	- [[ThreadLocal内存泄漏]]
+	- [[Java中21种锁]]
+	- [[为什么阿里禁用Executors创建线程]]
+	- [[如何根据实际需要，定制自己的线程池]]
+	- [[CAS缺点]]
+	- [[线程池线程复用原理]]
+	- [[阻塞和非阻塞队列的并发安全原理]]
+	- [[公平锁和非公平锁]]
+	- [[自旋锁优缺点]]
+	- [[合适的线程数量，CPU核心数和线程树的关系]]
+	- [[CAS是一种什么样的同步机制]]
+	- [[线程加锁有哪些方式，Synchronized和lock的区别]]
+	- [[进程和线程的区别，使用线程真的能节省时间]]
+	- [[线程有几种状态]]
+	- [[ThreadLocal是什么，工作中有用到过吗]]
+	- [[ThreadLocal父子线程怎么共享数据]]
+	- [[ThreadLocalMap的结构及扩容机制]]
+	- [[解决hash冲突发方法]]
+	- [[你知道哪几种锁，分别有什么特点]]
+	- [[什么是阻塞队列，Java中有哪些阻塞队列]]
+	- [[ConcurrentHashMap为什么放弃了分段锁]]
+	- [[HashMap内部如何工作]]
+	- [[什么是指令重排序，为什么要重排序]]
+	- [[什么是内存可见性]]
+	- [[什么是happen-before原则]]
+	- [[为什么需要AQS，AQS的作用和重要性]]
+	- [[一个线程调用两次start()方法会出现什么情况]]
+	- [[为什么多线程会带来性能问题]]
+	- [[线程池有几种拒绝策略]]
+	- [[哪些解决死锁的策略]]
+	- [[你知道哪些线程安全问题]]
+	- [[线程池中提交一个任务是怎么样的]]
+- DONE JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]--[2023-10-17 Tue 20:44:40] =>  247:33:12
+  :END:
+	- https://www.bilibili.com/video/BV1dA411U7or
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	- [[引用计数法有什么问题]]
+	- [[GC Root可达性分析法]]
+	- [[什么样的类能被回收]]
+	- [[JVM内部各种垃圾收集算法]]
+	- [[CMS垃圾回收过程]]
+	- [[CMS比较严重的问题并发收集阶段再次触发Full GC]]
+	- [[垃圾收集底层三色标记算法]]
+	- [[G1垃圾收集过程]]
+	- [[G1收集器最大停顿时间时如何实现的]]
+	- [[内存泄漏如何排查和解决]]
+	- [[GC什么时候都能做吗，GC安全点和安全区域]]
+	- [[字符串常量池]]
+	- [[基本类型包装类常量池如何实现的]]
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-23T07_56_27.574Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-23T07_56_27.574Z.Desktop.md
@@ -0,0 +1,173 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DOING 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]
+  :END:
+	- [[Java创建线程的方式有哪些]]
+	- [[线程生命周期状态]]
+	- [[什么是线程安全，线程安全的本质]]
+	- [[ThreadLocal使用场景]]
+	- [[ThreadLocal内存泄漏]]
+	- [[Java中21种锁]]
+	- [[为什么阿里禁用Executors创建线程]]
+	- [[如何根据实际需要，定制自己的线程池]]
+	- [[CAS缺点]]
+	- [[线程池线程复用原理]]
+	- [[阻塞和非阻塞队列的并发安全原理]]
+	- [[公平锁和非公平锁]]
+	- [[自旋锁优缺点]]
+	- [[合适的线程数量，CPU核心数和线程数的关系]]
+	- [[CAS是一种什么样的同步机制]]
+	- [[线程加锁有哪些方式，Synchronized和lock的区别]]
+	- [[进程和线程的区别，使用线程真的能节省时间]]
+	- [[线程有几种状态]]
+	- [[ThreadLocal是什么，工作中有用到过吗]]
+	- [[ThreadLocal如何实现]]
+	- [[ThreadLocal父子线程怎么共享数据]]
+	- [[ThreadLocalMap的结构及扩容机制]]
+	- [[解决hash冲突方法]]
+	- [[你知道哪几种锁，分别有什么特点]]
+	- [[什么是阻塞队列，Java中有哪些阻塞队列]]
+	- [[ConcurrentHashMap为什么放弃了分段锁]]
+	- [[HashMap内部如何工作]]
+	- [[什么是指令重排序，为什么要重排序]]
+	- [[什么是内存可见性]]
+	- [[主内存和工作内存的关系]]
+	- [[什么是happen-before原则]]
+	- [[为什么需要AQS，AQS的作用和重要性]]
+	- [[一个线程调用两次start()方法会出现什么情况]]
+	- [[为什么多线程会带来性能问题]]
+	- [[线程池有几种拒绝策略]]
+	- [[哪些解决死锁的策略]]
+	- [[你知道哪些线程安全问题]]
+	- [[线程池中提交一个任务是怎么样的]]
+- DONE JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]--[2023-10-17 Tue 20:44:40] =>  247:33:12
+  :END:
+	- https://www.bilibili.com/video/BV1dA411U7or
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	- [[引用计数法有什么问题]]
+	- [[GC Root可达性分析法]]
+	- [[什么样的类能被回收]]
+	- [[JVM内部各种垃圾收集算法]]
+	- [[CMS垃圾回收过程]]
+	- [[CMS比较严重的问题并发收集阶段再次触发Full GC]]
+	- [[垃圾收集底层三色标记算法]]
+	- [[G1垃圾收集过程]]
+	- [[G1收集器最大停顿时间时如何实现的]]
+	- [[内存泄漏如何排查和解决]]
+	- [[GC什么时候都能做吗，GC安全点和安全区域]]
+	- [[字符串常量池]]
+	- [[基本类型包装类常量池如何实现的]]
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-25T00_44_14.618Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-25T00_44_14.618Z.Desktop.md
@@ -0,0 +1,173 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DONE 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]--[2023-10-19 Thu 17:21:38] =>  292:10:21
+  :END:
+	- [[Java创建线程的方式有哪些]]
+	- [[线程生命周期状态]]
+	- [[什么是线程安全，线程安全的本质]]
+	- [[ThreadLocal使用场景]]
+	- [[ThreadLocal内存泄漏]]
+	- [[Java中21种锁]]
+	- [[为什么阿里禁用Executors创建线程]]
+	- [[如何根据实际需要，定制自己的线程池]]
+	- [[CAS缺点]]
+	- [[线程池线程复用原理]]
+	- [[阻塞和非阻塞队列的并发安全原理]]
+	- [[公平锁和非公平锁]]
+	- [[自旋锁优缺点]]
+	- [[合适的线程数量，CPU核心数和线程数的关系]]
+	- [[CAS是一种什么样的同步机制]]
+	- [[线程加锁有哪些方式，Synchronized和lock的区别]]
+	- [[进程和线程的区别，使用线程真的能节省时间]]
+	- [[线程有几种状态]]
+	- [[ThreadLocal是什么，工作中有用到过吗]]
+	- [[ThreadLocal如何实现]]
+	- [[ThreadLocal父子线程怎么共享数据]]
+	- [[ThreadLocalMap的结构及扩容机制]]
+	- [[解决hash冲突方法]]
+	- [[你知道哪几种锁，分别有什么特点]]
+	- [[什么是阻塞队列，Java中有哪些阻塞队列]]
+	- [[ConcurrentHashMap为什么放弃了分段锁]]
+	- [[HashMap内部如何工作]]
+	- [[什么是指令重排序，为什么要重排序]]
+	- [[什么是内存可见性]]
+	- [[主内存和工作内存的关系]]
+	- [[什么是happen-before原则]]
+	- [[为什么需要AQS，AQS的作用和重要性]]
+	- [[一个线程调用两次start()方法会出现什么情况]]
+	- [[为什么多线程会带来性能问题]]
+	- [[线程池有几种拒绝策略]]
+	- [[哪些解决死锁的策略]]
+	- [[你知道哪些线程安全问题]]
+	- [[线程池中提交一个任务是怎么样的]]
+- DONE JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]--[2023-10-17 Tue 20:44:40] =>  247:33:12
+  :END:
+	- https://www.bilibili.com/video/BV1dA411U7or
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	- [[引用计数法有什么问题]]
+	- [[GC Root可达性分析法]]
+	- [[什么样的类能被回收]]
+	- [[JVM内部各种垃圾收集算法]]
+	- [[CMS垃圾回收过程]]
+	- [[CMS比较严重的问题并发收集阶段再次触发Full GC]]
+	- [[垃圾收集底层三色标记算法]]
+	- [[G1垃圾收集过程]]
+	- [[G1收集器最大停顿时间时如何实现的]]
+	- [[内存泄漏如何排查和解决]]
+	- [[GC什么时候都能做吗，GC安全点和安全区域]]
+	- [[字符串常量池]]
+	- [[基本类型包装类常量池如何实现的]]
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-25T01_12_10.364Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-25T01_12_10.364Z.Desktop.md
@@ -0,0 +1,123 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DOING 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]
+  :END:
+	- [[线程池中提交一个任务是怎么样的]]
+- DOING JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]
+  :END:
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	-
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-27T07_18_31.958Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-27T07_18_31.958Z.Desktop.md
@@ -0,0 +1,123 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DOING 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]
+  :END:
+	- [[线程池中提交一个任务是怎么样的]]
+- DOING JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]
+  :END:
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	-
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_07/2023-10-27T07_24_32.169Z.Desktop.md
+++ b/logseq-java/logseq/bak/journals/2023_10_07/2023-10-27T07_24_32.169Z.Desktop.md
@@ -0,0 +1,173 @@
+- MySQL
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:05:28]
+  :END:
+	- DONE 看面试题
+	  :LOGBOOK:
+	  CLOCK: [2023-10-10 Tue 11:46:55]
+	  CLOCK: [2023-10-10 Tue 11:46:59]--[2023-10-10 Tue 21:24:01] =>  09:37:02
+	  :END:
+	- https://www.bilibili.com/video/BV1N24y1y7a1
+	- [[如何实现的索引机制]]
+	- [[表中没有索引，会创建B+树吗]]
+	- [[B+树]]
+	- [[为什么官方推荐自增主键]]
+	- [[使用int作为自增主键，最大id为10，删除10和9，添加一条记录，不重启和重启后添加记录id为多少]]
+	- [[索引优缺点]]
+	- [[回表操作]]
+	- [[索引类型]]
+	- [[创建索引的情况]]
+	- [[索引下推]]
+	- [[索引失效]]
+	- [[多个索引是否可以指定]]
+	- [[Order By是否走索引]]
+	- [[MySQL查询缓存]]
+	- [[MySQL组成]]
+	- [[MySQL执行SQL步骤]]
+	- [[存储引擎]]
+	- [[MySQL事务]]
+	- [[MySQL锁]]
+	- [[XA协议]]
+	- [[select for update会产生哪些操作]]
+	- [[死锁的产生原因和处理方法]]
+	- [[MySQL日志]]
+	- MySQL开发
+		- [[可以用MySQL存储文件吗]]
+		- [[存储的时候有遇到过什么问题吗]]
+		- [[财务计算有没有出现过错乱]]
+		- [[预编译SQL]]
+		- [[子查询和join哪个效率高]]
+		- [[SQL调优]]
+		- [[MySQL数据库cpu飙升]]
+		- [[分库分表]]
+		- [[视图]]
+		- [[存储过程]]
+		- [[外键]]
+		- [[processlist]]
+		- [[千万数据查询优化]]
+		- [[count(列名)和count(*)区别]]
+		- [[如果有超大分页怎么处理]]
+		- [[mysql服务器毫无规律异常重启]]
+		- [[mysql线上修改表结构有哪些风险]]
+		- [[什么是mysql多实例部署]]
+- DONE 多线程
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:17]--[2023-10-19 Thu 17:21:38] =>  292:10:21
+  :END:
+	- [[Java创建线程的方式有哪些]]
+	- [[线程生命周期状态]]
+	- [[什么是线程安全，线程安全的本质]]
+	- [[ThreadLocal使用场景]]
+	- [[ThreadLocal内存泄漏]]
+	- [[Java中21种锁]]
+	- [[为什么阿里禁用Executors创建线程]]
+	- [[如何根据实际需要，定制自己的线程池]]
+	- [[CAS缺点]]
+	- [[线程池线程复用原理]]
+	- [[阻塞和非阻塞队列的并发安全原理]]
+	- [[公平锁和非公平锁]]
+	- [[自旋锁优缺点]]
+	- [[合适的线程数量，CPU核心数和线程数的关系]]
+	- [[CAS是一种什么样的同步机制]]
+	- [[线程加锁有哪些方式，Synchronized和lock的区别]]
+	- [[进程和线程的区别，使用线程真的能节省时间]]
+	- [[线程有几种状态]]
+	- [[ThreadLocal是什么，工作中有用到过吗]]
+	- [[ThreadLocal如何实现]]
+	- [[ThreadLocal父子线程怎么共享数据]]
+	- [[ThreadLocalMap的结构及扩容机制]]
+	- [[解决hash冲突方法]]
+	- [[你知道哪几种锁，分别有什么特点]]
+	- [[什么是阻塞队列，Java中有哪些阻塞队列]]
+	- [[ConcurrentHashMap为什么放弃了分段锁]]
+	- [[HashMap内部如何工作]]
+	- [[什么是指令重排序，为什么要重排序]]
+	- [[什么是内存可见性]]
+	- [[主内存和工作内存的关系]]
+	- [[什么是happen-before原则]]
+	- [[为什么需要AQS，AQS的作用和重要性]]
+	- [[一个线程调用两次start()方法会出现什么情况]]
+	- [[为什么多线程会带来性能问题]]
+	- [[线程池有几种拒绝策略]]
+	- [[哪些解决死锁的策略]]
+	- [[你知道哪些线程安全问题]]
+	- [[线程池中提交一个任务是怎么样的]]
+- DONE JVM
+  :LOGBOOK:
+  CLOCK: [2023-10-07 Sat 13:11:28]--[2023-10-17 Tue 20:44:40] =>  247:33:12
+  :END:
+	- https://www.bilibili.com/video/BV1dA411U7or
+	- [[JVM主要组成部分]]
+	- [[JVM内存结构]]
+	- [[垃圾回收算法]]
+	- [[垃圾回收器]]
+	- [[JVM调优]]
+	- [[JDK自带调优工具]]
+	- [[生产环境OOM问题]]
+	- [[生产环境CPU飙高问题]]
+	- [[类加载机制]]
+	- [[对象完整创建流程]]
+	- [[对象分配内存时的指针碰撞和空闲列表机制]]
+	- [[对象头]]
+	- [[对象分配内存时的并发问题解决CAS与TLAB机制]]
+	- [[如何计算对象占用内存大小]]
+	- [[对象指针压缩]]
+	- [[栈上分配，逃逸分析，标量替换]]
+	- [[引用计数法有什么问题]]
+	- [[GC Root可达性分析法]]
+	- [[什么样的类能被回收]]
+	- [[JVM内部各种垃圾收集算法]]
+	- [[CMS垃圾回收过程]]
+	- [[CMS比较严重的问题并发收集阶段再次触发Full GC]]
+	- [[垃圾收集底层三色标记算法]]
+	- [[G1垃圾收集过程]]
+	- [[G1收集器最大停顿时间时如何实现的]]
+	- [[内存泄漏如何排查和解决]]
+	- [[GC什么时候都能做吗，GC安全点和安全区域]]
+	- [[字符串常量池]]
+	- [[基本类型包装类常量池如何实现的]]
+	- 堆的分代
+		- 年轻代minor gc
+			- Eden
+			- S0
+			- S1
+		- 老年代full gc
+	- 可达性分析法
+		- GCRoots，以root为节点分析引用的对象
+	- jvisualvm
+		- 双击进去查看内部的运行情况
+	- arthas
+		- java -jar运行jar包
+		- dashboard
+		- thread 线程号
+			- 定位代码运行位置
+		- thread -b
+			- 查看死锁
+		- jad
+			- 反编译代码
+		- ognl
+			- 修改线上系统变量的值
+	- STW机制
+		- 用户线程会被暂停
+	- 电商网站
+		- 有压力频繁full gc
+		- 亿级流量电商
+			- 每个用户平均点击20，30次
+			- 日活用户500万
+			- 付费转换率10%
+			- 日均50万单
+			- 大促在抢购前几分钟产生
+			- 每秒1000多单
+		- 4核8G部署 300单/秒
+			- 一个订单对象1KB
+			- 每秒300KB订单
+			- 其他对象放大20倍
+			- eden800M，s0，s1，100M，old2G
+			- 一秒产生60M对象，运行14秒占满eden
+			- 因为动态对象年龄，每秒60M对象直接移动到老年代
+	- 能够对JVM调优，让其不发生Full GC
+		- 可以，调大新生代的区域大小，让清理的时间延长
+	- 长期存活对象移动到老年代
+		- 动态对象年龄
+			- 一批对象的总大小大于这块susrvivor区域内存大小的50%，大于等于这批对象年龄最大值的对象可以直接进入老年代
+			-
--- a/logseq-java/logseq/bak/journals/2023_10_22/2023-10-31T14_53_02.945Z.ios.md
+++ b/logseq-java/logseq/bak/journals/2023_10_22/2023-10-31T14_53_02.945Z.ios.md
@@ -0,0 +1,26 @@
+- DOING SSM框架
+  :LOGBOOK:
+  CLOCK: [2023-10-22 Sun 19:56:32]
+  :END:
+	- [【冒死上传】比啃书强十倍！23年最牛SSM框架面试教程（SpringBoot+SpringMvc+Mybatis）高质量夺命连环47问|完整版-允许白嫖！！_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1hh4y1q7je/)
+	- Spring中定义Bean的方式 #card
+		- 使用@Bean
+		- 使用@Component
+		- 使用@Controller，@Service，@Repository
+		- 使用@Configuration
+		- 使用@Import(.class)导入
+		- 使用@ControllerAdevice、@RestControllerAdvice
+			- 底层不是用的Spring AOP那套，Spring MVC自己实现了
+		- 使用BeanDefination
+		- xml配置\<bean/>标签
+			- @ImportResource(classpath:spring.xml)
+	- Spring的自动配置 #card
+		- 使用SpringBoot时会引入一个starter包，间接引用spring-boot-autoconfigure的包，里面有各种各样的配置类，里面配置了各种Bean
+		- @SpringBootApplication注解，内部有三个注解
+			- @SpringBootConfiguration
+			- @EnableAutoConfiguration，自动配置的开关，正常情况下我们的应用程序不会扫描SpringBootConfigure这个包的路径文件，开启了这个注解才会
+			- @ComponentScan
+	- {{embed [[#{} 与 ${} 的区别]]}}
+	- ApplicationContext和BeanFactory有什么区别
+		- 都是接口，分别代表应用容器和Bean工厂
+		- Application继承了BeanFactory，有BeanFactory的全部功能，也是一个Bean工厂，还继承了其它接口并增加了国际化，事件发布，加载资源文件，获取系统环境变量等功能