Merge branch 'Snailclimb:master' into master

docs/java/basis/Java基础知识疑难点.md

@@ -376,7 +376,7 @@ s=list.toArray(new String[0]);//没有指定类型的话会报错
 
 如果要进行`remove`操作，可以调用迭代器的 `remove `方法而不是集合类的 remove 方法。因为如果列表在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身`remove/add`方法，迭代器都将抛出一个`ConcurrentModificationException`,这就是单线程状态下产生的 **fail-fast 机制**。
 
-> **fail-fast 机制** ：多个线程对 fail-fast 集合进行修改的时，可能会抛出ConcurrentModificationException，单线程下也会出现这种情况，上面已经提到过。
+> **fail-fast 机制** ：多个线程对 fail-fast 集合进行修改的时候，可能会抛出ConcurrentModificationException，单线程下也会出现这种情况，上面已经提到过。
 
 Java8开始，可以使用`Collection#removeIf()`方法删除满足特定条件的元素,如
 ``` java

docs/java/basis/Java常见关键字总结.md

@@ -23,63 +23,63 @@
 
 ## final 关键字
 
-**final关键字，意思是最终的、不可修改的，最见不得变化 ，用来修饰类、方法和变量，具有以下特点：**
+**final 关键字，意思是最终的、不可修改的，最见不得变化 ，用来修饰类、方法和变量，具有以下特点：**
 
-1. **final修饰的类不能被继承，final类中的所有成员方法都会被隐式的指定为final方法；**
+1. **final 修饰的类不能被继承，final 类中的所有成员方法都会被隐式的指定为 final 方法；**
 
-2. **final修饰的方法不能被重写；**
+2. **final 修饰的方法不能被重写；**
 
-3. **final修饰的变量是常量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。**
+3. **final 修饰的变量是常量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。**
 
-说明：使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
+说明：使用 final 方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的 Java 实现版本中，会将 final 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的 Java 版本已经不需要使用 final 方法进行这些优化了）。类中所有的 private 方法都隐式地指定为 final。
 
 ## static 关键字
 
 **static 关键字主要有以下四种使用场景：**
 
-1. **修饰成员变量和成员方法:** 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。调用格式：`类名.静态变量名`    `类名.静态方法名()`
+1. **修饰成员变量和成员方法:** 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被 static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。调用格式：`类名.静态变量名` `类名.静态方法名()`
 2. **静态代码块:** 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次.
-3. **静态内部类（static修饰类的话只能修饰内部类）：** 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
+3. **静态内部类（static 修饰类的话只能修饰内部类）：** 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非 static 成员变量和方法。
-4. **静态导包(用来导入类中的静态资源，1.5之后的新特性):** 格式为：`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。
+4. **静态导包(用来导入类中的静态资源，1.5 之后的新特性):** 格式为：`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。
 
 ## this 关键字
 
-this关键字用于引用类的当前实例。 例如：
+this 关键字用于引用类的当前实例。 例如：
 
 ```java
 class Manager {
     Employees[] employees;
-     
+
     void manageEmployees() {
         int totalEmp = this.employees.length;
         System.out.println("Total employees: " + totalEmp);
         this.report();
     }
-     
+
     void report() { }
 }
 ```
 
-在上面的示例中，this关键字用于两个地方：
+在上面的示例中，this 关键字用于两个地方：
 
-- this.employees.length：访问类Manager的当前实例的变量。
+- this.employees.length：访问类 Manager 的当前实例的变量。
-- this.report（）：调用类Manager的当前实例的方法。
+- this.report（）：调用类 Manager 的当前实例的方法。
 
 此关键字是可选的，这意味着如果上面的示例在不使用此关键字的情况下表现相同。 但是，使用此关键字可能会使代码更易读或易懂。
 
 ## super 关键字
 
-super关键字用于从子类访问父类的变量和方法。 例如：
+super 关键字用于从子类访问父类的变量和方法。 例如：
 
 ```java
 public class Super {
     protected int number;
-     
+
     protected showNumber() {
         System.out.println("number = " + number);
     }
 }
- 
+
 public class Sub extends Super {
     void bar() {
         super.number = 10;
@@ -88,16 +88,16 @@ public class Sub extends Super {
 }
 ```
 
-在上面的例子中，Sub 类访问父类成员变量 number 并调用其其父类 Super 的 `showNumber（）` 方法。
+在上面的例子中，Sub 类访问父类成员变量 number 并调用其父类 Super 的 `showNumber（）` 方法。
 
 **使用 this 和 super 要注意的问题：**
 
 - 在构造器中使用 `super()` 调用父类中的其他构造方法时，该语句必须处于构造器的首行，否则编译器会报错。另外，this 调用本类中的其他构造方法时，也要放在首行。
-- this、super不能用在static方法中。
+- this、super 不能用在 static 方法中。
 
 **简单解释一下：**
 
-被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而 this 代表对本类对象的引用，指向本类对象；而 super 代表对父类对象的引用，指向父类对象；所以， **this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西**。
+被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而 this 代表对本类对象的引用，指向本类对象；而 super 代表对父类对象的引用，指向父类对象；所以， **this 和 super 是属于对象范畴的东西，而静态方法是属于类范畴的东西**。
 
 ## 参考
 
@@ -111,15 +111,15 @@ public class Sub extends Super {
 1. 修饰成员变量和成员方法
 2. 静态代码块
 3. 修饰类(只能修饰内部类)
-4. 静态导包(用来导入类中的静态资源，1.5之后的新特性)
+4. 静态导包(用来导入类中的静态资源，1.5 之后的新特性)
 
 ### 修饰成员变量和成员方法(常用)
 
-被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。
+被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被 static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。
 
-方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目的应该是与 Java 堆区分开来。
+方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目的应该是与 Java 堆区分开来。
 
- HotSpot 虚拟机中方法区也常被称为 “永久代”，本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已，这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意，因为这样更容易遇到内存溢出问题。
+HotSpot 虚拟机中方法区也常被称为 “永久代”，本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已，这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意，因为这样更容易遇到内存溢出问题。
 
 调用格式：
 
@@ -170,44 +170,40 @@ public class StaticDemo {
 }
 ```
 
-
 ### 静态代码块
 
 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块 —> 非静态代码块 —> 构造方法)。 该类不管创建多少对象，静态代码块只执行一次.
 
-静态代码块的格式是 
+静态代码块的格式是
 
 ```
-static {    
+static {
-语句体;   
+语句体;
 }
 ```
 
-
+一个类中的静态代码块可以有多个，位置可以随便放，它不在任何的方法体内，JVM 加载类时会执行这些静态的代码块，如果静态代码块有多个，JVM 将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
-一个类中的静态代码块可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果静态代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
 
 ![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-14/88531075.jpg)
 
 静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问.
 
-
 ### 静态内部类
 
 静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：
 
 1.  它的创建是不需要依赖外围类的创建。
-2.  它不能使用任何外围类的非static成员变量和方法。
+2.  它不能使用任何外围类的非 static 成员变量和方法。
-
 
 Example（静态内部类实现单例模式）
 
 ```java
 public class Singleton {
-    
+
     //声明为 private 避免调用默认构造方法创建对象
     private Singleton() {
     }
-    
+
    // 声明为 private 表明静态内部该类只能在该 Singleton 类中被访问
     private static class SingletonHolder {
         private static final Singleton INSTANCE = new Singleton();
@@ -219,13 +215,13 @@ public class Singleton {
 }
 ```
 
-当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance() `方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
+当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()`方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
 
 这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
 
 ### 静态导包
 
-格式为：import static 
+格式为：import static
 
 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法
 
@@ -234,12 +230,12 @@ public class Singleton {
 
  //将Math中的所有静态资源导入，这时候可以直接使用里面的静态方法，而不用通过类名进行调用
  //如果只想导入单一某个静态方法，只需要将*换成对应的方法名即可
- 
+
 import static java.lang.Math.*;//换成import static java.lang.Math.max;具有一样的效果
- 
+
 public class Demo {
   public static void main(String[] args) {
- 
+
     int max = max(1,2);
     System.out.println(max);
   }
@@ -247,8 +243,7 @@ public class Demo {
 
 ```
 
-
+## 补充内容
-##  补充内容
 
 ### 静态方法与非静态方法
 
@@ -259,13 +254,13 @@ Example
 ```java
 class Foo {
     int i;
-    public Foo(int i) { 
+    public Foo(int i) {
        this.i = i;
     }
 
     public static String method1() {
        return "An example string that doesn't depend on i (an instance variable)";
-       
+
     }
 
     public int method2() {
@@ -274,26 +269,28 @@ class Foo {
 
 }
 ```
+
 你可以像这样调用静态方法：`Foo.method1()`。 如果您尝试使用这种方法调用 method2 将失败。 但这样可行
-``` java
+
+```java
 Foo bar = new Foo(1);
 bar.method2();
 ```
 
 总结：
 
-- 在外部调用静态方法时，可以使用”类名.方法名”的方式，也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。 
+- 在外部调用静态方法时，可以使用”类名.方法名”的方式，也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
-- 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制 
+- 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制
 
 ### `static{}`静态代码块与`{}`非静态代码块(构造代码块)
 
-相同点： 都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，定义多个时按定义的顺序执行，一般在代码块中对一些static变量进行赋值。 
+相同点： 都是在 JVM 加载类时且在构造方法执行之前执行，在类中都可以定义多个，定义多个时按定义的顺序执行，一般在代码块中对一些 static 变量进行赋值。
 
-不同点： 静态代码块在非静态代码块之前执行(静态代码块 -> 非静态代码块 -> 构造方法)。静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new一次就执行一次。 非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。
+不同点： 静态代码块在非静态代码块之前执行(静态代码块 -> 非静态代码块 -> 构造方法)。静态代码块只在第一次 new 执行一次，之后不再执行，而非静态代码块在每 new 一次就执行一次。 非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。
 
-> **🐛 修正（参见： [issue #677](https://github.com/Snailclimb/JavaGuide/issues/677)）** ：静态代码块可能在第一次new的时候执行，但不一定只在第一次new的时候执行。比如通过 `Class.forName("ClassDemo")`创建 Class 对象的时候也会执行。
+> **🐛 修正（参见： [issue #677](https://github.com/Snailclimb/JavaGuide/issues/677)）** ：静态代码块可能在第一次 new 对象的时候执行，但不一定只在第一次 new 的时候执行。比如通过 `Class.forName("ClassDemo")`创建 Class 对象的时候也会执行，即 new 或者 `Class.forName("ClassDemo")` 都会执行静态代码块。
 
-一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法，例如：Arrays类，Character类，String类等，就需要使用静态方法, 两者的区别是 静态代码块是自动执行的而静态方法是被调用的时候才执行的. 
+一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法，例如：`Arrays` 类，`Character` 类，`String` 类等，就需要使用静态方法, 两者的区别是 静态代码块是自动执行的而静态方法是被调用的时候才执行的.
 
 Example：
 
@@ -346,8 +343,7 @@ public class Test {
 静态代码块！--非静态代码块！--默认构造方法！--
 ```
 
-
+非静态代码块与构造函数的区别是： 非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。
-非静态代码块与构造函数的区别是： 非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。 
 
 ### 参考
 

docs/java/collection/HashMap(JDK1.8)源码+底层数据结构分析.md

@@ -1,4 +1,3 @@
-
 <!-- @import "[TOC]" {cmd="toc" depthFrom=1 depthTo=6 orderedList=false} -->
 
 <!-- code_chunk_output -->
@@ -21,14 +20,13 @@
 
 ## HashMap 简介
 
-HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一。
+HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一，是非线程安全的。
 
-JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。
+ `HashMap` 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个
 
-JDK1.8 之后 HashMap 的组成多了红黑树，在满足下面两个条件之后，会执行链表转红黑树操作，以此来加快搜索速度。
+JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。 JDK1.8 以后的 `HashMap` 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。
 
-- 链表长度大于阈值（默认为 8）
+`HashMap` 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。并且， `HashMap` 总是使用 2 的幂作为哈希表的大小
-- HashMap 数组长度超过 64
 
 ## 底层数据结构分析
 
@@ -574,5 +572,4 @@ public class HashMapDemo {
     }
 
 }
-
 ```

docs/operating-system/Shell.md

@@ -234,12 +234,16 @@ echo ${str:0:10} #输出:SnailClimb
 #author:amau
 
 var="https://www.runoob.com/linux/linux-shell-variable.html"
-
+# %表示删除从后匹配, 最短结果
-s1=${var%%t*}#h
+# %%表示删除从后匹配, 最长匹配结果
-s2=${var%t*}#https://www.runoob.com/linux/linux-shell-variable.h
+# #表示删除从头匹配, 最短结果
-s3=${var%%.*}#http://www
+# ##表示删除从头匹配, 最长匹配结果
-s4=${var#*/}#/www.runoob.com/linux/linux-shell-variable.html
+# 注: *为通配符, 意为匹配任意数量的任意字符
-s5=${var##*/}#linux-shell-variable.html
+s1=${var%%t*} #h
+s2=${var%t*}  #https://www.runoob.com/linux/linux-shell-variable.h
+s3=${var%%.*} #http://www
+s4=${var#*/}  #/www.runoob.com/linux/linux-shell-variable.html
+s5=${var##*/} #linux-shell-variable.html
 ```
 
 ### Shell 数组

docs/system-design/framework/mybatis/mybatis-interview.md

@@ -197,14 +197,14 @@ public V get(Object key) {
 
 举例：下面 join 查询出来 6 条记录，一、二列是 Teacher 对象列，第三列为 Student 对象列，MyBatis 去重复处理后，结果为 1 个老师 6 个学生，而不是 6 个老师 6 个学生。
 
- t_id t_name s_id
+| t_id | t_name  | s_id |
-
+| ---- | ------- | ---- |
-| 1 | teacher | 38 |
+| 1    | teacher | 38   |
-| 1 | teacher | 39 |
+| 1    | teacher | 39   |
-| 1 | teacher | 40 |
+| 1    | teacher | 40   |
-| 1 | teacher | 41 |
+| 1    | teacher | 41   |
-| 1 | teacher | 42 |
+| 1    | teacher | 42   |
-| 1 | teacher | 43 |
+| 1    | teacher | 43   |
 
 #### 10、MyBatis 是否支持延迟加载？如果支持，它的实现原理是什么？
 
@@ -238,7 +238,7 @@ public V get(Object key) {
 
 **`SimpleExecutor`：**每执行一次 update 或 select，就开启一个 Statement 对象，用完立刻关闭 Statement 对象。
 
-**``ReuseExecutor`：**执行 update 或 select，以 sql 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map<String, Statement>内，供下一次使用。简言之，就是重复使用 Statement 对象。
+**`ReuseExecutor`：**执行 update 或 select，以 sql 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map<String, Statement>内，供下一次使用。简言之，就是重复使用 Statement 对象。
 
 **`BatchExecutor`：**执行 update（没有 select，JDBC 批处理不支持 select），将所有 sql 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch()完毕后，等待逐一执行 executeBatch()批处理。与 JDBC 批处理相同。