面经——Java基础

清疚 2023-06-22 03:22 70阅读 0赞

# Java基础 #

--------------------

1.  ArrayList 和 LinkedList 区别
2.  双亲委派模型以及优点
3.  String是否可以被继承及相关原因
4.  String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？
5.  接口和抽象类的区别
6.  Java 中的异常体系
7.  synchronized 底层实现
8.  final关键字
9.  重载和重写的区别
10. 浅拷贝和深拷贝的区别
11. static 关键字
12. wait和sleep区别
13. 反射
14. 为什么java是跨平台的
15. int和Integer区别
16. HashMap详解
17. HashSet 和 HashMap 区别
18. HashMap 和 HashTable 区别
19. ConcurrentHashMap解析
20. ConcurrentHashMap 和 Hashtable 的区别
21. == 和 equals 区别
22. Java 序列化和反序列化

注：题目从牛客 Java部门面经整理而来。  
[2020秋招面经大汇总！（岗位划分）][2020]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70]

--------------------

### ArrayList 和 LinkedList 区别 ###

###### 1. ArrayList概览 ######

因为 ArrayList 是基于数组实现的，所以支持快速随机访问。RandomAccess 接口标识着该类支持快速随机访问。

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

数组的默认大小为 10。

private static final int DEFAULT_CAPACITY = 10;

![在这里插入图片描述][20191213164606701.png]

###### 2. 扩容 ######

添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1) ，也就是旧容量的 1.5 倍。

扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。

###### 3. 删除元素 ######

需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。

--------------------

###### 1. LinkedList 概览 ######

LinkedList 基于双向链表实现，使用 Node 存储链表节点信息。

private static class Node<E> {
        
    E item;
    Node<E> next;
    Node<E> prev;
    }

每个链表存储了 first 和 last 指针：

transient Node<E> first;
    transient Node<E> last

--------------------

###### ArrayList 和 LinkedList 区别 ######

1.  是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
2.  底层数据结构： Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向链表数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环。注意双向链表和双向循环链表的区别：）； 详细可阅读JDK1.7-LinkedList循环链表优化
3.  插入和删除是否受元素位置的影响： ① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行 add(E e) 方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（ add(int index, E element) ）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。
4.  是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于 get(int index) 方法)。
5.  内存空间占用： ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

###### ArrayList 和 LinkedList 实现线程安全 ######

ArrayList 和 LinkedList 是线程不安全的。

线程安全解决办法——换成线程安全的集合：ArrayList -> CopyOnWriteArrayList，LinkedList -> ConcurrentLinkedQueue，HashMap -> ConcurrentHashMap，HashSet -> CopyOnWriteArraySet。

线程安全集合类特点：

1.  都是有线程锁的，所以是线程安全的
2.  CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object\[ \]添加，而是先将当前容器Object\[ \]进行Copy，复制出一个新的容器Object\[\] newElements，然后往新的容器Object\[ \] newElements里添加元素，添加完元素之后，再将原容器的引用指向新的容器 setArray(newElements)。
3.  好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

--------------------

### 2. 双亲委派模型以及优点 ###

###### 类加载器分类 ######

从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：

*  启动类加载器（Bootstrap ClassLoader），使用 C++ 实现，是虚拟机自身的一部分；
 *  所有其它类的加载器，使用 Java 实现，独立于虚拟机，继承自抽象类 java.lang.ClassLoader。

从 Java 开发人员的角度看，类加载器可以划分得更细致一些：

*  启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 <JRE\_HOME>\\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
 *  扩展类加载器（Extension ClassLoader）这个类加载器是由ExtClassLoader（sun.misc.Launcher`$`ExtClassLoader）实现的。它负责将 <JAVA\_HOME>/lib/ext 或者被java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
 *  应用程序类加载器（Application ClassLoader）这个类加载器是由AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是ClassLoader 中的getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

###### 双亲委派模型 ######

应用程序是由三种类加载器互相配合从而实现类加载，除此之外还可以加入自己定义的类加载器。

类加载器之间的层次关系，称为双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其它的类加载器都要有自己的父类加载器。这里的父子关系一般通过组合关系（Composition）来实现，而不是继承关系（Inheritance）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 1]

###### 1. 工作过程 ######

一个类加载器首先将类加载请求转发到父类加载器，只有当父类加载器无法完成时才尝试自己加载。

###### 2. 好处 ######

使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。

例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 并放到 ClassPath 中，程序可以编译通过。由于双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，这是因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。rt.jar 中的 Object 优先级更高，那么程序中所有的 Object 都是这个 Object。

--------------------

### 3. String是否可以被继承及相关原因 ###

String 被声明为 final，因此它不可被继承。

在 Java 8 中，String 内部使用 char 数组存储数据。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
        
    /** The value is used for character storage. */
    private final char value[];
    }

在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 coder 来标识使用了哪种编码。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
        
    /** The value is used for character storage. */
    private final byte[] value;
    /** The identifier of the encoding used to encode the bytes in {@code value}. */
    private final byte coder;
    }

value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value数组的方法，因此可以保证 String 不可变。

###### 不可变的好处 ######

1.  可以缓存 hash 值  
    因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
2.  String Pool 的需要  
    如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用String Pool。
3.  安全性  
    String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
4.  线程安全  
    String 不可变性天生具备线程安全，可以在多个线程中安全地使用

--------------------

### 4. String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？ ###

###### 可变性 ######

简单的来说：String 类中使用 final 关键字字符数组保存字符串， `private final char value[]` ，所以 String对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在AbstractStringBuilder中也是使用字符数组保存字符串 `char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自  
行查阅源码。

AbstractStringBuilder.java
    abstract class AbstractStringBuilder implements Appendable, CharSequence {
        
    char[] value;
    int count;
    AbstractStringBuilder() {
        
    } A
    bstractStringBuilder(int capacity) {
        
    value = new char[capacity];
    }

###### 线程安全性 ######

String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

###### 性能 ######

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。

StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

###### 对于三者使用的总结： ######

1.  操作少量的数据 = String
2.  单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.  多线程操作字符串缓冲区下操作大量数据 = StringBuffer

--------------------

### 5. 接口和抽象类的区别 ###

1.  接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），抽象类可以有非抽象的方法；
2.  接口中的实例变量默认是 final 类型的，而抽象类中则不一定；
3.  一个类可以实现多个接口，但最多只能实现一个抽象类；
4.  一个类实现接口的话要实现接口的所有方法，而抽象类不一定；
5.  接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象。从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

备注:在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错。

--------------------

### Java 中的异常体系 ###

Java异常类层次结构图

在 Java 中，所有的异常都有一个共同的祖先`java.lang`包中的 Throwable 类。Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:

*  `是程序无法处理的错误`，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当JVM 不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
 *  这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（VirtualMachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

Exception（异常）：

*  `是程序本身可以处理的异常`。Exception 类有一个重要的子类 RuntimeException。  
    RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和  
    ArrayIndexOutOfBoundsException （下标越界异常）。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

###### Throwable类常用方法 ######

*  public string getMessage():返回异常发生时的详细信息
 *  public string toString():返回异常发生时的简要描述
 *  public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
 *  public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

###### 异常处理总结 ######

*  try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
 *  catch 块：用于处理try捕获到的异常。
 *  finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

1.  在finally语句块中发生了异常。
2.  在前面的代码中用了System.exit()退出程序。
3.  程序所在的线程死亡。
4.  关闭CPU。

--------------------

### 7. synchronized 底层实现 ###

synchronized 关键字底层原理属于 JVM 层面。

① synchronized 同步语句块的情况

public class SynchronizedDemo {
        
    	public void method() {
        
    		synchronized (this) {
        
    			System.out.println("synchronized 代码块");
    		}
    	}
    }

通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 javac SynchronizedDemo.java 命令生成编译后的 .class 文件，然后执行 javap -c -s -v -l  
SynchronizedDemo.class 。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 2]  
从上面我们可以看出：

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

② synchronized 修饰方法的的情况

public class SynchronizedDemo2 {
        
    	public synchronized void method() {
        
    		System.out.println("synchronized 方法");
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 3]  
synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的是ACC\_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC\_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

更多内容请看：[synchronized 面试五连击][synchronized]

--------------------

### 8. final关键字 ###

final关键字主要用在三个地方：变量、方法、类。

1.  对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
2.  当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
3.  使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

--------------------

### 9. 重载和重写的区别 ###

*  重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
 *  重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

--------------------

### 10. 浅拷贝和深拷贝的区别 ###

深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。

深拷贝和浅拷贝的示意图大致如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 4]

*  浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化。
 *  深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变。

补充：**数据类型**

数据分为基本数据类型(String, Number, Boolean, Null, Undefined，Symbol)和引用数据类型。

1.  基本数据类型的特点：直接存储在栈(stack)中的数据
2.  引用数据类型的特点：存储的是该对象在栈中引用，真实的数据存放在堆内存里。

引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 5]

--------------------

### 11. static 关键字 ###

**1. 静态变量**  
静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。

实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

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. 静态方法**  
静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

public abstract class A {
        
    	public static void func1(){
        
    	} /
    	/ public abstract static void func2(); // Illegal combination of modifiers: 		'abstract' and 'static'
    }

只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。

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. 静态语句块**  
静态语句块在类初始化时运行一次。

public class A {
        
        static {
        
            System.out.println("123");
        }
    
        public static void main(String[] args) {
        
            A a1 = new A();
            A a2 = new A();
        }
    }

**4. 静态内部类**  
非静态内部类依赖于外部类的实例，而静态内部类不需要。

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，从而简化代码，但可读性大大降低。

import static com.xxx.ClassName.*

**6. 初始化顺序**  
静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺  
序。

public static String staticField = "静态变量";static {
        
    
    System.out.println("静态语句块");
    } 
    
    public String field = "实例变量";
    
    {
        
    	System.out.println("普通语句块");
    }

最后才是构造函数的初始化。

public InitialOrderTest() {
        
    	System.out.println("构造函数");
    }

存在继承的情况下，初始化顺序为：

1.  父类（静态变量、静态语句块）
2.  子类（静态变量、静态语句块）
3.  父类（实例变量、普通语句块）
4.  父类（构造函数）
5.  子类（实例变量、普通语句块）
6.  子类（构造函数）

--------------------

### 12. wait和sleep区别 ###

1.  sleep()方法是Thread的静态方法，而wait是Object实例方法
2.  wait()方法必须要在同步方法或者同步块中调用，也就是必须已经获得对象锁。而sleep()方法没有这个限制可以在任何地方种使用。另外，wait()方法会释放占有的对象锁，使得该线程进入等待池中，等待下一次获取资源。而sleep()方法只是会让出CPU并不会释放掉对象锁；
3.  sleep()方法在休眠时间达到后如果再次获得CPU时间片就会继续执行，而wait()方法必须等待Object.notift/Object.notifyAll通知后，才会离开等待池，并且再次获得CPU时间片才会继续执行。
4.  sleep方法有可能会抛出异常，所以需要进行异常处理；wait方法不需要处理

--------------------

### 13. 反射 ###

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

每个类都有一个 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 创建新的对象。

**反射的优点：**

1.  可扩展性 ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
2.  类浏览器和可视化开发环境 ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
3.  调试器和测试工具 ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。

**反射的缺点**：

尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。

1.  性能开销 ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
2.  安全限制 ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
3.  内部暴露 ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。

--------------------

### 14. 为什么java是跨平台的 ###

java程序的运行本质上是先编译成二进制字节码的class文件，再由JVM解释执行class文件。而不同平台上的拥有不同的JVM，都能够运行字节码文件，从而实现不同平台的运行，实现跨平台。

--------------------

### 15. int和Integer区别 ###

Java是一个面向对象编程语言，但是为了编程的方便还是引入不是对象的基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int 的包装类型就是 Integer，从JDK 1.5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

Java 为每个原始类型提供了包装类型：

*  原始类型: boolean，char，byte，short，int，long，float，double
 *  包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

public class AutoUnboxingTest {
          
      
        public static void main(String[] args) {
          
            Integer a = new Integer(3);
            Integer b = 3;              // 将3自动装箱成Integer类型  
            int c = 3;
            System.out.println(a == b); // false 两个引用没有引用同一对象  
            System.out.println(a == c); // true a自动拆箱成int类型再和c比较  
            
            Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
            System.out.println(f1 == f2);//true
            System.out.println(f3 == f4);//false
        }  
    }

首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象，所以上面的 == 运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf。  
通过看valueOf源码可知：字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1 == f2的结果是true，而f3 == f4的结果是false。

**int和Integer区别：**

1.  int是基本数据类型，Integer是int包装类。
2.  Integer变量必须实例化后才能使用，int可以直接使用
3.  Integer的默认值是null，int默认值是0
4.  Integer变量实际上是对象的引用，指向new的Integer对象，int是直接存储数据。

--------------------

### 16. HashMap详解 ###

**1. HashMap 的数据结构？**

JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。JDK1.8后 变化为**数组+链表+红黑树**的存储方式，当链表长度超过阈值（8）时，将链表转换为红黑树。  
HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。

所谓 “拉链法” 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 6]  
TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。

--------------------

**2. HashMap 的工作原理？**

A：HashMap 底层是 hash 数组和单向链表实现，数组中的每个元素都是链表，由 Node 内部类（实现 Map.Entry<K,V>接口）实现，HashMap 通过 put & get 方法存储和获取。

**存储对象时，将 K/V 键值传给 put() 方法：**  
①、调用 hash(K) 方法计算 K 的 hash 值，然后结合数组长度，计算得数组下标；  
②、调整数组大小（当容器中的元素个数大于 capacity \* loadfactor 时，容器会进行扩容resize 为 2n）；  
③、i.如果 K 的 hash 值在 HashMap 中不存在，则执行插入，若存在，则发生碰撞；  
ii.如果 K 的 hash 值在 HashMap 中存在，且它们两者 equals 返回 true，则更新键值对；  
iii. 如果 K 的 hash 值在 HashMap 中存在，且它们两者 equals 返回 false，则插入链表的尾部（尾插法）或者红黑树中（树的添加方式）。  
（JDK 1.7 之前使用头插法、JDK 1.8 使用尾插法）  
（注意：当碰撞导致链表大于 TREEIFY\_THRESHOLD = 8 时，就把链表转换成红黑树）

**获取对象时，将 K 传给 get() 方法：**  
①、调用 hash(K) 方法（计算 K 的 hash 值）从而获取该键值所在链表的数组下标；  
②、顺序遍历链表，equals()方法查找相同 Node 链表中 K 值对应的 V 值。

hashCode 是定位的，存储位置；equals是定性的，比较两者是否相等

--------------------

**3. 当两个对象的 hashCode 相同会发生什么？**  
因为 hashCode 相同，不一定就是相等的（equals方法比较），所以两个对象所在数组的下标相同，"碰撞"就此发生。又因为 HashMap 使用链表存储对象，这个 Node 会存储到链表中。

--------------------

**4. HashMap 的 table 的容量如何确定？loadFactor 是什么？ 该容量如何变化？这种变化会带来什么问题？**

①、table 数组大小是由 capacity 这个参数确定的，默认是16，也可以构造时传入，最大限制是1<<30；  
②、loadFactor 是装载因子，主要目的是用来确认table 数组是否需要动态扩展，默认值是0.75，比如table 数组大小为 16，装载因子为 0.75 时，threshold 就是12，当 table 的实际大小超过 12 时，table就需要动态扩容；  
③、扩容时，调用 resize() 方法，将 table 长度变为原来的两倍（注意是 table 长度，而不是 threshold）  
④、如果数据很大的情况下，扩展时将会带来性能的损失，在性能要求很高的地方，这种损失很可能很致命。

--------------------

**5. HashMap JDK1.7和1.8 的区别？**

1.  出现哈希冲突时，1.7把数据存放在链表，1.8是先放在链表，链表长度超过8就转成红黑树。
2.  1.7扩容条件是数组长度大于阈值且存在哈希冲突，1.8扩容条件是数组长度大于阈值或链表转为红黑树且数组元素小于64时。

--------------------

**6. HashMap 的长度为什么是2的幂次方**  
为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ hash & (n - 1) ”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。

这个算法应该如何设计呢？  
我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“**取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。**” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。

--------------------

**7. 扰动函数（hash方法）**  
所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的hashCode() 方法，换句话说使用扰动函数之后可以减少碰撞。

JDK 1.8 HashMap 的 hash 方法源码:

static final int hash(Object key) {
        
    	int h;
    	// key.hashCode()：返回散列值也就是hashcode
    	// ^ ：按位异或
    	// >>>:无符号右移，忽略符号位，空位都以0补齐
    	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

由源码注释可知，（数组长度-1）正好相当于一个“低位掩码”。“&”操作的结果就是散列值的高位全部归零，只保留低位值，用来做数组下标访问。以初始长度16为例，16-1=15。2进制表示是00000000 00000000 00001111。和某散列值做“与”操作如下，结果就是截取了最低的四位值。

10100101 11000100 00100101
    &   00000000 00000000 00001111
    ----------------------------------
        00000000 00000000 00000101    //高位全部归零，只保留末四位

但这时候问题就来了，这样就算我的散列值分布再松散，要是只取最后几位的话，碰撞也会很严重。更要命的是如果散列本身做得不好，分布上成等差数列的漏洞，恰好使最后几个低位呈现规律性重复，就很不好了。

这时候“扰动函数”的价值就体现出来了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 7]  
右位移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。

--------------------

**8. HashMap扩容**

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>capacity</td> 
   <td>table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。</td> 
  </tr> 
  <tr> 
   <td>size</td> 
   <td>键值对数量。</td> 
  </tr> 
  <tr> 
   <td>threshold</td> 
   <td>size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。</td> 
  </tr> 
  <tr> 
   <td>loadFactor</td> 
   <td>装载因子，table 能够使用的比例，threshold = capacity * loadFactor。</td> 
  </tr> 
 </tbody> 
</table>

扩容使用 resize() 实现，当需要扩容时，令 capacity 为原来的两倍。需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。

在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。

假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：

capacity : 00010000
    new capacity : 00100000

对于一个 Key，它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样。如果为 1，那么得到的结果为原来的结果 +16。

--------------------

### 17. HashSet 和 HashMap 区别 ###

如果你看过 HashSet 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 clone() 方法、writeObject()方法、readObject()方法是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 8]

--------------------

### 18. HashMap 和 Hashtable 的区别 ###

1.  线程是否安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。
2.  效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
3.  对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
4.  初始容量大小和每次扩充容量大小的不同 ：  
    ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。  
    ②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小，也就是说 HashMap 总是使用2的幂作为哈希表的大小。
5.  底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

--------------------

### 19. ConcurrentHashMap解析 ###

**1. ConcurrentHashMap概述**  
ConcurrentHashMap 是 Java并发包 java.util.concurrent 中提供的一个线程安全且高效的 HashMap 实现。ConcurrentHashMap的数据结构已经接近HashMap，相对而言，ConcurrentHashMap只是增加了同步的操作来控制并发，从JDK1.7 版本的 ReentrantLock+Segment+HashEntry，到JDK1.8版本中的synchronized + CAS + HashEntry+红黑树。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 10]

1.  数据结构：取消了Segment分段锁的数据结构，取而代之的是 数组+链表+红黑树的结构。
2.  保证线程安全机制：JDK1.7采用segment的分段锁机制实现线程安全，其中segment继承自ReentrantLock。JDK1.8采用 CAS+synchronized来保证线程安全。
3.  锁的粒度：JDK1.7对需要进行数据操作的segment 加锁，JDK1.8调整为对每个数组元素加锁（Node）
4.  链表转化为红黑树：定位节点的hash算法简化会带来弊端，Hash冲突加剧，因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。
5.  查询时间复杂度：从原来的遍历链表O(n)，变成遍历红黑树O(logN)

--------------------

**2. ConcurrentHashMap线程安全的具体实现方式/底层具体实现**  
**JDK1.7**（上面有示意图）  
首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。  
ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成。  
Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。

static class Segment<K,V> extends ReentrantLock implements Serializable {
        
    }

一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment的锁。

**JDK1.8** （上面有示意图）  
ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构类似，数组+链表/红黑二叉树。  
synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。

--------------------

**3. ConcurrentHashMap 的并发度是什么？**  
程序运行时能够同时更新 ConccurentHashMap 且不产生锁竞争的最大线程数。默认为 16，且可以在构造函数中设置。当用户设置并发度时，ConcurrentHashMap 会使用大于等于该值的最小2幂指数作为实际并发度（假如用户设置并发度为17，实际并发度则为32）

--------------------

**4. ConcurrentHashMap 在 JDK 1.8 中，为什么要使用内置锁 synchronized 来代替重入锁 ReentrantLock？**

1.  粒度降低了；
2.  JVM 开发团队没有放弃 synchronized，而且基于 JVM 的 synchronized 优化空间更大，更加自然。
3.  在大量的数据操作下，对于 JVM 的内存压力，基于 API 的 ReentrantLock 会开销更多的内存。

--------------------

### 20. ConcurrentHashMap 和 Hashtable 的区别 ###

ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

1.  底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
2.  实现线程安全的方式（重要）： ① 在JDK1.7的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。

--------------------

### 21. == 和 equals 区别 ###

**1. == 和 equals 区别**

*  == : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)
 *  equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：  
    情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。  
    情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

**2. 为什么要同时重写equals()和hashCode()**  
当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode方法，它们仅仅是两个对象。违反了“相等的对象必须具有相等的散列码”原则。所以要同时重写equals()和hashCode()。

**3. 为什么要重写 equals 方法**  
因为不重写 equals 方法，执行 user1.equals(user2) 比较的就是两个对象的地址（即 user1 == user2），肯定是不相等的，见 Object 源码：

public boolean equals(Object obj) {
        
        return (this == obj);
    }

**4. 为什么要重写 hashCode 方法**  
当 equals 方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。  
hashCode 是用于散列数据的快速存取，如利用 HashSet/HashMap/Hashtable 类来存储数据时，都会根据存储对象的 hashCode 值来进行判断是否相同的。如果只重写 equals() 而不重写 hashCode() 那么 HashSet 等集合会判定为两个对象，而不是同一个对象。

--------------------

### 22. Java 序列化和反序列化 ###

*  把对象转换为字节序列的过程称为对象的序列化。
 *  把字节序列恢复为对象的过程称为对象的反序列化。

Java 的序列化是为了保存各种对象在内存中的状态，并且可以把保存的对象状态再读取出来。  
以下情况需要使用 Java 序列化：

1.  想把内存中的对象状态保存到一个文件中或者数据库中；
2.  想用套接字在网络上传送对象的时候；
3.  想通过 RMI（远程方法调用）传输对象的时候；

[2020]: https://www.nowcoder.com/discuss/205497
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191216200639723.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[20191213164606701.png]: https://img-blog.csdnimg.cn/20191213164606701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191213171129136.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191214190432951.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191214191010339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[synchronized]: https://blog.csdn.net/weixin_41910694/article/details/103542167
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191214203708117.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191214205018738.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191216142703457.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191216154146790.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191216161601965.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191216163725572.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20191216163752400.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA==,size_16,color_FFFFFF,t_70