From 7bbf41cdcf7cab4589b7036789daa9a49951f1d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=AE=E4=BF=A1=E5=85=AC=E4=BC=97=E5=8F=B7=EF=BC=9A?=
=?UTF-8?q?=E7=A8=8B=E5=BA=8F=E5=91=98=E4=B9=94=E6=88=88=E9=87=8C?=
<990878733@qq.com>
Date: Thu, 29 Aug 2019 18:21:15 +0800
Subject: [PATCH 001/259] =?UTF-8?q?Update=20Leetcode=20=E9=A2=98=E8=A7=A3?=
=?UTF-8?q?=20-=20=E6=90=9C=E7=B4=A2.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\351\242\230\350\247\243 - \346\220\234\347\264\242.md" | 7 -------
1 file changed, 7 deletions(-)
diff --git "a/\347\237\245\350\257\206\347\202\271\346\225\264\347\220\206/notes/Leetcode \351\242\230\350\247\243 - \346\220\234\347\264\242.md" "b/\347\237\245\350\257\206\347\202\271\346\225\264\347\220\206/notes/Leetcode \351\242\230\350\247\243 - \346\220\234\347\264\242.md"
index 0437af64..df4884ca 100644
--- "a/\347\237\245\350\257\206\347\202\271\346\225\264\347\220\206/notes/Leetcode \351\242\230\350\247\243 - \346\220\234\347\264\242.md"
+++ "b/\347\237\245\350\257\206\347\202\271\346\225\264\347\220\206/notes/Leetcode \351\242\230\350\247\243 - \346\220\234\347\264\242.md"
@@ -1271,10 +1271,3 @@ private void backtracking(int row) {
-# 微信公众号
-
-
-更多精彩内容将发布在微信公众号 CyC2018 上，你也可以在公众号后台和我交流学习和求职相关的问题。另外，公众号提供了该项目的 PDF 等离线阅读版本，后台回复 "下载" 即可领取。公众号也提供了一份技术面试复习大纲，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点，后台回复 "大纲" 即可领取。我基本是按照这个大纲来进行复习的，对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
-
-
-
- implements MyQueue
- {
```
-
-
-# 微信公众号
-
-
-更多精彩内容将发布在微信公众号 CyC2018 上，你也可以在公众号后台和我交流学习和求职相关的问题。另外，公众号提供了该项目的 PDF 等离线阅读版本，后台回复 "下载" 即可领取。公众号也提供了一份技术面试复习大纲，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点，后台回复 "大纲" 即可领取。我基本是按照这个大纲来进行复习的，对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
-
-
-
-
-
-# 微信公众号
-
-
-更多精彩内容将发布在微信公众号 CyC2018 上，你也可以在公众号后台和我交流学习和求职相关的问题。另外，公众号提供了该项目的 PDF 等离线阅读版本，后台回复 "下载" 即可领取。公众号也提供了一份技术面试复习大纲，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点，后台回复 "大纲" 即可领取。我基本是按照这个大纲来进行复习的，对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
-
-
-
-
-**3. 安全性**
-
-String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
-
-**4. 线程安全**
-
-String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
-
-[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
-
-## String, StringBuffer and StringBuilder
-
-**1. 可变性**
-
-- String 不可变
-- StringBuffer 和 StringBuilder 可变
-
-**2. 线程安全**
-
-- String 不可变，因此是线程安全的
-- StringBuilder 不是线程安全的
-- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
-
-[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
-
-## String Pool
-
-字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
-
-当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
-
-下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
-
-```java
-String s1 = new String("aaa");
-String s2 = new String("aaa");
-System.out.println(s1 == s2); // false
-String s3 = s1.intern();
-String s4 = s1.intern();
-System.out.println(s3 == s4); // true
-```
-
-如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
-
-```java
-String s5 = "bbb";
-String s6 = "bbb";
-System.out.println(s5 == s6); // true
-```
-
-在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
-
-- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
-- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
-
-## new String("abc")
-
-使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
-
-- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
-- 而使用 new 的方式会在堆中创建一个字符串对象。
-
-创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
-
-```java
-public class NewStringTest {
- public static void main(String[] args) {
- String s = new String("abc");
- }
-}
-```
-
-使用 javap -verbose 进行反编译，得到以下内容：
-
-```java
-// ...
-Constant pool:
-// ...
- #2 = Class #18 // java/lang/String
- #3 = String #19 // abc
-// ...
- #18 = Utf8 java/lang/String
- #19 = Utf8 abc
-// ...
-
- public static void main(java.lang.String[]);
- descriptor: ([Ljava/lang/String;)V
- flags: ACC_PUBLIC, ACC_STATIC
- Code:
- stack=3, locals=2, args_size=1
- 0: new #2 // class java/lang/String
- 3: dup
- 4: ldc #3 // String abc
- 6: invokespecial #4 // Method java/lang/String."":(Ljava/lang/String;)V
- 9: astore_1
-// ...
-```
-
-在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
-
-以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
-
-```java
-public String(String original) {
- this.value = original.value;
- this.hash = original.hash;
-}
-```
-
-# 三、运算
-
-## 参数传递
-
-Java 的参数是以值传递的形式传入方法中，而不是引用传递。
-
-以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
-
-```java
-public class Dog {
-
- String name;
-
- Dog(String name) {
- this.name = name;
- }
-
- String getName() {
- return this.name;
- }
-
- void setName(String name) {
- this.name = name;
- }
-
- String getObjectAddress() {
- return super.toString();
- }
-}
-```
-
-```java
-public class PassByValueExample {
- public static void main(String[] args) {
- Dog dog = new Dog("A");
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- func(dog);
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- System.out.println(dog.getName()); // A
- }
-
- private static void func(Dog dog) {
- System.out.println(dog.getObjectAddress()); // Dog@4554617c
- dog = new Dog("B");
- System.out.println(dog.getObjectAddress()); // Dog@74a14482
- System.out.println(dog.getName()); // B
- }
-}
-```
-
-如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。
-
-```java
-class PassByValueExample {
- public static void main(String[] args) {
- Dog dog = new Dog("A");
- func(dog);
- System.out.println(dog.getName()); // B
- }
-
- private static void func(Dog dog) {
- dog.setName("B");
- }
-}
-```
-
-[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
-
-## float 与 double
-
-Java 不能隐式执行向下转型，因为这会使得精度降低。
-
-1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
-
-```java
-// float f = 1.1;
-```
-
-1.1f 字面量才是 float 类型。
-
-```java
-float f = 1.1f;
-```
-
-## 隐式类型转换
-
-因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
-
-```java
-short s1 = 1;
-// s1 = s1 + 1;
-```
-
-但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
-
-```java
-s1 += 1;
-// s1++;
-```
-
-上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
-
-```java
-s1 = (short) (s1 + 1);
-```
-
-[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
-
-## switch
-
-从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
-
-```java
-String s = "a";
-switch (s) {
- case "a":
- System.out.println("aaa");
- break;
- case "b":
- System.out.println("bbb");
- break;
-}
-```
-
-switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
-
-```java
-// long x = 111;
-// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
-// case 111:
-// System.out.println(111);
-// break;
-// case 222:
-// System.out.println(222);
-// break;
-// }
-```
-
-[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
-
-# 四、继承
-
-## 访问权限
-
-Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
-
-可以对类或类中的成员（字段以及方法）加上访问修饰符。
-
-- 类可见表示其它类可以用这个类创建实例对象。
-- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
-
-protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
-
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
-
-如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
-
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
-
-```java
-public class AccessExample {
- public String id;
-}
-```
-
-可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
-
-```java
-public class AccessExample {
-
- private int id;
-
- public String getId() {
- return id + "";
- }
-
- public void setId(String id) {
- this.id = Integer.valueOf(id);
- }
-}
-```
-
-但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
-
-```java
-public class AccessWithInnerClassExample {
-
- private class InnerClass {
- int x;
- }
-
- private InnerClass innerClass;
-
- public AccessWithInnerClassExample() {
- innerClass = new InnerClass();
- }
-
- public int getValue() {
- return innerClass.x; // 直接访问
- }
-}
-```
-
-## 抽象类与接口
-
-**1. 抽象类**
-
-抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法，那么这个类必须声明为抽象类。
-
-抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
-
-```java
-public abstract class AbstractClassExample {
-
- protected int x;
- private int y;
-
- public abstract void func1();
-
- public void func2() {
- System.out.println("func2");
- }
-}
-```
-
-```java
-public class AbstractExtendClassExample extends AbstractClassExample {
- @Override
- public void func1() {
- System.out.println("func1");
- }
-}
-```
-
-```java
-// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
-AbstractClassExample ac2 = new AbstractExtendClassExample();
-ac2.func1();
-```
-
-**2. 接口**
-
-接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
-
-从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
-
-接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
-
-接口的字段默认都是 static 和 final 的。
-
-```java
-public interface InterfaceExample {
-
- void func1();
-
- default void func2(){
- System.out.println("func2");
- }
-
- int x = 123;
- // int y; // Variable 'y' might not have been initialized
- public int z = 0; // Modifier 'public' is redundant for interface fields
- // private int k = 0; // Modifier 'private' not allowed here
- // protected int l = 0; // Modifier 'protected' not allowed here
- // private void fun3(); // Modifier 'private' not allowed here
-}
-```
-
-```java
-public class InterfaceImplementExample implements InterfaceExample {
- @Override
- public void func1() {
- System.out.println("func1");
- }
-}
-```
-
-```java
-// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
-InterfaceExample ie2 = new InterfaceImplementExample();
-ie2.func1();
-System.out.println(InterfaceExample.x);
-```
-
-**3. 比较**
-
-- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
-- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
-- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
-- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
-
-**4. 使用选择**
-
-使用接口：
-
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
-- 需要使用多重继承。
-
-使用抽象类：
-
-- 需要在几个相关的类中共享代码。
-- 需要能控制继承来的成员的访问权限，而不是都为 public。
-- 需要继承非静态和非常量字段。
-
-在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
-
-- [Abstract Methods and Classes](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
-- [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/)
-- [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
-
-
-## super
-
-- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
-- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
-
-```java
-public class SuperExample {
-
- protected int x;
- protected int y;
-
- public SuperExample(int x, int y) {
- this.x = x;
- this.y = y;
- }
-
- public void func() {
- System.out.println("SuperExample.func()");
- }
-}
-```
-
-```java
-public class SuperExtendExample extends SuperExample {
-
- private int z;
-
- public SuperExtendExample(int x, int y, int z) {
- super(x, y);
- this.z = z;
- }
-
- @Override
- public void func() {
- super.func();
- System.out.println("SuperExtendExample.func()");
- }
-}
-```
-
-```java
-SuperExample e = new SuperExtendExample(1, 2, 3);
-e.func();
-```
-
-```html
-SuperExample.func()
-SuperExtendExample.func()
-```
-
-[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
-
-## 重写与重载
-
-**1. 重写（Override）**
-
-存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
-
-为了满足里式替换原则，重写有以下三个限制：
-
-- 子类方法的访问权限必须大于等于父类方法；
-- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
-- 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
-
-使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
-
-下面的示例中，SubClass 为 SuperClass 的子类，SubClass 重写了 SuperClass 的 func() 方法。其中：
-
-- 子类方法访问权限为 public，大于父类的 protected。
-- 子类的返回类型为 ArrayList，是父类返回类型 List 的子类。
-- 子类抛出的异常类型为 Exception，是父类抛出异常 Throwable 的子类。
-- 子类重写方法使用 @Override 注解，从而让编译器自动检查是否满足限制条件。
-
-```java
-class SuperClass {
- protected List func() throws Throwable {
- return new ArrayList<>();
- }
-}
-
-class SubClass extends SuperClass {
- @Override
- public ArrayList func() throws Exception {
- return new ArrayList<>();
- }
-}
-```
-
-在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：
-
-- this.func(this)
-- super.func(this)
-- this.func(super)
-- super.func(super)
-
-
-```java
-/*
- A
- |
- B
- |
- C
- |
- D
- */
-
-
-class A {
-
- public void show(A obj) {
- System.out.println("A.show(A)");
- }
-
- public void show(C obj) {
- System.out.println("A.show(C)");
- }
-}
-
-class B extends A {
-
- @Override
- public void show(A obj) {
- System.out.println("B.show(A)");
- }
-}
-
-class C extends B {
-}
-
-class D extends C {
-}
-```
-
-```java
-public static void main(String[] args) {
-
- A a = new A();
- B b = new B();
- C c = new C();
- D d = new D();
-
- // 在 A 中存在 show(A obj)，直接调用
- a.show(a); // A.show(A)
- // 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
- a.show(b); // A.show(A)
- // 在 B 中存在从 A 继承来的 show(C obj)，直接调用
- b.show(c); // A.show(C)
- // 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
- b.show(d); // A.show(C)
-
- // 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
- A ba = new B();
- ba.show(c); // A.show(C)
- ba.show(d); // A.show(C)
-}
-```
-
-**2. 重载（Overload）**
-
-存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
-
-应该注意的是，返回值不同，其它都相同不算是重载。
-
-# 五、Object 通用方法
-
-## 概览
-
-```java
-
-public native int hashCode()
-
-public boolean equals(Object obj)
-
-protected native Object clone() throws CloneNotSupportedException
-
-public String toString()
-
-public final native Class getClass()
-
-protected void finalize() throws Throwable {}
-
-public final native void notify()
-
-public final native void notifyAll()
-
-public final native void wait(long timeout) throws InterruptedException
-
-public final void wait(long timeout, int nanos) throws InterruptedException
-
-public final void wait() throws InterruptedException
-```
-
-## equals()
-
-**1. 等价关系**
-
-Ⅰ 自反性
-
-```java
-x.equals(x); // true
-```
-
-Ⅱ 对称性
-
-```java
-x.equals(y) == y.equals(x); // true
-```
-
-Ⅲ 传递性
-
-```java
-if (x.equals(y) && y.equals(z))
- x.equals(z); // true;
-```
-
-Ⅳ 一致性
-
-多次调用 equals() 方法结果不变
-
-```java
-x.equals(y) == x.equals(y); // true
-```
-
-Ⅴ 与 null 的比较
-
-对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
-
-```java
-x.equals(null); // false;
-```
-
-**2. 等价与相等**
-
-- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
-- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
-
-```java
-Integer x = new Integer(1);
-Integer y = new Integer(1);
-System.out.println(x.equals(y)); // true
-System.out.println(x == y); // false
-```
-
-**3. 实现**
-
-- 检查是否为同一个对象的引用，如果是直接返回 true；
-- 检查是否是同一个类型，如果不是，直接返回 false；
-- 将 Object 对象进行转型；
-- 判断每个关键域是否相等。
-
-```java
-public class EqualExample {
-
- private int x;
- private int y;
- private int z;
-
- public EqualExample(int x, int y, int z) {
- this.x = x;
- this.y = y;
- this.z = z;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
-
- EqualExample that = (EqualExample) o;
-
- if (x != that.x) return false;
- if (y != that.y) return false;
- return z == that.z;
- }
-}
-```
-
-## hashCode()
-
-hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
-
-在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
-
-下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hashCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
-
-```java
-EqualExample e1 = new EqualExample(1, 1, 1);
-EqualExample e2 = new EqualExample(1, 1, 1);
-System.out.println(e1.equals(e2)); // true
-HashSet set = new HashSet<>();
-set.add(e1);
-set.add(e2);
-System.out.println(set.size()); // 2
-```
-
-理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
-
-一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
-
-```java
-@Override
-public int hashCode() {
- int result = 17;
- result = 31 * result + x;
- result = 31 * result + y;
- result = 31 * result + z;
- return result;
-}
-```
-
-## toString()
-
-默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
-
-```java
-public class ToStringExample {
-
- private int number;
-
- public ToStringExample(int number) {
- this.number = number;
- }
-}
-```
-
-```java
-ToStringExample example = new ToStringExample(123);
-System.out.println(example.toString());
-```
-
-```html
-ToStringExample@4554617c
-```
-
-## clone()
-
-**1. cloneable**
-
-clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
-
-```java
-public class CloneExample {
- private int a;
- private int b;
-}
-```
-
-```java
-CloneExample e1 = new CloneExample();
-// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
-```
-
-重写 clone() 得到以下实现：
-
-```java
-public class CloneExample {
- private int a;
- private int b;
-
- @Override
- public CloneExample clone() throws CloneNotSupportedException {
- return (CloneExample)super.clone();
- }
-}
-```
-
-```java
-CloneExample e1 = new CloneExample();
-try {
- CloneExample e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
-}
-```
-
-```html
-java.lang.CloneNotSupportedException: CloneExample
-```
-
-以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
-
-应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
-
-```java
-public class CloneExample implements Cloneable {
- private int a;
- private int b;
-
- @Override
- public Object clone() throws CloneNotSupportedException {
- return super.clone();
- }
-}
-```
-
-**2. 浅拷贝**
-
-拷贝对象和原始对象的引用类型引用同一个对象。
-
-```java
-public class ShallowCloneExample implements Cloneable {
-
- private int[] arr;
-
- public ShallowCloneExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
-
- public void set(int index, int value) {
- arr[index] = value;
- }
-
- public int get(int index) {
- return arr[index];
- }
-
- @Override
- protected ShallowCloneExample clone() throws CloneNotSupportedException {
- return (ShallowCloneExample) super.clone();
- }
-}
-```
-
-```java
-ShallowCloneExample e1 = new ShallowCloneExample();
-ShallowCloneExample e2 = null;
-try {
- e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
-}
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 222
-```
-
-**3. 深拷贝**
-
-拷贝对象和原始对象的引用类型引用不同对象。
-
-```java
-public class DeepCloneExample implements Cloneable {
-
- private int[] arr;
-
- public DeepCloneExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
-
- public void set(int index, int value) {
- arr[index] = value;
- }
-
- public int get(int index) {
- return arr[index];
- }
-
- @Override
- protected DeepCloneExample clone() throws CloneNotSupportedException {
- DeepCloneExample result = (DeepCloneExample) super.clone();
- result.arr = new int[arr.length];
- for (int i = 0; i < arr.length; i++) {
- result.arr[i] = arr[i];
- }
- return result;
- }
-}
-```
-
-```java
-DeepCloneExample e1 = new DeepCloneExample();
-DeepCloneExample e2 = null;
-try {
- e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
- e.printStackTrace();
-}
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 2
-```
-
-**4. clone() 的替代方案**
-
-使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
-
-```java
-public class CloneConstructorExample {
-
- private int[] arr;
-
- public CloneConstructorExample() {
- arr = new int[10];
- for (int i = 0; i < arr.length; i++) {
- arr[i] = i;
- }
- }
-
- public CloneConstructorExample(CloneConstructorExample original) {
- arr = new int[original.arr.length];
- for (int i = 0; i < original.arr.length; i++) {
- arr[i] = original.arr[i];
- }
- }
-
- public void set(int index, int value) {
- arr[index] = value;
- }
-
- public int get(int index) {
- return arr[index];
- }
-}
-```
-
-```java
-CloneConstructorExample e1 = new CloneConstructorExample();
-CloneConstructorExample e2 = new CloneConstructorExample(e1);
-e1.set(2, 222);
-System.out.println(e2.get(2)); // 2
-```
-
-# 六、关键字
-
-## final
-
-**1. 数据**
-
-声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
-
-- 对于基本类型，final 使数值不变；
-- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
-
-```java
-final int x = 1;
-// x = 2; // cannot assign value to final variable 'x'
-final A y = new A();
-y.a = 1;
-```
-
-**2. 方法**
-
-声明方法不能被子类重写。
-
-private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
-
-**3. 类**
-
-声明类不允许被继承。
-
-## static
-
-**1. 静态变量**
-
-- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
-- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
-
-```java
-public class A {
-
- private int x; // 实例变量
- private static int y; // 静态变量
-
- public static void main(String[] args) {
- // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
- A a = new A();
- int x = a.x;
- int y = A.y;
- }
-}
-```
-
-**2. 静态方法**
-
-静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
-
-```java
-public abstract class A {
- public static void func1(){
- }
- // public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
-}
-```
-
-只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
-
-```java
-public class A {
-
- private static int x;
- private int y;
-
- public static void func1(){
- int a = x;
- // int b = y; // Non-static field 'y' cannot be referenced from a static context
- // int b = this.y; // 'A.this' cannot be referenced from a static context
- }
-}
-```
-
-**3. 静态语句块**
-
-静态语句块在类初始化时运行一次。
-
-```java
-public class A {
- static {
- System.out.println("123");
- }
-
- public static void main(String[] args) {
- A a1 = new A();
- A a2 = new A();
- }
-}
-```
-
-```html
-123
-```
-
-**4. 静态内部类**
-
-非静态内部类依赖于外部类的实例，而静态内部类不需要。
-
-```java
-public class OuterClass {
-
- class InnerClass {
- }
-
- static class StaticInnerClass {
- }
-
- public static void main(String[] args) {
- // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
- OuterClass outerClass = new OuterClass();
- InnerClass innerClass = outerClass.new InnerClass();
- StaticInnerClass staticInnerClass = new StaticInnerClass();
- }
-}
-```
-
-静态内部类不能访问外部类的非静态的变量和方法。
-
-**5. 静态导包**
-
-在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
-
-```java
-import static com.xxx.ClassName.*
-```
-
-**6. 初始化顺序**
-
-静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
-
-```java
-public static String staticField = "静态变量";
-```
-
-```java
-static {
- System.out.println("静态语句块");
-}
-```
-
-```java
-public String field = "实例变量";
-```
-
-```java
-{
- System.out.println("普通语句块");
-}
-```
-
-最后才是构造函数的初始化。
-
-```java
-public InitialOrderTest() {
- System.out.println("构造函数");
-}
-```
-
-存在继承的情况下，初始化顺序为：
-
-- 父类（静态变量、静态语句块）
-- 子类（静态变量、静态语句块）
-- 父类（实例变量、普通语句块）
-- 父类（构造函数）
-- 子类（实例变量、普通语句块）
-- 子类（构造函数）
-
-
-# 七、反射
-
-每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
-
-类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
-
-反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
-
-Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
-
-- **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
-- **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
-- **Constructor** ：可以用 Constructor 的 newInstance() 创建新的对象。
-
-**反射的优点：**
-
-* **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
-* **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
-* **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
-
-**反射的缺点：**
-
-尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
-
-* **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
-
-* **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
-
-* **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
-
-
-- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
-- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
-
-# 八、异常
-
-Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
-
-- **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
-- **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
-
- 
-
-- [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
-- [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
-
-# 九、泛型
-
-```java
-public class Box {
- // T stands for "Type"
- private T t;
- public void set(T t) { this.t = t; }
- public T get() { return t; }
-}
-```
-
-- [Java 泛型详解](http://www.importnew.com/24029.html)
-- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
-
-# 十、注解
-
-Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
-
-[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
-
-# 十一、特性
-
-## Java 各版本的新特性
-
-**New highlights in Java SE 8**
-
-1. Lambda Expressions
-2. Pipelines and Streams
-3. Date and Time API
-4. Default Methods
-5. Type Annotations
-6. Nashhorn JavaScript Engine
-7. Concurrent Accumulators
-8. Parallel operations
-9. PermGen Error Removed
-
-**New highlights in Java SE 7**
-
-1. Strings in Switch Statement
-2. Type Inference for Generic Instance Creation
-3. Multiple Exception Handling
-4. Support for Dynamic Languages
-5. Try with Resources
-6. Java nio Package
-7. Binary Literals, Underscore in literals
-8. Diamond Syntax
-
-- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
-- [Java 8 特性](http://www.importnew.com/19345.html)
-
-## Java 与 C++ 的区别
-
-- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
-- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
-- Java 支持自动垃圾回收，而 C++ 需要手动回收。
-- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
-- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
-- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
-- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
-
-[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
-
-## JRE or JDK
-
-- JRE is the JVM program, Java application need to run on JRE.
-- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
-
-# 参考资料
-
-- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
-
-
-
-
From 9da090caf30de6184e7f42f7f283862a18eaae20 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=AE=E4=BF=A1=E5=85=AC=E4=BC=97=E5=8F=B7=EF=BC=9A?=
=?UTF-8?q?=E7=A8=8B=E5=BA=8F=E5=91=98=E4=B9=94=E6=88=88=E9=87=8C?=
<990878733@qq.com>
Date: Fri, 30 Aug 2019 23:26:55 +0800
Subject: [PATCH 070/259] Delete MySQL.md
---
MySQL.md | 426 -------------------------------------------------------
1 file changed, 426 deletions(-)
delete mode 100644 MySQL.md
diff --git a/MySQL.md b/MySQL.md
deleted file mode 100644
index 6f3e3295..00000000
--- a/MySQL.md
+++ /dev/null
@@ -1,426 +0,0 @@
-
-* [一、索引](#一索引)
- * [B+ Tree 原理](#b-tree-原理)
- * [MySQL 索引](#mysql-索引)
- * [索引优化](#索引优化)
- * [索引的优点](#索引的优点)
- * [索引的使用条件](#索引的使用条件)
-* [二、查询性能优化](#二查询性能优化)
- * [使用 Explain 进行分析](#使用-explain-进行分析)
- * [优化数据访问](#优化数据访问)
- * [重构查询方式](#重构查询方式)
-* [三、存储引擎](#三存储引擎)
- * [InnoDB](#innodb)
- * [MyISAM](#myisam)
- * [比较](#比较)
-* [四、数据类型](#四数据类型)
- * [整型](#整型)
- * [浮点数](#浮点数)
- * [字符串](#字符串)
- * [时间和日期](#时间和日期)
-* [五、切分](#五切分)
- * [水平切分](#水平切分)
- * [垂直切分](#垂直切分)
- * [Sharding 策略](#sharding-策略)
- * [Sharding 存在的问题](#sharding-存在的问题)
-* [六、复制](#六复制)
- * [主从复制](#主从复制)
- * [读写分离](#读写分离)
-* [参考资料](#参考资料)
-
-
-
-# 一、索引
-
-## B+ Tree 原理
-
-### 1. 数据结构
-
-B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
-
-B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
-
-在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 keyi 和 keyi+1，且不为 null，则该指针指向节点的所有 key 大于等于 keyi 且小于等于 keyi+1。
-
-
-
-### 2. 操作
-
-进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
-
-插入删除操作会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。
-
-### 3. 与红黑树的比较
-
-红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
-
-（一）更少的查找次数
-
-平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(logdN)，其中 d 为每个节点的出度。
-
-红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
-
-（二）利用磁盘预读特性
-
-为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的磁盘旋转时间，速度会非常快。
-
-操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
-
-## MySQL 索引
-
-索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。
-
-### 1. B+Tree 索引
-
-是大多数 MySQL 存储引擎的默认索引类型。
-
-因为不再需要进行全表扫描，只需要对树进行搜索即可，所以查找速度快很多。
-
-因为 B+ Tree 的有序性，所以除了用于查找，还可以用于排序和分组。
-
-可以指定多个列作为索引列，多个索引列共同组成键。
-
-适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。
-
-InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
-
-
-
-辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
-
-
-
-### 2. 哈希索引
-
-哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
-
-- 无法用于排序与分组；
-- 只支持精确查找，无法用于部分查找和范围查找。
-
-InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
-
-### 3. 全文索引
-
-MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
-
-查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
-
-全文索引使用倒排索引实现，它记录着关键词到其所在文档的映射。
-
-InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
-
-### 4. 空间数据索引
-
-MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
-
-必须使用 GIS 相关的函数来维护数据。
-
-## 索引优化
-
-### 1. 独立的列
-
-在进行查询时，索引列不能是表达式的一部分，也不能是函数的参数，否则无法使用索引。
-
-例如下面的查询不能使用 actor_id 列的索引：
-
-```sql
-SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
-```
-
-### 2. 多列索引
-
-在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
-
-```sql
-SELECT film_id, actor_ id FROM sakila.film_actor
-WHERE actor_id = 1 AND film_id = 1;
-```
-
-### 3. 索引列的顺序
-
-让选择性最强的索引列放在前面。
-
-索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，每个记录的区分度越高，查询效率也越高。
-
-例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
-
-```sql
-SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
-COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
-COUNT(*)
-FROM payment;
-```
-
-```html
- staff_id_selectivity: 0.0001
-customer_id_selectivity: 0.0373
- COUNT(*): 16049
-```
-
-### 4. 前缀索引
-
-对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
-
-前缀长度的选取需要根据索引选择性来确定。
-
-### 5. 覆盖索引
-
-索引包含所有需要查询的字段的值。
-
-具有以下优点：
-
-- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
-- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
-- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
-
-## 索引的优点
-
-- 大大减少了服务器需要扫描的数据行数。
-
-- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，不需要排序和分组，也就不需要创建临时表）。
-
-- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
-
-## 索引的使用条件
-
-- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
-
-- 对于中到大型的表，索引就非常有效；
-
-- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
-
-# 二、查询性能优化
-
-## 使用 Explain 进行分析
-
-Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
-
-比较重要的字段有：
-
-- select_type : 查询类型，有简单查询、联合查询、子查询等
-- key : 使用的索引
-- rows : 扫描的行数
-
-## 优化数据访问
-
-### 1. 减少请求的数据量
-
-- 只返回必要的列：最好不要使用 SELECT * 语句。
-- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
-- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
-
-### 2. 减少服务器端扫描的行数
-
-最有效的方式是使用索引来覆盖查询。
-
-## 重构查询方式
-
-### 1. 切分大查询
-
-一个大查询如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
-
-```sql
-DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
-```
-
-```sql
-rows_affected = 0
-do {
- rows_affected = do_query(
- "DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
-} while rows_affected > 0
-```
-
-### 2. 分解大连接查询
-
-将一个大连接查询分解成对每一个表进行一次单表查询，然后在应用程序中进行关联，这样做的好处有：
-
-- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
-- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
-- 减少锁竞争；
-- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
-- 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
-
-```sql
-SELECT * FROM tab
-JOIN tag_post ON tag_post.tag_id=tag.id
-JOIN post ON tag_post.post_id=post.id
-WHERE tag.tag='mysql';
-```
-
-```sql
-SELECT * FROM tag WHERE tag='mysql';
-SELECT * FROM tag_post WHERE tag_id=1234;
-SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
-```
-
-# 三、存储引擎
-
-## InnoDB
-
-是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
-
-实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ Next-Key Locking 防止幻影读。
-
-主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。
-
-内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。
-
-支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
-
-## MyISAM
-
-设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。
-
-提供了大量的特性，包括压缩表、空间数据索引等。
-
-不支持事务。
-
-不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
-
-可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。
-
-如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
-
-## 比较
-
-- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
-
-- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
-
-- 外键：InnoDB 支持外键。
-
-- 备份：InnoDB 支持在线热备份。
-
-- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
-
-- 其它特性：MyISAM 支持压缩表和空间数据索引。
-
-# 四、数据类型
-
-## 整型
-
-TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
-
-INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
-
-## 浮点数
-
-FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
-
-FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
-
-## 字符串
-
-主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
-
-VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
-
-在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
-
-## 时间和日期
-
-MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
-
-### 1. DATETIME
-
-能够保存从 1000 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
-
-它与时区无关。
-
-默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
-
-### 2. TIMESTAMP
-
-和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
-
-它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。
-
-MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
-
-默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
-
-应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
-
-# 五、切分
-
-## 水平切分
-
-水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
-
-当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
-
- 
-
-## 垂直切分
-
-垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。
-
-在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。
-
- 
-
-## Sharding 策略
-
-- 哈希取模：hash(key) % N；
-- 范围：可以是 ID 范围也可以是时间范围；
-- 映射表：使用单独的一个数据库来存储映射关系。
-
-## Sharding 存在的问题
-
-### 1. 事务问题
-
-使用分布式事务来解决，比如 XA 接口。
-
-### 2. 连接
-
-可以将原来的连接分解成多个单表查询，然后在用户程序中进行连接。
-
-### 3. ID 唯一性
-
-- 使用全局唯一 ID（GUID）
-- 为每个分片指定一个 ID 范围
-- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
-
-# 六、复制
-
-## 主从复制
-
-主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
-
-- **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
-- **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的中继日志（Relay log）。
-- **SQL 线程** ：负责读取中继日志，解析出主服务器已经执行的数据更改并在从服务器中重放（Replay）。
-
- 
-
-## 读写分离
-
-主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。
-
-读写分离能提高性能的原因在于：
-
-- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
-- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
-- 增加冗余，提高可用性。
-
-读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。
-
- 
-
-# 参考资料
-
-- BaronScbwartz, PeterZaitsev, VadimTkacbenko, 等. 高性能 MySQL[M]. 电子工业出版社, 2013.
-- 姜承尧. MySQL 技术内幕: InnoDB 存储引擎 [M]. 机械工业出版社, 2011.
-- [20+ 条 MySQL 性能优化的最佳经验](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
-- [服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策](http://blog.720ui.com/2017/mysql_core_09_multi_db_table2/ "服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策")
-- [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases)
-- [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.")
-- [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
-- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735)
-- [How Sharding Works](https://medium.com/@jeeyoungk/how-sharding-works-b4dec46b3f6)
-- [大众点评订单系统分库分表实践](https://tech.meituan.com/dianping_order_db_sharding.html)
-- [B + 树](https://zh.wikipedia.org/wiki/B%2B%E6%A0%91)
-
-
-
From 7149072a1787ad4b949292c81b17b84b0030588b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BE=AE=E4=BF=A1=E5=85=AC=E4=BC=97=E5=8F=B7=EF=BC=9A?=
=?UTF-8?q?=E7=A8=8B=E5=BA=8F=E5=91=98=E4=B9=94=E6=88=88=E9=87=8C?=
<990878733@qq.com>
Date: Fri, 30 Aug 2019 23:27:17 +0800
Subject: [PATCH 071/259] =?UTF-8?q?Delete=20Java=20=E8=99=9A=E6=8B=9F?=
=?UTF-8?q?=E6=9C=BA.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...a \350\231\232\346\213\237\346\234\272.md" | 760 ------------------
1 file changed, 760 deletions(-)
delete mode 100644 "Java \350\231\232\346\213\237\346\234\272.md"
diff --git "a/Java \350\231\232\346\213\237\346\234\272.md" "b/Java \350\231\232\346\213\237\346\234\272.md"
deleted file mode 100644
index 5a61b194..00000000
--- "a/Java \350\231\232\346\213\237\346\234\272.md"
+++ /dev/null
@@ -1,760 +0,0 @@
-
-* [一、运行时数据区域](#一运行时数据区域)
- * [程序计数器](#程序计数器)
- * [Java 虚拟机栈](#java-虚拟机栈)
- * [本地方法栈](#本地方法栈)
- * [堆](#堆)
- * [方法区](#方法区)
- * [运行时常量池](#运行时常量池)
- * [直接内存](#直接内存)
-* [二、垃圾收集](#二垃圾收集)
- * [判断一个对象是否可被回收](#判断一个对象是否可被回收)
- * [引用类型](#引用类型)
- * [垃圾收集算法](#垃圾收集算法)
- * [垃圾收集器](#垃圾收集器)
-* [三、内存分配与回收策略](#三内存分配与回收策略)
- * [Minor GC 和 Full GC](#minor-gc-和-full-gc)
- * [内存分配策略](#内存分配策略)
- * [Full GC 的触发条件](#full-gc-的触发条件)
-* [四、类加载机制](#四类加载机制)
- * [类的生命周期](#类的生命周期)
- * [类加载过程](#类加载过程)
- * [类初始化时机](#类初始化时机)
- * [类与类加载器](#类与类加载器)
- * [类加载器分类](#类加载器分类)
- * [双亲委派模型](#双亲委派模型)
- * [自定义类加载器实现](#自定义类加载器实现)
-* [参考资料](#参考资料)
-
-
-
-本文大部分内容参考 **周志明《深入理解 Java 虚拟机》** ，想要深入学习的话请看原书。
-
-# 一、运行时数据区域
-
- 
-
-## 程序计数器
-
-记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
-
-## Java 虚拟机栈
-
-每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
-
- 
-
-可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小，在 JDK 1.4 中默认为 256K，而在 JDK 1.5+ 默认为 1M：
-
-```java
-java -Xss2M HackTheJava
-```
-
-该区域可能抛出以下异常：
-
-- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
-- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
-
-## 本地方法栈
-
-本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
-
-本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
-
- 
-
-## 堆
-
-所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
-
-现代的垃圾收集器基本都是采用分代收集算法，其主要的思想是针对不同类型的对象采取不同的垃圾回收算法。可以将堆分成两块：
-
-- 新生代（Young Generation）
-- 老年代（Old Generation）
-
-堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
-
-可以通过 -Xms 和 -Xmx 这两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
-
-```java
-java -Xms1M -Xmx2M HackTheJava
-```
-
-## 方法区
-
-用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
-
-和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
-
-对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。
-
-HotSpot 虚拟机把它当成永久代来进行垃圾回收。但很难确定永久代的大小，因为它受到很多因素影响，并且每次 Full GC 之后永久代的大小都会改变，所以经常会抛出 OutOfMemoryError 异常。为了更容易管理方法区，从 JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。
-
-方法区是一个 JVM 规范，永久代与元空间都是其一种实现方式。在 JDK 1.8 之后，原来永久代的数据被分到了堆和元空间中。元空间存储类的元信息，静态变量和常量池等放入堆中。
-
-## 运行时常量池
-
-运行时常量池是方法区的一部分。
-
-Class 文件中的常量池（编译器生成的字面量和符号引用）会在类加载后被放入这个区域。
-
-除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
-
-## 直接内存
-
-在 JDK 1.4 中新引入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
-
-# 二、垃圾收集
-
-垃圾收集主要是针对堆和方法区进行。程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后就会消失，因此不需要对这三个区域进行垃圾回收。
-
-## 判断一个对象是否可被回收
-
-### 1. 引用计数算法
-
-为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
-
-在两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正是因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
-
-```java
-public class Test {
-
- public Object instance = null;
-
- public static void main(String[] args) {
- Test a = new Test();
- Test b = new Test();
- a.instance = b;
- b.instance = a;
- a = null;
- b = null;
- doSomething();
- }
-}
-```
-
-在上述代码中，a 与 b 引用的对象实例互相持有了对象的引用，因此当我们把对 a 对象与 b 对象的引用去除之后，由于两个对象还存在互相之间的引用，导致两个 Test 对象无法被回收。
-
-### 2. 可达性分析算法
-
-以 GC Roots 为起始点进行搜索，可达的对象都是存活的，不可达的对象可被回收。
-
-Java 虚拟机使用该算法来判断对象是否可被回收，GC Roots 一般包含以下内容：
-
-- 虚拟机栈中局部变量表中引用的对象
-- 本地方法栈中 JNI 中引用的对象
-- 方法区中类静态属性引用的对象
-- 方法区中的常量引用的对象
-
- 
-
-
-### 3. 方法区的回收
-
-因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，所以在方法区上进行回收性价比不高。
-
-主要是对常量池的回收和对类的卸载。
-
-为了避免内存溢出，在大量使用反射和动态代理的场景都需要虚拟机具备类卸载功能。
-
-类的卸载条件很多，需要满足以下三个条件，并且满足了条件也不一定会被卸载：
-
-- 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
-- 加载该类的 ClassLoader 已经被回收。
-- 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
-
-### 4. finalize()
-
-类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做得更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
-
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会再调用该方法。
-
-## 引用类型
-
-无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否可达，判定对象是否可被回收都与引用有关。
-
-Java 提供了四种强度不同的引用类型。
-
-### 1. 强引用
-
-被强引用关联的对象不会被回收。
-
-使用 new 一个新对象的方式来创建强引用。
-
-```java
-Object obj = new Object();
-```
-
-### 2. 软引用
-
-被软引用关联的对象只有在内存不够的情况下才会被回收。
-
-使用 SoftReference 类来创建软引用。
-
-```java
-Object obj = new Object();
-SoftReference 
