, CharSequence {
- private final char value[];
- //...
-}
-```
-
-> 🐛 修正 ： 我们知道被 `final` 关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，`final` 关键字修饰的数组保存字符串并不是 `String` 不可变的根本原因，因为这个数组保存的字符串是可变的（`final` 修饰引用类型变量的情况）。
->
-> `String` 真正不可变有下面几点原因：
->
-> 1. 保存字符串的数组被 `final` 修饰且为私有的，并且`String` 类没有提供/暴露修改这个字符串的方法。
-> 2. `String` 类被 `final` 修饰导致其不能被继承，进而避免了子类破坏 `String` 不可变。
->
-> 相关阅读：[如何理解 String 类型值的不可变？ - 知乎提问](https://www.zhihu.com/question/20618891/answer/114125846)
->
-> 补充（来自[issue 675](https://github.com/Snailclimb/JavaGuide/issues/675)）：在 Java 9 之后，`String` 、`StringBuilder` 与 `StringBuffer` 的实现改用 `byte` 数组存储字符串。
->
-> ```java
-> public final class String implements java.io.Serializable,Comparable, CharSequence {
-> // @Stable 注解表示变量最多被修改一次，称为“稳定的”。
-> @Stable
-> private final byte[] value;
-> }
->
-> abstract class AbstractStringBuilder implements Appendable, CharSequence {
-> byte[] value;
->
-> }
-> ```
->
-> **Java 9 为何要将 `String` 的底层实现由 `char[]` 改成了 `byte[]` ?**
->
-> 新版的 String 其实支持两个编码方案： Latin-1 和 UTF-16。如果字符串中包含的汉字没有超过 Latin-1 可表示范围内的字符，那就会使用 Latin-1 作为编码方案。Latin-1 编码方案下，`byte` 占一个字节(8 位)，`char` 占用 2 个字节（16），`byte` 相较 `char` 节省一半的内存空间。
->
-> JDK 官方就说了绝大部分字符串对象只包含 Latin-1 可表示的字符。
->
-> 
->
-> 如果字符串中包含的汉字超过 Latin-1 可表示范围内的字符，`byte` 和 `char` 所占用的空间是一样的。
->
-> 这是官方的介绍：https://openjdk.java.net/jeps/254 。
-
-#### 字符串拼接用“+” 还是 StringBuilder?
-
-Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。
-
-```java
-String str1 = "he";
-String str2 = "llo";
-String str3 = "world";
-String str4 = str1 + str2 + str3;
-```
-
-上面的代码对应的字节码如下：
-
-
-
-可以看出，字符串对象通过“+”的字符串拼接方式，实际上是通过 `StringBuilder` 调用 `append()` 方法实现的，拼接完成之后调用 `toString()` 得到一个 `String` 对象 。
-
-不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：**编译器不会创建单个 `StringBuilder` 以复用，会导致创建过多的 `StringBuilder` 对象**。
-
-```java
-String[] arr = {"he", "llo", "world"};
-String s = "";
-for (int i = 0; i < arr.length; i++) {
- s += arr[i];
-}
-System.out.println(s);
-```
-
-`StringBuilder` 对象是在循环内部被创建的，这意味着每循环一次就会创建一个 `StringBuilder` 对象。
-
-
-
-如果直接使用 `StringBuilder` 对象进行字符串拼接的话，就不会存在这个问题了。
-
-```java
-String[] arr = {"he", "llo", "world"};
-StringBuilder s = new StringBuilder();
-for (String value : arr) {
- s.append(value);
-}
-System.out.println(s);
-```
-
-
-
-如果你使用 IDEA 的话，IDEA 自带的代码检查机制也会提示你修改代码。
-
-#### String#equals() 和 Object#equals() 有何区别？
-
-`String` 中的 `equals` 方法是被重写过的，比较的是 String 字符串的值是否相等。 `Object` 的 `equals` 方法是比较的对象的内存地址。
-
-#### 字符串常量池的作用了解吗？
-
-**字符串常量池** 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。
-
-```java
-// 在堆中创建字符串对象”ab“
-// 将字符串对象”ab“的引用保存在字符串常量池中
-String aa = "ab";
-// 直接返回字符串常量池中字符串对象”ab“的引用
-String bb = "ab";
-System.out.println(aa==bb);// true
-```
-
-更多关于字符串常量池的介绍可以看一下 [Java 内存区域详解](https://javaguide.cn/java/jvm/memory-area.html) 这篇文章。
-
-#### String s1 = new String("abc");这句话创建了几个字符串对象？
-
-会创建 1 或 2 个字符串对象。
-
-1、如果字符串常量池中不存在字符串对象“abc”的引用，那么会在堆中创建 2 个字符串对象“abc”。
-
-示例代码（JDK 1.8）：
-
-```java
-String s1 = new String("abc");
-```
-
-对应的字节码：
-
-
-
-`ldc` 命令用于判断字符串常量池中是否保存了对应的字符串对象的引用，如果保存了的话直接返回，如果没有保存的话，会在堆中创建对应的字符串对象并将该字符串对象的引用保存到字符串常量池中。
-
-2、如果字符串常量池中已存在字符串对象“abc”的引用，则只会在堆中创建 1 个字符串对象“abc”。
-
-示例代码（JDK 1.8）：
-
-```java
-// 字符串常量池中已存在字符串对象“abc”的引用
-String s1 = "abc";
-// 下面这段代码只会在堆中创建 1 个字符串对象“abc”
-String s2 = new String("abc");
-```
-
-对应的字节码：
-
-
-
-这里就不对上面的字节码进行详细注释了，7 这个位置的 `ldc` 命令不会在堆中创建新的字符串对象“abc”，这是因为 0 这个位置已经执行了一次 `ldc` 命令，已经在堆中创建过一次字符串对象“abc”了。7 这个位置执行 `ldc` 命令会直接返回字符串常量池中字符串对象“abc”对应的引用。
-
-#### intern 方法有什么作用?
-
-`String.intern()` 是一个 native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：
-
-- 如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。
-- 如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。
-
-示例代码（JDK 1.8） :
-
-```java
-// 在堆中创建字符串对象”Java“
-// 将字符串对象”Java“的引用保存在字符串常量池中
-String s1 = "Java";
-// 直接返回字符串常量池中字符串对象”Java“对应的引用
-String s2 = s1.intern();
-// 会在堆中在单独创建一个字符串对象
-String s3 = new String("Java");
-// 直接返回字符串常量池中字符串对象”Java“对应的引用
-String s4 = s3.intern();
-// s1 和 s2 指向的是堆中的同一个对象
-System.out.println(s1 == s2); // true
-// s3 和 s4 指向的是堆中不同的对象
-System.out.println(s3 == s4); // false
-// s1 和 s4 指向的是堆中的同一个对象
-System.out.println(s1 == s4); //true
-```
-
-#### String 类型的变量和常量做“+”运算时发生了什么？
-
-先来看字符串不加 `final` 关键字拼接的情况（JDK1.8）：
-
-```java
-String str1 = "str";
-String str2 = "ing";
-String str3 = "str" + "ing";
-String str4 = str1 + str2;
-String str5 = "string";
-System.out.println(str3 == str4);//false
-System.out.println(str3 == str5);//true
-System.out.println(str4 == str5);//false
-```
-
-> **注意** ：比较 String 字符串的值是否相等，可以使用 `equals()` 方法。 `String` 中的 `equals` 方法是被重写过的。 `Object` 的 `equals` 方法是比较的对象的内存地址，而 `String` 的 `equals` 方法比较的是字符串的值是否相等。如果你使用 `==` 比较两个字符串是否相等的话，IDEA 还是提示你使用 `equals()` 方法替换。
-
-
-
-**对于编译期可以确定值的字符串，也就是常量字符串 ，jvm 会将其存入字符串常量池。并且，字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池，这个得益于编译器的优化。**
-
-在编译过程中，Javac 编译器（下文中统称为编译器）会进行一个叫做 **常量折叠(Constant Folding)** 的代码优化。《深入理解 Java 虚拟机》中是也有介绍到：
-
-
-
-常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中，这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。
-
-对于 `String str3 = "str" + "ing";` 编译器会给你优化成 `String str3 = "string";` 。
-
-并不是所有的常量都会进行折叠，只有编译器在程序编译期就可以确定值的常量才可以：
-
-- 基本数据类型( `byte`、`boolean`、`short`、`char`、`int`、`float`、`long`、`double`)以及字符串常量。
-- `final` 修饰的基本数据类型和字符串变量
-- 字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（<<、\>>、\>>> ）
-
-**引用的值在程序编译期是无法确定的，编译器无法对其进行优化。**
-
-对象引用和“+”的字符串拼接方式，实际上是通过 `StringBuilder` 调用 `append()` 方法实现的，拼接完成之后调用 `toString()` 得到一个 `String` 对象 。
-
-```java
-String str4 = new StringBuilder().append(str1).append(str2).toString();
-```
-
-我们在平时写代码的时候，尽量避免多个字符串对象拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 `StringBuilder` 或者 `StringBuffer`。
-
-不过，字符串使用 `final` 关键字声明之后，可以让编译器当做常量来处理。
-
-示例代码：
-
-```java
-final String str1 = "str";
-final String str2 = "ing";
-// 下面两个表达式其实是等价的
-String c = "str" + "ing";// 常量池中的对象
-String d = str1 + str2; // 常量池中的对象
-System.out.println(c == d);// true
-```
-
-被 `final` 关键字修改之后的 `String` 会被编译器当做常量来处理，编译器在程序编译期就可以确定它的值，其效果就相当于访问常量。
-
-如果 ，编译器在运行时才能知道其确切值的话，就无法对其优化。
-
-示例代码（`str2` 在运行时才能确定其值）：
-
-```java
-final String str1 = "str";
-final String str2 = getStr();
-String c = "str" + "ing";// 常量池中的对象
-String d = str1 + str2; // 在堆上创建的新的对象
-System.out.println(c == d);// false
-public static String getStr() {
- return "ing";
-}
-```
-
-### Exception 和 Error 有什么区别？
-
-在 Java 中，所有的异常都有一个共同的祖先 `java.lang` 包中的 `Throwable` 类。`Throwable` 类有两个重要的子类:
-
-- **`Exception`** :程序本身可以处理的异常，可以通过 `catch` 来进行捕获。`Exception` 又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。
-- **`Error`** ：`Error` 属于程序无法处理的错误 ，~~我们没办法通过 `catch` 来进行捕获~~不建议通过`catch`捕获 。例如 Java 虚拟机运行错误（`Virtual MachineError`）、虚拟机内存不够错误(`OutOfMemoryError`)、类定义错误（`NoClassDefFoundError`）等 。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。
-
-### Checked Exception 和 Unchecked Exception 有什么区别？
-
-**Java 异常类层次结构图概览** ：
-
-
-
-**Checked Exception** 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 `catch`或者`throws` 关键字处理的话，就没办法通过编译。
-
-比如下面这段 IO 操作的代码：
-
-
-
-除了`RuntimeException`及其子类以外，其他的`Exception`类及其子类都属于受检查异常 。常见的受检查异常有： IO 相关的异常、`ClassNotFoundException` 、`SQLException`...。
-
-**Unchecked Exception** 即 **不受检查异常** ，Java 代码在编译过程中 ，我们即使不处理不受检查异常也可以正常通过编译。
-
-`RuntimeException` 及其子类都统称为非受检查异常，常见的有（建议记下来，日常开发中会经常用到）：
-
-- `NullPointerException`(空指针错误)
-- `IllegalArgumentException`(参数错误比如方法入参类型错误)
-- `NumberFormatException`（字符串转换为数字格式错误，`IllegalArgumentException`的子类）
-- `ArrayIndexOutOfBoundsException`（数组越界错误）
-- `ClassCastException`（类型转换错误）
-- `ArithmeticException`（算术错误）
-- `SecurityException` （安全错误比如权限不够）
-- `UnsupportedOperationException`(不支持的操作错误比如重复创建同一用户)
-- ......
-
-
-
-### Throwable 类常用方法有哪些？
-
-- `String getMessage()`: 返回异常发生时的简要描述
-- `String toString()`: 返回异常发生时的详细信息
-- `String getLocalizedMessage()`: 返回异常对象的本地化信息。使用 `Throwable` 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 `getMessage()`返回的结果相同
-- `void printStackTrace()`: 在控制台上打印 `Throwable` 对象封装的异常信息
-
-### try-catch-finally 如何使用？
-
-- `try`块 ： 用于捕获异常。其后可接零个或多个 `catch` 块，如果没有 `catch` 块，则必须跟一个 `finally` 块。
-- `catch`块 ： 用于处理 try 捕获到的异常。
-- `finally` 块 ： 无论是否捕获或处理异常，`finally` 块里的语句都会被执行。当在 `try` 块或 `catch` 块中遇到 `return` 语句时，`finally` 语句块将在方法返回之前被执行。
-
-代码示例：
-
-```java
-try {
- System.out.println("Try to do something");
- throw new RuntimeException("RuntimeException");
-} catch (Exception e) {
- System.out.println("Catch Exception -> " + e.getMessage());
-} finally {
- System.out.println("Finally");
-}
-```
-
-输出：
-
-```
-Try to do something
-Catch Exception -> RuntimeException
-Finally
-```
-
-**注意：不要在 finally 语句块中使用 return!** 当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。
-
-[jvm 官方文档](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.10.2.5)中有明确提到：
-
-> If the `try` clause executes a _return_, the compiled code does the following:
->
-> 1. Saves the return value (if any) in a local variable.
-> 2. Executes a _jsr_ to the code for the `finally` clause.
-> 3. Upon return from the `finally` clause, returns the value saved in the local variable.
-
-代码示例：
-
-```java
-public static void main(String[] args) {
- System.out.println(f(2));
-}
-
-public static int f(int value) {
- try {
- return value * value;
- } finally {
- if (value == 2) {
- return 0;
- }
- }
-}
-```
-
-输出：
-
-```
-0
-```
-
-### finally 中的代码一定会执行吗？
-
-不一定的！在某些情况下，finally 中的代码不会被执行。
-
-就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。
-
-```java
-try {
- System.out.println("Try to do something");
- throw new RuntimeException("RuntimeException");
-} catch (Exception e) {
- System.out.println("Catch Exception -> " + e.getMessage());
- // 终止当前正在运行的Java虚拟机
- System.exit(1);
-} finally {
- System.out.println("Finally");
-}
-```
-
-输出：
-
-```
-Try to do something
-Catch Exception -> RuntimeException
-```
-
-另外，在以下 2 种特殊情况下，`finally` 块的代码也不会被执行：
-
-1. 程序所在的线程死亡。
-2. 关闭 CPU。
-
-相关 issue： 。
-
-🧗🏻 进阶一下：从字节码角度分析`try catch finally`这个语法糖背后的实现原理。
-
-### 如何使用 `try-with-resources` 代替`try-catch-finally`？
-
-1. **适用范围（资源的定义）：** 任何实现 `java.lang.AutoCloseable`或者 `java.io.Closeable` 的对象
-2. **关闭资源和 finally 块的执行顺序：** 在 `try-with-resources` 语句中，任何 catch 或 finally 块在声明的资源关闭后运行
-
-《Effective Java》中明确指出：
-
-> 面对必须要关闭的资源，我们总是应该优先使用 `try-with-resources` 而不是`try-finally`。随之产生的代码更简短，更清晰，产生的异常对我们也更有用。`try-with-resources`语句让我们更容易编写必须要关闭的资源的代码，若采用`try-finally`则几乎做不到这点。
-
-Java 中类似于`InputStream`、`OutputStream` 、`Scanner` 、`PrintWriter`等的资源都需要我们调用`close()`方法来手动关闭，一般情况下我们都是通过`try-catch-finally`语句来实现这个需求，如下：
-
-```java
-//读取文本文件的内容
-Scanner scanner = null;
-try {
- scanner = new Scanner(new File("D://read.txt"));
- while (scanner.hasNext()) {
- System.out.println(scanner.nextLine());
- }
-} catch (FileNotFoundException e) {
- e.printStackTrace();
-} finally {
- if (scanner != null) {
- scanner.close();
- }
-}
-```
-
-使用 Java 7 之后的 `try-with-resources` 语句改造上面的代码:
-
-```java
-try (Scanner scanner = new Scanner(new File("test.txt"))) {
- while (scanner.hasNext()) {
- System.out.println(scanner.nextLine());
- }
-} catch (FileNotFoundException fnfe) {
- fnfe.printStackTrace();
-}
-```
-
-当然多个资源需要关闭的时候，使用 `try-with-resources` 实现起来也非常简单，如果你还是用`try-catch-finally`可能会带来很多问题。
-
-通过使用分号分隔，可以在`try-with-resources`块中声明多个资源。
-
-```java
-try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
- BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
- int b;
- while ((b = bin.read()) != -1) {
- bout.write(b);
- }
-}
-catch (IOException e) {
- e.printStackTrace();
-}
-```
-
-### 异常使用有哪些需要注意的地方？
-
-- 不要把异常定义为静态变量，因为这样会导致异常栈信息错乱。每次手动抛出异常，我们都需要手动 new 一个异常对象抛出。
-- 抛出的异常信息一定要有意义。
-- 建议抛出更加具体的异常比如字符串转换为数字格式错误的时候应该抛出`NumberFormatException`而不是其父类`IllegalArgumentException`。
-- 使用日志打印异常之后就不要再抛出异常了（两者不要同时存在一段代码逻辑中）。
-- ......
-
-### 何谓反射？
-
-如果说大家研究过框架的底层原理或者咱们自己写过框架的话，一定对反射这个概念不陌生。反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。
-
-### 反射的优缺点？
-
-反射可以让我们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利。
-
-不过，反射让我们在运行时有了分析操作类的能力的同时，也增加了安全问题，比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的。
-
-相关阅读：[Java Reflection: Why is it so slow?](https://stackoverflow.com/questions/1392351/java-reflection-why-is-it-so-slow) 。
-
-### 反射的应用场景？
-
-像咱们平时大部分时候都是在写业务代码，很少会接触到直接使用反射机制的场景。但是！这并不代表反射没有用。相反，正是因为反射，你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。
-
-**这些框架中也大量使用了动态代理，而动态代理的实现也依赖反射。**
-
-比如下面是通过 JDK 实现动态代理的示例代码，其中就使用了反射类 `Method` 来调用指定的方法。
-
-```java
-public class DebugInvocationHandler implements InvocationHandler {
- /**
- * 代理类中的真实对象
- */
- private final Object target;
-
- public DebugInvocationHandler(Object target) {
- this.target = target;
- }
-
- public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
- System.out.println("before method " + method.getName());
- Object result = method.invoke(target, args);
- System.out.println("after method " + method.getName());
- return result;
- }
-}
-
-```
-
-另外，像 Java 中的一大利器 **注解** 的实现也用到了反射。
-
-为什么你使用 Spring 的时候 ，一个`@Component`注解就声明了一个类为 Spring Bean 呢？为什么你通过一个 `@Value`注解就读取到配置文件中的值呢？究竟是怎么起作用的呢？
-
-这些都是因为你可以基于反射分析类，然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后，就可以做进一步的处理。
-
-### 何谓 SPI?
-
-SPI 即 Service Provider Interface ，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。
-
-SPI 将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。
-
-很多框架都使用了 Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。
-
-
-
-### SPI 和 API 有什么区别？
-
-**那 SPI 和 API 有啥区别？**
-
-说到 SPI 就不得不说一下 API 了，从广义上来说它们都属于接口，而且很容易混淆。下面先用一张图说明一下：
-
-
-
-一般模块之间都是通过通过接口进行通讯，那我们在服务调用方和服务实现方（也称服务提供者）之间引入一个“接口”。
-
-当实现方提供了接口和实现，我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力，这就是 API ，这种接口和实现都是放在实现方的。
-
-当接口存在于调用方这边时，就是 SPI ，由接口调用方确定接口规则，然后由不同的厂商去根绝这个规则对这个接口进行实现，从而提供服务。
-
-举个通俗易懂的例子：公司 H 是一家科技公司，新设计了一款芯片，然后现在需要量产了，而市面上有好几家芯片制造业公司，这个时候，只要 H 公司指定好了这芯片生产的标准（定义好了接口标准），那么这些合作的芯片公司（服务提供者）就按照标准交付自家特色的芯片（提供不同方案的实现，但是给出来的结果是一样的）。
-
-### SPI 的优缺点？
-
-通过 SPI 机制能够大大地提高接口设计的灵活性，但是 SPI 机制也存在一些缺点，比如：
-
-- 需要遍历加载所有的实现类，不能做到按需加载，这样效率还是相对较低的。
-- 当多个 `ServiceLoader` 同时 `load` 时，会有并发问题。
-
-### 什么是序列化?什么是反序列化?
-
-如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。
-
-简单来说：
-
-- **序列化**： 将数据结构或对象转换成二进制字节流的过程
-- **反序列化**：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程
-
-对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。
-
-维基百科是如是介绍序列化的：
-
-> **序列化**（serialization）在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。
-
-综上：**序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。**
-
-
-
-https://www.corejavaguru.com/java/serialization/interview-questions-1
-
-### 如果有些字段不想进行序列化怎么办？
-
-对于不想进行序列化的变量，使用 `transient` 关键字修饰。
-
-`transient` 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 `transient` 修饰的变量值不会被持久化和恢复。
-
-关于 `transient` 还有几点注意：
-
-- `transient` 只能修饰变量，不能修饰类和方法。
-- `transient` 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 `int` 类型，那么反序列后结果就是 `0`。
-- `static` 变量因为不属于任何对象(Object)，所以无论有没有 `transient` 关键字修饰，均不会被序列化。
-
-### Java IO 流了解吗？
-
-IO 即 `Input/Output`，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。
-
-Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。
-
-- `InputStream`/`Reader`: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
-- `OutputStream`/`Writer`: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
-
-相关阅读：[Java IO 基础知识总结](https://javaguide.cn/java/io/io-basis.html#io-%E6%B5%81%E7%AE%80%E4%BB%8B)。
-
-### I/O 流为什么要分为字节流和字符流呢?
-
-问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？**
-
-个人认为主要有两点原因：
-
-- 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时；
-- 如果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题。
-
-### Java IO 中的设计模式有哪些？
-
-[Java IO 设计模式总结](https://javaguide.cn/java/io/io-design-patterns.html)。
-
-### BIO、NIO 和 AIO 的区别？
-
-[Java IO 模型详解](https://javaguide.cn/java/io/io-model.html)。
-
-
-
-
https://www.cnblogs.com/chengxiao/p/6842045.html>
-
-**JDK1.7 的 ConcurrentHashMap** ：
-
-
-
-`ConcurrentHashMap` 是由 `Segment` 数组结构和 `HashEntry` 数组结构组成。
-
-`Segment` 数组中的每个元素包含一个 `HashEntry` 数组，每个 `HashEntry` 数组属于链表结构。
-
-**JDK1.8 的 ConcurrentHashMap** ：
-
-
-
-JDK1.8 的 `ConcurrentHashMap` 不再是 **Segment 数组 + HashEntry 数组 + 链表**，而是 **Node 数组 + 链表 / 红黑树**。不过，Node 只能用于链表的情况，红黑树的情况需要使用 **`TreeNode`**。当冲突链表达到一定长度时，链表会转换成红黑树。
-
-`TreeNode`是存储红黑树节点，被`TreeBin`包装。`TreeBin`通过`root`属性维护红黑树的根结点，因为红黑树在旋转的时候，根结点可能会被它原来的子节点替换掉，在这个时间点，如果有其他线程要写这棵红黑树就会发生线程不安全问题，所以在 `ConcurrentHashMap` 中`TreeBin`通过`waiter`属性维护当前使用这棵红黑树的线程，来防止其他线程的进入。
-
-```java
-static final class TreeBin extends Node {
- TreeNode root;
- volatile TreeNode first;
- volatile Thread waiter;
- volatile int lockState;
- // values for lockState
- static final int WRITER = 1; // set while holding write lock
- static final int WAITER = 2; // set when waiting for write lock
- static final int READER = 4; // increment value for setting read lock
-...
-}
-```
-
-### ConcurrentHashMap 线程安全的具体实现方式/底层具体实现
-
-#### JDK1.8 之前
-
-
-
-首先将数据分为一段一段（这个“段”就是 `Segment`）的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。
-
-**`ConcurrentHashMap` 是由 `Segment` 数组结构和 `HashEntry` 数组结构组成**。
-
-`Segment` 继承了 `ReentrantLock`,所以 `Segment` 是一种可重入锁，扮演锁的角色。`HashEntry` 用于存储键值对数据。
-
-```java
-static class Segment extends ReentrantLock implements Serializable {
-}
-```
-
-一个 `ConcurrentHashMap` 里包含一个 `Segment` 数组，`Segment` 的个数一旦**初始化就不能改变**。 `Segment` 数组的大小默认是 16，也就是说默认可以同时支持 16 个线程并发写。
-
-`Segment` 的结构和 `HashMap` 类似，是一种数组和链表结构，一个 `Segment` 包含一个 `HashEntry` 数组，每个 `HashEntry` 是一个链表结构的元素，每个 `Segment` 守护着一个 `HashEntry` 数组里的元素，当对 `HashEntry` 数组的数据进行修改时，必须首先获得对应的 `Segment` 的锁。也就是说，对同一 `Segment` 的并发写入会被阻塞，不同 `Segment` 的写入是可以并发执行的。
-
-#### JDK1.8 之后
-
-
-
-Java 8 几乎完全重写了 `ConcurrentHashMap`，代码量从原来 Java 7 中的 1000 多行，变成了现在的 6000 多行。
-
-`ConcurrentHashMap` 取消了 `Segment` 分段锁，采用 `Node + CAS + synchronized` 来保证并发安全。数据结构跟 `HashMap` 1.8 的结构类似，数组+链表/红黑二叉树。Java 8 在链表长度超过一定阈值（8）时将链表（寻址时间复杂度为 O(N)）转换为红黑树（寻址时间复杂度为 O(log(N))）。
-
-Java 8 中，锁粒度更细，`synchronized` 只锁定当前链表或红黑二叉树的首节点，这样只要 hash 不冲突，就不会产生并发，就不会影响其他 Node 的读写，效率大幅提升。
-
-### JDK 1.7 和 JDK 1.8 的 ConcurrentHashMap 实现有什么不同？
-
-- **线程安全实现方式** ：JDK 1.7 采用 `Segment` 分段锁来保证安全， `Segment` 是继承自 `ReentrantLock`。JDK1.8 放弃了 `Segment` 分段锁的设计，采用 `Node + CAS + synchronized` 保证线程安全，锁粒度更细，`synchronized` 只锁定当前链表或红黑二叉树的首节点。
-- **Hash 碰撞解决方法** : JDK 1.7 采用拉链法，JDK1.8 采用拉链法结合红黑树（链表长度超过一定阈值时，将链表转换为红黑树）。
-- **并发度** ：JDK 1.7 最大并发度是 Segment 的个数，默认是 16。JDK 1.8 最大并发度是 Node 数组的大小，并发度更大。
-
-
-
-
-
-
-
-
-
-
-
-
-
-> 上图有一个错误，请注意，是 OSPF 不是 OPSF。 OSPF（Open Shortest Path First，ospf）开放最短路径优先协议, 是由 Internet 工程任务组开发的路由选择协议
-
-总体来说分为以下几个过程:
-
-1. DNS 解析
-2. TCP 连接
-3. 发送 HTTP 请求
-4. 服务器处理请求并返回 HTTP 报文
-5. 浏览器解析渲染页面
-6. 连接结束
-
-具体可以参考下面这两篇文章：
-
-- [从输入URL到页面加载发生了什么？](https://segmentfault.com/a/1190000006879700)
-- [浏览器从输入网址到页面展示的过程](https://cloud.tencent.com/developer/article/1879758)
-
-### HTTP 状态码有哪些？
-
-HTTP 状态码用于描述 HTTP 请求的结果，比如2xx 就代表请求被成功处理。
-
-
-
-关于 HTTP 状态码更详细的总结，可以看我写的这篇文章：[HTTP 常见状态码总结（应用层）](https://javaguide.cn/cs-basics/network/http-status-codes.html)。
-
-### HTTP 和 HTTPS 有什么区别？（重要）
-
-- **端口号** ：HTTP 默认是 80，HTTPS 默认是 443。
-- **URL 前缀** ：HTTP 的 URL 前缀是 `http://`，HTTPS 的 URL 前缀是 `https://`。
-- **安全性和资源消耗** ： HTTP 协议运行在 TCP 之上，所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份。HTTPS 是运行在 SSL/TLS 之上的 HTTP 协议，SSL/TLS 运行在 TCP 之上。所有传输的内容都经过加密，加密采用对称加密，但对称加密的密钥用服务器方的证书进行了非对称加密。所以说，HTTP 安全性没有 HTTPS 高，但是 HTTPS 比 HTTP 耗费更多服务器资源。
-
-关于 HTTP 和 HTTPS 更详细的对比总结，可以看我写的这篇文章：[HTTP vs HTTPS（应用层）](https://javaguide.cn/cs-basics/network/http&https.html) 。
-
-### HTTP 1.0 和 HTTP 1.1 有什么区别？
-
-- **连接方式** : HTTP 1.0 为短连接，HTTP 1.1 支持长连接。
-- **状态响应码** : HTTP/1.1中新加入了大量的状态码，光是错误响应状态码就新增了24种。比如说，`100 (Continue)`——在请求大资源前的预热请求，`206 (Partial Content)`——范围请求的标识码，`409 (Conflict)`——请求与当前资源的规定冲突，`410 (Gone)`——资源已被永久转移，而且没有任何已知的转发地址。
-- **缓存处理** : 在 HTTP1.0 中主要使用 header 里的 If-Modified-Since,Expires 来做为缓存判断的标准，HTTP1.1 则引入了更多的缓存控制策略例如 Entity tag，If-Unmodified-Since, If-Match, If-None-Match 等更多可供选择的缓存头来控制缓存策略。
-- **带宽优化及网络连接的使用** :HTTP1.0 中，存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象送过来了，并且不支持断点续传功能，HTTP1.1 则在请求头引入了 range 头域，它允许只请求资源的某个部分，即返回码是 206（Partial Content），这样就方便了开发者自由的选择以便于充分利用带宽和连接。
-- **Host头处理** : HTTP/1.1在请求头中加入了`Host`字段。
-
-关于 HTTP 1.0 和 HTTP 1.1 更详细的对比总结，可以看我写的这篇文章：[HTTP 1.0 vs HTTP 1.1（应用层）](https://javaguide.cn/cs-basics/network/http1.0&http1.1.html) 。
-
-### HTTP 是不保存状态的协议, 如何保存用户状态?
-
-HTTP 是一种不保存状态，即无状态（stateless）协议。也就是说 HTTP 协议自身不对请求和响应之间的通信状态进行保存。那么我们保存用户状态呢？Session 机制的存在就是为了解决这个问题，Session 的主要作用就是通过服务端记录用户的状态。典型的场景是购物车，当你要添加商品到购物车的时候，系统不知道是哪个用户操作的，因为 HTTP 协议是无状态的。服务端给特定的用户创建特定的 Session 之后就可以标识这个用户并且跟踪这个用户了（一般情况下，服务器会在一定时间内保存这个 Session，过了时间限制，就会销毁这个 Session）。
-
-在服务端保存 Session 的方法很多，最常用的就是内存和数据库(比如是使用内存数据库 redis 保存)。既然 Session 存放在服务器端，那么我们如何实现 Session 跟踪呢？大部分情况下，我们都是通过在 Cookie 中附加一个 Session ID 来方式来跟踪。
-
-**Cookie 被禁用怎么办?**
-
-最常用的就是利用 URL 重写把 Session ID 直接附加在 URL 路径的后面。
-
-
-
-### URI 和 URL 的区别是什么?
-
-* URI(Uniform Resource Identifier) 是统一资源标志符，可以唯一标识一个资源。
-* URL(Uniform Resource Locator) 是统一资源定位符，可以提供该资源的路径。它是一种具体的 URI，即 URL 可以用来标识一个资源，而且还指明了如何 locate 这个资源。
-
-URI 的作用像身份证号一样，URL 的作用更像家庭住址一样。URL 是一种具体的 URI，它不仅唯一标识资源，而且还提供了定位该资源的信息。
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-