JVM#

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

JVM 并不是只有一种！只要满足 JVM 规范，每个公司、组织或者个人都可以开发自己的专属 JVM。也就是说我们平时接触到的 HotSpot VM 仅仅是是 JVM 规范的一种实现而已。

除了我们平时最常用的 HotSpot VM 外，还有 J9 VM、Zing VM、JRockit VM 等 JVM 。维基百科上就有常见 JVM 的对比：Comparison of Java virtual machines

JDK和JRE#

JDK（Java Development Kit），它是功能齐全的 Java SDK，是提供给开发者使用，能够创建和编译 Java 程序的开发套件。它包含了 JRE，同时还包含了编译 java 源码的编译器 javac 以及一些其他工具比如 javadoc（文档注释工具）、jdb（调试器）、jconsole（基于 JMX 的可视化监控⼯具）、javap（反编译工具）等等。

JRE（Java Runtime Environment） 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，主要包括 Java 虚拟机（JVM）、Java 基础类库（Class Library）。

也就是说，JRE 是 Java 运行时环境，仅包含 Java 应用程序的运行时环境和必要的类库。而 JDK 则包含了 JRE，同时还包括了 javac、javadoc、jdb、jconsole、javap 等工具，可以用于 Java 应用程序的开发和调试。如果需要进行 Java 编程工作，比如编写和编译 Java 程序、使用 Java API 文档等，就需要安装 JDK。而对于某些需要使用 Java 特性的应用程序，如 JSP 转换为 Java Servlet、使用反射等，也需要 JDK 来编译和运行 Java 代码。因此，即使不打算进行 Java 应用程序的开发工作，也有可能需要安装 JDK。

不过，从 JDK 9 开始，就不需要区分 JDK 和 JRE 的关系了，取而代之的是模块系统（JDK 被重新组织成 94 个模块）+ jlink 工具 (随 Java 9 一起发布的新命令行工具，用于生成自定义 Java 运行时映像，该映像仅包含给定应用程序所需的模块) 。并且，从 JDK 11 开始，Oracle 不再提供单独的 JRE 下载。

注释有哪几种形式？#

Java 中的注释有三种：

• 单行注释：以 // 开头，一直到行尾的内容都是注释
• 多行注释：以 /* 开头，以 / 结尾，中间的内容都是注释
• 文档注释：以 /** 开头，以 / 结尾，中间的内容都是注释，但是文档注释可以通过 javadoc 工具生成一定格式的文档

用的比较多的还是单行注释和文档注释，多行注释在实际开发中使用的相对较少。

在我们编写代码的时候，如果代码量比较少，我们自己或者团队其他成员还可以很轻易地看懂代码，但是当项目结构一旦复杂起来，我们就需要用到注释了。注释并不会执行(编译器在编译代码之前会把代码中的所有注释抹掉,字节码中不保留注释)，是我们程序员写给自己看的，注释是你的代码说明书，能够帮助看代码的人快速地理清代码之间的逻辑关系。因此，在写程序的时候随手加上注释是一个非常好的习惯。

代码的注释不是越详细越好。实际上好的代码本身就是注释，我们要尽量规范和美化自己的代码来减少不必要的注释。
若编程语言足够有表达力，就不需要注释，尽量通过代码来阐述。

标识符和关键字的区别是什么？#

在我们编写程序的时候，需要大量地为程序、类、变量、方法等取名字，于是就有了 标识符 。简单来说， 标识符就是一个名字 。

有一些标识符，Java 语言已经赋予了其特殊的含义，只能用于特定的地方，这些特殊的标识符就是 关键字 。简单来说，关键字是被赋予特殊含义的标识符 。

Java 语言关键字有哪些？#

• 分类关键字访问控制 private/protected/public
• 类，方法和变量修饰符 abstract/class/extends/final/implements/interface/native/new/static/strictfp/synchronized/transient/volatile/enum
• 程序控制 break/continue/return/do/while/if/else/for/instanceof/switch/case/default/assert
• 错误处理 try/catch/throw/throws/finally
• 包相关 import/package
• 基本类型 boolean/byte/char/double/float/int/long/short
• 变量引用 super/this/void
• 保留字 goto/const

Tips：所有的关键字都是小写的，在 IDE 中会以特殊颜色显示。
default 这个关键字很特殊，既属于程序控制，也属于类，方法和变量修饰符，还属于访问控制。

• 在程序控制中，当在 switch 中匹配不到任何情况时，可以使用 default 来编写默认匹配的情况。
• 在类，方法和变量修饰符中，从 JDK8 开始引入了默认方法，可以使用 default 关键字来定义一个方法的默认实现。
• 在访问控制中，如果一个方法前没有任何修饰符，则默认会有一个修饰符 default，但是这个修饰符加上了就会报错。

注意：虽然 true, false, 和 null 看起来像关键字但实际上他们是字面值，同时你也不可以作为标识符来使用。

官方文档

自增自减运算符#

在写代码的过程中，常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++)和自减运算符（--）。 ++ 和 -- 运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。

移位运算符#

移位运算符是最基本的运算符之一，几乎每种编程语言都包含这一运算符。移位操作中，被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。移位运算符在各种框架以及 JDK 自身的源码中使用还是挺广泛的，HashMap（JDK1.8） 中的 hash 方法的源码就用到了移位运算符

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

Java 中有三种移位运算符

• <<：左移运算符，num << 1,相当于num乘以2
• >>：右移运算符，num >> 1,相当于num除以2
• >>>：无符号右移，忽略符号位，空位都以0补齐

在 Java 代码里使用 <<、 >> 和>>>转换成的指令码运行起来会更高效些。掌握最基本的移位运算符知识还是很有必要的，这不光可以帮助我们在代码中使用，还可以帮助我们理解源码中涉及到移位运算符的代码。

由于 double，float 在二进制中的表现比较特殊，因此不能来进行移位操作。移位操作符实际上支持的类型只有int和long，编译器在对short、byte、char类型进行移位前，都会将其转换为int类型再操作。

如果移位的位数超过数值所占有的位数会怎样？当 int 类型左移/右移位数大于等于 32 位操作时，会先求余（%）后再进行左移/右移操作。也就是说左移/右移 32 位相当于不进行移位操作（32%32=0），左移/右移 42 位相当于左移/右移 10 位（42%32=10）。当 long 类型进行左移/右移操作时，由于 long 对应的二进制是 64 位，因此求余操作的基数也变成了 64。

continue、break 和 return 的区别是什么？#

在循环结构中，当循环条件不满足或者循环次数达到要求时，循环会正常结束。但是，有时候可能需要在循环的过程中，当发生了某种条件之后 ，提前终止循环，这就需要用到下面几个关键词：

1. continue：指跳出当前的这一次循环，继续下一次循环
2. break：指跳出整个循环体，继续执行循环下面的语句
3. return 用于跳出所在方法，结束该方法的运行。
   • return;：直接使用 return 结束方法执行，用于没有返回值函数的方法
   • return value;：return 一个特定值，用于有返回值函数的方法

基本类型和包装类型的区别？#

• 用途：除了定义一些常量和局部变量之外，我们在其他地方比如方法参数、对象属性中很少会使用基本类型来定义变量。并且，包装类型可用于泛型，而基本类型不可以。
• 存储方式：基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
• 占用空间：相比于包装类型（对象类型）， 基本数据类型占用的空间往往非常小。
• 默认值：成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
• 比较方式：对于基本数据类型来说，== 比较的是值。对于包装数据类型来说，== 比较的是对象的内存地址。所有整型包装类对象之间值的比较，全部使用 equals() 方法。

为什么说是几乎所有对象实例都存在于堆中呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存

注意：基本数据类型存放在栈中是一个常见的误区！ 基本数据类型的存储位置取决于它们的作用域和声明方式。如果它们是局部变量，那么它们会存放在栈中；如果它们是成员变量，那么它们会存放在堆中。

包装类型的缓存机制了解么？#

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。

两种浮点数类型的包装类 Float,Double 并没有实现缓存机制。

记住：所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

自动装箱与拆箱了解吗？原理是什么？#

什么是自动拆装箱？

• 装箱：将基本类型用它们对应的引用类型包装起来；
• 拆箱：将包装类型转换为基本数据类型；

1
Integer i = 10;  //装箱
2
int n = i;   //拆箱

从字节码中，我们发现装箱其实就是调用了 包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法。因此，

• Integer i = 10 等价于 Integer i = Integer.valueOf(10)
• int n = i 等价于 int n = i.intValue()

注意：如果频繁拆装箱的话，也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。

1
BigDecimal a = new BigDecimal("1.0");
2
BigDecimal b = new BigDecimal("0.9");
3
BigDecimal c = new BigDecimal("0.8");
4

5
BigDecimal x = a.subtract(b);
6
BigDecimal y = b.subtract(c);
7

8
System.out.println(x); /* 0.1 */
9
System.out.println(y); /* 0.1 */
10
System.out.println(Objects.equals(x, y)); /* true */

1
long l = Long.MAX_VALUE;
2
System.out.println(l + 1); // -9223372036854775808
3
System.out.println(l + 1 == Long.MIN_VALUE); // true

变量#

1
public class StaticVariableExample {
2
    // 静态变量
3
    public static int staticVar = 0;
4
}

1
public class StringExample {
2
    // 字符型常量
3
    public static final char LETTER_A = 'A';
4

5
    // 字符串常量
6
    public static final String GREETING_MESSAGE = "Hello, world!";
7
    public static void main(String[] args) {
8
        System.out.println("字符型常量占用的字节数为："+Character.BYTES);
9
        // 2
10
        System.out.println("字符串常量占用的字节数为："+GREETING_MESSAGE.getBytes().length);
11
        // 13
12
    }
13
}

方法#

1
public class Example {
2
    // 定义一个字符型常量
3
    public static final char LETTER_A = 'A';
4

5
    // 定义一个字符串常量
6
    public static final String GREETING_MESSAGE = "Hello, world!";
7

8
    public static void main(String[] args) {
9
        // 输出字符型常量的值
10
        System.out.println("字符型常量的值为：" + LETTER_A);
11

12
        // 输出字符串常量的值
13
        System.out.println("字符串常量的值为：" + GREETING_MESSAGE);
14
    }
15
}

1
public class Person {
2
    public void method() {
3
      //......
4
    }
5

6
    public static void staicMethod(){
7
      //......
8
    }
9
    public static void main(String[] args) {
10
        Person person = new Person();
11
        // 调用实例方法
12
        person.method();
13
        // 调用静态方法
14
        Person.staicMethod()
15
    }
16
}

1
public static void method1(String... args) {
2
//......}

1
public static void method2(String arg1, String... args) {
2
//......}

面向对象和面向过程的区别#

两者的主要区别在于解决问题的方式不同：

1. 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
2. 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。

另外，面向对象开发的程序一般更易维护、易复用、易扩展。

创建一个对象用什么运算符?对象实体与对象引用有何不同?#

new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

• 一个对象引用可以指向 0 个或 1 个对象；
• 一个对象可以有 n 个引用指向它。

对象的相等和引用相等的区别#

• 对象的相等一般比较的是内存中存放的内容是否相等。
• 引用相等一般比较的是他们指向的内存地址是否相等。

如果一个类没有声明构造方法，该程序能正确执行吗?#

构造方法是一种特殊的方法，主要作用是完成对象的初始化工作。

如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会添加默认的无参数的构造方法了。

构造方法有哪些特点？是否可被 override?#

构造方法特点如下：

• 名字与类名相同。
• 没有返回值，但不能用 void 声明构造函数。
• 生成类的对象时自动执行，无需调用。

构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

面向对象三大特征#

1. 封装

   封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

2. 继承

   不同类型的对象，相互之间经常有一定数量的共同点。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。

   • 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
   • 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
   • 子类可以用自己的方式实现父类的方法。（以后介绍）。

3. 多态

   多态，顾名思义，表示一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。

   多态的特点:

   • 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
   • 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
   • 多态不能调用“只在子类存在但在父类不存在”的方法；
   • 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

接口和抽象类有什么共同点和区别？#

共同点：

• 都不能被实例化。
• 都可以包含抽象方法。
• 都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

区别：

• 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
• 一个类只能继承一个类，但是可以实现多个接口。
• 接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

深拷贝和浅拷贝区别了解吗？什么是引用拷贝？#

• 浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
• 深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

Object 类的常见方法有哪些？#

Object 类是一个特殊的类，是所有类的父类。它主要提供了以下 11 个方法：

1
/**
2
 * native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。
3
 */
4
public final native Class<?> getClass()
5
/**
6
 * native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。
7
 */
8
public native int hashCode()
9
/**
10
 * 用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。
11
 */
12
public boolean equals(Object obj)
13
/**
14
 * native 方法，用于创建并返回当前对象的一份拷贝。
15
 */
16
protected native Object clone() throws CloneNotSupportedException
17
/**
18
 * 返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。
19
 */
20
public String toString()
21
/**
22
 * native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
23
 */
24
public final native void notify()
25
/**
26
 * native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
27
 */
28
public final native void notifyAll()
29
/**
30
 * native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。
31
 */
32
public final native void wait(long timeout) throws InterruptedException
33
/**
34
 * 多了 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。
35
 */
36
public final void wait(long timeout, int nanos) throws InterruptedException
37
/**
38
 * 跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
39
 */
40
public final void wait() throws InterruptedException
41
/**
42
 * 实例被垃圾回收器回收的时候触发的操作
43
 */
44
protected void finalize() throws Throwable { }

== 和 equals() 的区别#

== 对于基本类型和引用类型的作用效果是不同的：

• 对于基本数据类型来说，== 比较的是值。
• 对于引用数据类型来说，== 比较的是对象的内存地址。

因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法。

Object 类 equals() 方法：

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

equals() 方法存在两种使用情况：

• 类没有重写 equals()方法：通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 Object类equals()方法。
• 类重写了 equals()方法：一般我们都重写 equals()方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回 true(即，认为这两个对象相等)。

当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

hashCode() 有什么用？#

hashCode() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是：Object 的 hashCode() 方法是本地方法，也就是用 C 语言或 C++ 实现的。

注意：该方法在 Oracle OpenJDK8 中默认是 “使用线程局部状态来实现 Marsaglia’s xor-shift 随机数生成”, 并不是 “地址” 或者 “地址转换而来”, 不同 JDK/VM 可能不同在 Oracle OpenJDK8 中有六种生成方式 (其中第五种是返回地址), 通过添加 VM 参数: -XX=4 启用第五种。参考源码:

• https://hg.openjdk.org/jdk8u/jdk8u/hotspot/file/87ee5ee27509/src/share/vm/runtime/globals.hpp（1127 行）
• https://hg.openjdk.org/jdk8u/jdk8u/hotspot/file/87ee5ee27509/src/share/vm/runtime/synchronizer.cpp（537 行开始）

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

为什么要有 hashCode？#

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode？

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashCode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashCode 值作比较，如果没有相符的 hashCode，HashSet 会假设对象没有重复出现。
但是如果发现有相同 hashCode 值的对象，这时会调用 equals() 方法来检查 hashCode 相等的对象是否真的相同。
如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。
这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

其实， hashCode() 和 equals()都是用于比较两个对象是否相等。

那为什么 JDK 还要同时提供这两个方法呢？

这是因为在一些容器（比如 HashMap、HashSet）中，有了 hashCode() 之后，判断元素是否在对应容器中的效率会更高（参考添加元素进HashSet的过程）！

我们在前面也提到了添加元素进HashSet的过程，如果 HashSet 在对比的时候，同样的 hashCode 有多个对象，它会继续使用 equals() 来判断是否真的相同。也就是说 hashCode 帮助我们大大缩小了查找成本。

那为什么不只提供 hashCode() 方法呢？

这是因为两个对象的hashCode 值相等并不代表两个对象就相等。

那为什么两个对象有相同的 hashCode 值，它们也不一定是相等的？

因为 hashCode() 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓哈希碰撞也就是指的是不同的对象得到相同的 hashCode)。

• 如果两个对象的hashCode 值相等，那这两个对象不一定相等（哈希碰撞）。
• 如果两个对象的hashCode 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。
• 如果两个对象的hashCode 值不相等，我们就可以直接认为这两个对象不相等。

为什么重写 equals() 时必须重写 hashCode() 方法？#

因为两个相等的对象的 hashCode 值必须是相等。也就是说如果 equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。

如果重写 equals() 时没有重写 hashCode() 方法的话就可能会导致 equals 方法判断是相等的两个对象，hashCode 值却不相等。

• equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。
• 两个对象有相同的 hashCode 值，他们也不一定是相等的（哈希碰撞）。

String、StringBuffer、StringBuilder 的区别？#

• 可变性

  String 是不可变的（后面会详细分析原因）。

  StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法比如 append 方法。

  1
  abstract class AbstractStringBuilder implements Appendable, CharSequence {
  2
      char[] value;
  3
      public AbstractStringBuilder append(String str) {
  4
          if (str == null)
  5
              return appendNull();
  6
          int len = str.length();
  7
          ensureCapacityInternal(count + len);
  8
          str.getChars(0, len, value, count);
  9
          count += len;
  10
          return this;
  11
      }
  12
      //...
  13
  }

• 线程安全性

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

• 性能

  每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

对于三者使用的总结：

• 操作少量的数据: 适用 String
• 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
• 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer

String 为什么是不可变的?#

String 类中使用 final 关键字修饰字符数组来保存字符串,被 final 关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。

1. 保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。
2. String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 不可变。

在 Java 9 之后，String、StringBuilder 与 StringBuffer 的实现改用 byte 数组存储字符串。

新版的 String 其实支持两个编码方案：Latin-1 和 UTF-16。如果字符串中包含的汉字没有超过 Latin-1 可表示范围内的字符，那就会使用 Latin-1 作为编码方案。Latin-1 编码方案下，byte 占一个字节(8 位)，char 占用 2 个字节（16），byte 相较 char 节省一半的内存空间。 如果字符串中包含的汉字超过 Latin-1 可表示范围内的字符，byte 和 char 所占用的空间是一样的。

字符串拼接用“+” 还是 StringBuilder?#

Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。

字符串对象通过“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象 。

不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：编译器不会创建单个 StringBuilder 以复用，会导致创建过多的 StringBuilder 对象。

不过，使用 “+” 进行字符串拼接会产生大量的临时对象的问题在 JDK9 中得到了解决。在 JDK9 当中，字符串相加 “+” 改为了用动态方法 makeConcatWithConstants() 来实现，而不是大量的 StringBuilder 了。

String#equals() 和 Object#equals() 有何区别？#

String 中的 equals 方法是被重写过的，比较的是 String 字符串的值是否相等。 Object 的 equals 方法是比较的对象的内存地址。

字符串常量池的作用了解吗？#

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

1
// 在堆中创建字符串对象”ab“
2
// 将字符串对象”ab“的引用保存在字符串常量池中
3
String aa = "ab";
4
// 直接返回字符串常量池中字符串对象”ab“的引用
5
String bb = "ab";
6
System.out.println(aa==bb);// true

String s1 = new String(“abc”);这句话创建了几个字符串对象？#

会创建 1 或 2 个字符串对象。

1. 如果字符串常量池中不存在字符串对象“abc”的引用，那么它会在堆上创建两个字符串对象，其中一个字符串对象的引用会被保存在字符串常量池中。
2. 如果字符串常量池中已存在字符串对象“abc”的引用，则只会在堆中创建 1 个字符串对象“abc”。

String#intern 方法有什么作用?#

String.intern() 是一个 native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：

1. 如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。
2. 如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。

1
// 在堆中创建字符串对象”Java“
2
// 将字符串对象”Java“的引用保存在字符串常量池中
3
String s1 = "Java";
4
// 直接返回字符串常量池中字符串对象”Java“对应的引用
5
String s2 = s1.intern();
6
// 会在堆中在单独创建一个字符串对象
7
String s3 = new String("Java");
8
// 直接返回字符串常量池中字符串对象”Java“对应的引用
9
String s4 = s3.intern();
10
// s1 和 s2 指向的是堆中的同一个对象
11
System.out.println(s1 == s2); // true
12
// s3 和 s4 指向的是堆中不同的对象
13
System.out.println(s3 == s4); // false
14
// s1 和 s4 指向的是堆中的同一个对象
15
System.out.println(s1 == s4); //true

String 类型的变量和常量做“+”运算时发生了什么？#

对于编译期可以确定值的字符串，也就是常量字符串 ，jvm 会将其存入字符串常量池。并且，字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池，这个得益于编译器的优化。

在编译过程中，Javac 编译器（下文中统称为编译器）会进行一个叫做 常量折叠(Constant Folding) 的代码优化

常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中，这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。

对于 String str3 = "str" + "ing"; 编译器会给你优化成 String str3 = "string"; 。

并不是所有的常量都会进行折叠，只有编译器在程序编译期就可以确定值的常量才可以：

• 基本数据类型( byte、boolean、short、char、int、float、long、double)以及字符串常量。
• final 修饰的基本数据类型和字符串变量
• 字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（<<、>>、>>> ）

引用的值在程序编译期是无法确定的，编译器无法对其进行优化。

对象引用和“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象 。

被 final 关键字修饰之后的 String 会被编译器当做常量来处理，编译器在程序编译期就可以确定它的值，其效果就相当于访问常量。

如果 ，编译器在运行时才能知道其确切值的话，就无法对其优化。

Java 异常类层次结构图概览#

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 有什么区别？#

Checked Exception 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。

除了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 语句块将在方法返回之前被执行。

注意：不要在 finally 语句块中使用 return!
当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。

finally 中的代码一定会执行吗？#

不一定的！在某些情况下，finally 中的代码不会被执行。

就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

另外，在以下 2 种特殊情况下，finally 块的代码也不会被执行：

• 程序所在的线程死亡。
• 关闭 CPU。

如何使用 try-with-resources 代替try-catch-finally？#

1. 适用范围（资源的定义）： 任何实现 java.lang.AutoCloseable或者 java.io.Closeable 的对象
2. 关闭资源和 finally 块的执行顺序： 在 try-with-resources 语句中，任何 catch 或 finally 块在声明的资源关闭后运行

Java 中类似于InputStream、OutputStream、Scanner、PrintWriter等的资源都需要我们调用close()方法来手动关闭，一般情况下我们都是通过try-catch-finally语句来实现这个需求

当然多个资源需要关闭的时候，使用 try-with-resources 实现起来也非常简单，如果你还是用try-catch-finally可能会带来很多问题。

通过使用分号分隔，可以在try-with-resources块中声明多个资源。

异常使用有哪些需要注意的地方？#

• 不要把异常定义为静态变量，因为这样会导致异常栈信息错乱。每次手动抛出异常，我们都需要手动 new 一个异常对象抛出。
• 抛出的异常信息一定要有意义。
• 建议抛出更加具体的异常比如字符串转换为数字格式错误的时候应该抛出NumberFormatException而不是其父类IllegalArgumentException。
• 使用日志打印异常之后就不要再抛出异常了（两者不要同时存在一段代码逻辑中）

什么是泛型？有什么作用？#

Java 泛型（Generics） 是 JDK 5 中引入的一个新特性。使用泛型参数，可以增强代码的可读性以及稳定性。

编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如 ArrayList<Person> persons = new ArrayList<Person>() 这行代码就指明了该 ArrayList 对象只能传入 Person 对象，如果传入其他类型的对象就会报错。

1
ArrayList<E> extends AbstractList<E>

并且，原生 List 返回类型是 Object ，需要手动转换类型才能使用，使用泛型后编译器自动转换。

泛型的使用方式有哪几种？#

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。

1. 泛型类

   1
   //此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
   2
   //在实例化泛型类时，必须指定T的具体类型
   3
   public class Generic<T>{
   4
   
   5
       private T key;
   6
   
   7
       public Generic(T key) {
   8
           this.key = key;
   9
       }
   10
   
   11
       public T getKey(){
   12
           return key;
   13
       }
   14
   }

2. 泛型接口

   1
   public interface Generator<T> {
   2
       public T next();
   3
   }

3. 泛型方法

   1
   public static < E > void printArray( E[] inputArray ) {
   2
        for ( E element : inputArray ){
   3
           System.out.printf( "%s ", element );
   4
        }
   5
        System.out.println();
   6
   }

注意: public static < E > void printArray( E[] inputArray ) 一般被称为静态泛型方法;在 java 中泛型只是一个占位符，必须在传递类型后才能使用。
类在实例化时才能真正的传递类型参数，由于静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数，静态的方法的加载就已经完成了，所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的

项目中哪里用到了泛型？#

• 自定义接口通用返回结果 CommonResult<T> 通过参数 T 可根据具体的返回类型动态指定结果的数据类型
• 定义 Excel 处理类 ExcelUtil<T> 用于动态指定 Excel 导出的数据类型
• 构建集合工具类（参考 Collections 中的 sort, binarySearch 方法）。

何谓反射？#

如果说大家研究过框架的底层原理或者咱们自己写过框架的话，一定对反射这个概念不陌生。反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。

反射的优缺点？#

反射可以让我们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利。

不过，反射让我们在运行时有了分析操作类的能力的同时，也增加了安全问题，比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的。

反射的应用场景？#

像咱们平时大部分时候都是在写业务代码，很少会接触到直接使用反射机制的场景。但是！这并不代表反射没有用。相反，正是因为反射，你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。

这些框架中也大量使用了动态代理，而动态代理的实现也依赖反射。

比如下面是通过 JDK 实现动态代理的示例代码，其中就使用了反射类 Method 来调用指定的方法。

1
public class DebugInvocationHandler implements InvocationHandler {
2
    /**
3
     * 代理类中的真实对象
4
     */
5
    private final Object target;
6

7
    public DebugInvocationHandler(Object target) {
8
        this.target = target;
9
    }
10

11
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
12
        System.out.println("before method " + method.getName());
13
        Object result = method.invoke(target, args);
14
        System.out.println("after method " + method.getName());
15
        return result;
16
    }
17
}

另外，像 Java 中的一大利器 注解 的实现也用到了反射。

为什么你使用 Spring 的时候 ，一个@Component注解就声明了一个类为 Spring Bean 呢？为什么你通过一个 @Value注解就读取到配置文件中的值呢？究竟是怎么起作用的呢？

这些都是因为你可以基于反射分析类，然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后，就可以做进一步的处理。

何谓注解？#

Annotation （注解） 是 Java5 开始引入的新特性，可以看作是一种特殊的注释，主要用于修饰类、方法或者变量，提供某些信息供程序在编译或者运行时使用。

注解本质是一个继承了Annotation 的特殊接口：

1
@Target(ElementType.METHOD)
2
@Retention(RetentionPolicy.SOURCE)
3
public @interface Override {
4

5
}
6

7
public interface Override extends Annotation{
8

9
}

JDK 提供了很多内置的注解（比如 @Override、@Deprecated），同时，我们还可以自定义注解。

注解的解析方法有哪几种？#

注解只有被解析之后才会生效，常见的解析方法有两种：

• 编译期直接扫描：编译器在编译 Java 代码的时候扫描对应的注解并处理，比如某个方法使用@Override 注解，编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。
• 运行期通过反射处理：像框架中自带的注解(比如 Spring 框架的 @Value、@Component)都是通过反射来进行处理的。

何谓 SPI?#

SPI 即 Service Provider Interface ，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。

SPI 将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。

很多框架都使用了 Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。

SPI 和 API 有什么区别？#

那 SPI 和 API 有啥区别？

说到 SPI 就不得不说一下 API 了，从广义上来说它们都属于接口，而且很容易混淆。

一般模块之间都是通过接口进行通讯，那我们在服务调用方和服务实现方（也称服务提供者）之间引入一个“接口”。

当实现方提供了接口和实现，我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力，这就是 API ，这种接口和实现都是放在实现方的。

当接口存在于调用方这边时，就是 SPI ，由接口调用方确定接口规则，然后由不同的厂商去根据这个规则对这个接口进行实现，从而提供服务。

SPI实现-ServiceLoader#

Java 中的 SPI 机制就是在每次类加载的时候会先去找到 class 相对目录下的 META-INF 文件夹下的 services 文件夹下的文件，将这个文件夹下面的所有文件先加载到内存中，然后根据这些文件的文件名和里面的文件内容找到相应接口的具体实现类，找到实现类后就可以通过反射去生成对应的对象，保存在一个 list 列表里面，所以可以通过迭代或者遍历的方式拿到对应的实例对象，生成不同的实现。

所以会提出一些规范要求：文件名一定要是接口的全类名，然后里面的内容一定要是实现类的全类名，实现类可以有多个，直接换行就好了，多个实现类的时候，会一个一个的迭代加载。

ServiceLoader 具体实现想要使用 Java 的 SPI 机制是需要依赖 ServiceLoader 来实现的，那么我们接下来看看 ServiceLoader 具体是怎么做的：ServiceLoader 是 JDK 提供的一个工具类， 位于package java.util包下。

来自javaGuide的serviceLoader

1
package edu.jiangxuan.up.service;
2

3
import java.io.BufferedReader;
4
import java.io.InputStream;
5
import java.io.InputStreamReader;
6
import java.lang.reflect.Constructor;
7
import java.net.URL;
8
import java.net.URLConnection;
9
import java.util.ArrayList;
10
import java.util.Enumeration;
11
import java.util.List;
12

13
public class MyServiceLoader<S> {
14

15
    // 对应的接口 Class 模板
16
    private final Class<S> service;
17

18
    // 对应实现类的 可以有多个，用 List 进行封装
19
    private final List<S> providers = new ArrayList<>();
20

21
    // 类加载器
22
    private final ClassLoader classLoader;
23

24
    // 暴露给外部使用的方法，通过调用这个方法可以开始加载自己定制的实现流程。
25
    public static <S> MyServiceLoader<S> load(Class<S> service) {
26
        return new MyServiceLoader<>(service);
27
    }
28

29
    // 构造方法私有化
30
    private MyServiceLoader(Class<S> service) {
31
        this.service = service;
32
        this.classLoader = Thread.currentThread().getContextClassLoader();
33
        doLoad();
34
    }
35

36
    // 关键方法，加载具体实现类的逻辑
37
    private void doLoad() {
38
        try {
39
            // 读取所有 jar 包里面 META-INF/services 包下面的文件，这个文件名就是接口名，然后文件里面的内容就是具体的实现类的路径加全类名
40
            Enumeration<URL> urls = classLoader.getResources("META-INF/services/" + service.getName());
41
            // 挨个遍历取到的文件
42
            while (urls.hasMoreElements()) {
43
                // 取出当前的文件
44
                URL url = urls.nextElement();
45
                System.out.println("File = " + url.getPath());
46
                // 建立链接
47
                URLConnection urlConnection = url.openConnection();
48
                urlConnection.setUseCaches(false);
49
                // 获取文件输入流
50
                InputStream inputStream = urlConnection.getInputStream();
51
                // 从文件输入流获取缓存
52
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
53
                // 从文件内容里面得到实现类的全类名
54
                String className = bufferedReader.readLine();
55

56
                while (className != null) {
57
                    // 通过反射拿到实现类的实例
58
                    Class<?> clazz = Class.forName(className, false, classLoader);
59
                    // 如果声明的接口跟这个具体的实现类是属于同一类型，（可以理解为Java的一种多态，接口跟实现类、父类和子类等等这种关系。）则构造实例
60
                    if (service.isAssignableFrom(clazz)) {
61
                        Constructor<? extends S> constructor = (Constructor<? extends S>) clazz.getConstructor();
62
                        S instance = constructor.newInstance();
63
                        // 把当前构造的实例对象添加到 Provider的列表里面
64
                        providers.add(instance);
65
                    }
66
                    // 继续读取下一行的实现类，可以有多个实现类，只需要换行就可以了。
67
                    className = bufferedReader.readLine();
68
                }
69
            }
70
        } catch (Exception e) {
71
            System.out.println("读取文件异常。。。");
72
        }
73
    }
74

75
    // 返回spi接口对应的具体实现类列表
76
    public List<S> getProviders() {
77
        return providers;
78
    }
79
}

主要的流程就是：

1. 通过 URL 工具类从 jar 包的 /META-INF/services 目录下面找到对应的文件
2. 读取这个文件的名称找到对应的 spi 接口
3. 通过 InputStream 流将文件里面的具体实现类的全类名读取出来
4. 根据获取到的全类名，先判断跟 spi 接口是否为同一类型，如果是的，那么就通过反射的机制构造对应的实例对象
5. 将构造出来的实例对象添加到 Providers 的列表中。

其实不难发现，SPI 机制的具体实现本质上还是通过反射完成的。即：我们按照规定将要暴露对外使用的具体实现类在 META-INF/services/ 文件下声明。

另外，SPI 机制在很多框架中都有应用：Spring 框架的基本原理也是类似的方式。还有 Dubbo 框架提供同样的 SPI 扩展机制，只不过 Dubbo 和 spring 框架中的 SPI 机制具体实现方式跟上面有些细微的区别，不过整体的原理都是一致的。

SPI 的优缺点？#

通过 SPI 机制能够大大地提高接口设计的灵活性，但是 SPI 机制也存在一些缺点，比如：

• 需要遍历加载所有的实现类，不能做到按需加载，这样效率还是相对较低的。
• 当多个 ServiceLoader 同时 load 时，会有并发问题。

什么是序列化?什么是反序列化?#

如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。

• 序列化：将数据结构或对象转换成二进制字节流的过程
• 反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。

下面是序列化和反序列化常见应用场景：

• 对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；
• 将对象存储到文件之前需要进行序列化，将对象从文件中读取出来需要进行反序列化；
• 将对象存储到数据库（如 Redis）之前需要用到序列化，将对象从缓存数据库中读取出来需要反序列化；
• 将对象存储到内存之前需要进行序列化，从内存中读取出来之后需要进行反序列化。

序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

序列化协议对应于 TCP/IP 4 层模型的哪一层？#

我们知道网络通信的双方必须要采用和遵守相同的协议。TCP/IP 四层模型是下面这样的，序列化协议属于哪一层呢？

如上图所示，OSI 七层协议模型中，表示层做的事情主要就是对应用层的用户数据进行处理转换为二进制流。反过来的话，就是将二进制流转换成应用层的用户数据。这不就对应的是序列化和反序列化么？

因为，OSI 七层协议模型中的应用层、表示层和会话层对应的都是 TCP/IP 四层模型中的应用层，所以序列化协议属于 TCP/IP 协议应用层的一部分。

如果有些字段不想进行序列化怎么办？#

对于不想进行序列化的变量，使用 transient 关键字修饰。

transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

关于 transient 还有几点注意：

• transient 只能修饰变量，不能修饰类和方法。
• transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。
• static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化。

常见序列化协议有哪些？#

JDK 自带的序列化方式一般不会用 ，因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff，这些都是基于二进制的序列化协议。

像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好，但是性能较差，一般不会选择。

为什么不推荐使用 JDK 自带的序列化？#

我们很少或者说几乎不会直接使用 JDK 自带的序列化方式，主要原因有下面这些原因：

• 不支持跨语言调用 : 如果调用的是其他语言开发的服务的时候就不支持了。
• 性能差：相比于其他序列化框架性能更低，主要原因是序列化之后的字节数组体积较大，导致传输成本加大。
• 存在安全问题：序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码。

Java IO 流了解吗？#

IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

• InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
• OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

I/O 流为什么要分为字节流和字符流呢?#

问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

个人认为主要有两点原因：

• 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时
• 如果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题。

Java IO 中的设计模式有哪些？#

1
class PollingWatchService
2
    extends AbstractWatchService
3
{
4
    // 定义一个 daemon thread（守护线程）轮询检测文件变化
5
    private final ScheduledExecutorService scheduledExecutor;
6

7
    PollingWatchService() {
8
        scheduledExecutor = Executors
9
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
10
                 @Override
11
                 public Thread newThread(Runnable r) {
12
                     Thread t = new Thread(r);
13
                     t.setDaemon(true);
14
                     return t;
15
                 }});
16
    }
17

18
  void enable(Set<? extends WatchEvent.Kind<?>> events, long period) {
19
    synchronized (this) {
20
      // 更新监听事件
21
      this.events = events;
22

23
        // 开启定期轮询
24
      Runnable thunk = new Runnable() { public void run() { poll(); }};
25
      this.poller = scheduledExecutor
26
        .scheduleAtFixedRate(thunk, period, period, TimeUnit.SECONDS);
27
    }
28
  }
29
}

BIO、NIO 和 AIO 的区别？#

什么是语法糖？#

语法糖（Syntactic sugar） 代指的是编程语言为了方便程序员开发程序而设计的一种特殊语法，这种语法对编程语言的功能并没有影响。实现相同的功能，基于语法糖写出来的代码往往更简单简洁且更易阅读。

举个例子，Java 中的 for-each 就是一个常用的语法糖，其原理其实就是基于普通的 for 循环和迭代器。

1
String[] strs = {"JavaGuide", "公众号：JavaGuide", "博客：<https://javaguide.cn/>"};
2
for (String s : strs) {
3
    System.out.println(s);
4
}

不过，JVM 其实并不能识别语法糖，Java 语法糖要想被正确执行，需要先通过编译器进行解糖，也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明，Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

Java 中有哪些常见的语法糖？#

Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等。

JVM#

The Java Virtual Machine (JVM) is a virtual machine that runs Java bytecode. There are JVM implementations tailored for different systems (Windows, Linux, macOS) with the same bytecode producing the same results. Bytecode and the different system JVM implementations are the key to Java’s “write once, run anywhere.”

There isn’t just one JVM! As long as a JVM specification is met, any company, organization, or individual can develop their own JVM. That means the HotSpot VM we commonly encounter is just one implementation of the JVM specification.

Besides the HotSpot VM that we typically use, there are also other JVMs such as J9 VM, Zing VM, JRockit VM, etc. A common comparison of JVM implementations can be found on Wikipedia: Comparison of Java virtual machines

JDK and JRE#

JDK（Java Development Kit） is a full-featured Java SDK, a development kit for developers that enables creating and compiling Java programs. It includes the JRE, as well as the javac compiler for compiling Java source code and other tools such as javadoc (documentation tool), jdb (debugger), jconsole (JMX-based visual monitoring tool), javap (decompiler), etc.

JRE（Java Runtime Environment） is the Java Runtime Environment. It contains everything needed to run already-compiled Java programs, primarily the Java Virtual Machine (JVM) and the standard class library.

In short, JRE is Java’s runtime environment, containing runtime and essential libraries for Java applications. The JDK includes the JRE, plus tools like javac, javadoc, jdb, jconsole, javap, etc., for Java development and debugging. If you plan to do Java programming, you need the JDK. Some applications that use Java features (such as JSP compilation to Java Servlets, or reflective operations) may also require the JDK to compile and run Java code. Therefore, even if you don’t plan to develop Java applications, you might still need the JDK.

Starting with JDK 9, the distinction between JDK and JRE was removed in favor of a modular system (the JDK is organized into 94 modules) plus the jlink tool (a new command-line tool released with Java 9 to build a custom Java runtime image that contains only the modules your application needs). And since JDK 11, Oracle no longer provides a standalone JRE download.

What forms of comments exist?#

Java has three kinds of comments:

• Single-line comments: start with // and extend to end of line
• Multi-line comments: start with /* and end with */, content in between is a comment
• Documentation comments: start with /** and end with */, content in between is a comment, but documentation comments can be generated into formatted docs using the javadoc tool

The most commonly used are single-line and documentation comments; multi-line comments are used less in practice.

When we write code, if the codebase is small, we or other team members can understand it easily, but as the project structure grows complex, comments become necessary. Comments do not execute (the compiler removes them before compiling, and they are not kept in the bytecode); they are written for developers to read. Comments are your code’s instruction manual, helping readers quickly understand the relationships between parts of the code. Therefore, adding comments as you write is a very good habit.

Comments are not better the more detailed they are. In fact, good code is its own best documentation, so strive to write clean, readable code to minimize unnecessary comments. If the programming language is expressive enough, there is no need for many comments; let the code speak for itself.

What is the difference between identifiers and keywords?#

When writing programs, we need to name many things like programs, classes, variables, methods, etc., so we have identifiers. In short, an identifier is a name.

Some identifiers have special meaning in Java and can only be used in particular places. These special identifiers are keywords. In short, keywords are identifiers with special meaning.

What are the Java keywords?#

• Kind of keyword: access control private/protected/public
• Modifiers for classes, methods, and variables abstract/class/extends/final/implements/interface/native/new/static/strictfp/synchronized/transient/volatile/enum
• Program control break/continue/return/do/while/if/else/for/instanceof/switch/case/default/assert
• Error handling try/catch/throw/throws/finally
• Package related import/package
• Primitive types boolean/byte/char/double/float/int/long/short
• Reference-related super/this/void
• Reserved words goto/const

Tips: All keywords are lowercase; in IDEs they appear in special colors. default is a special keyword; it belongs to program control as well as class/method/field modifiers and access control.

• In program control, default can be used to specify the default case in a switch statement.
• In class, method, and field modifiers, from JDK 8 onward, default methods can be defined with the default keyword.
• In access control, if a method has no modifier, a default access modifier is implied, but if you add this modifier explicitly, it causes a compilation error.

Note: although true, false, and null look like keywords, they are literals, and you cannot use them as identifiers.

Official documentation

Increment and decrement operators#

When writing code, a common scenario is to increment or decrement a numeric variable by 1. Java provides a special operator for this expression: the increment (++) and decrement (—) operators. The ++ and — operators can be placed before the variable (prefix) or after the variable (postfix). When the operator is before the variable (prefix), the value is incremented/decremented first, then assigned; when the operator is after the variable (postfix), the value is assigned first, then incremented/decremented.

Shift operators#

Shift operators are among the most basic operators; almost every programming language includes this operator. In shift operations, the data being operated on is treated as binary, and shifting moves it left or right by a number of bits. Shift operators are widely used in various frameworks and in the source code of the JDK itself; for example, the hash method in HashMap (JDK 1.8) uses shift operators.

1
static final int hash(Object key) {
2
    int h;
3
    // key.hashCode(): returns the hash value
4
    // ^: bitwise XOR
5
    // >>>: unsigned right shift, ignores the sign bit, fill with 0s
6
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
7
  }

Java has three shift operators:

• <<: left shift operator, num << 1 is equivalent to num * 2

• : right shift operator, num >> 1 is equivalent to num / 2

• : unsigned right shift, ignore sign bit, fill with 0s

Using <<, >>, and >>> in Java code can yield more efficient instruction codes. It’s necessary to master the basic shift operators; it helps not only in using them in code but also in understanding code that involves shifting.

Because double and float have special representations in binary, you cannot perform shift operations on them. The shift operators actually support only int and long; before shifting, the compiler converts short, byte, and char to int.

What happens if the shift count exceeds the bit width? For int, if the shift amount is greater than or equal to 32, the count is taken modulo 32 before shifting. So shifting left/right by 32 bits is equivalent to no shift (32%32=0), shifting by 42 bits is equivalent to shifting by 10 bits (42%32=10). For long, the modulus base is 64.

What’s the difference between continue, break, and return?#

In loops, when the loop condition is not met or the iteration limit is reached, the loop ends normally. But sometimes you may want to terminate the loop early when a certain condition occurs, using these keywords:

1. continue: skip the current iteration and proceed to the next iteration
2. break: exit the entire loop body and continue with statements after the loop
3. return: exit the method containing this statement, ending the method’s execution
   • return; for void methods
   • return value; for methods with a return value

What’s the difference between primitive types and wrapper types?#

• Usage: Apart from declaring constants and local variables, we rarely define variables as primitive types in other placeslike method parameters and object properties. Also, wrapper types can be used in generics, while primitive types cannot.
• Storage: Local variables of primitive types reside in the JVM stack; member variables of primitive types (non-static) reside in the JVM heap. Wrapper types are object types, which mostly live on the heap.
• Space: Wrapper objects take more space than primitive types.
• Default values: For member variables, wrapper types default to null if not assigned; primitive types have default values and are not null.
• Comparison: For primitive types, == compares values. For wrapper types, == compares object references. All comparisons of values between wrapper objects should use equals().

Why do almost all object instances reside on the heap? Because after HotSpot introduces JIT optimizations, the VM may perform escape analysis to determine if an object escapes beyond the method; if not, scalar replacement may allocate it on the stack instead of on the heap.

Note: It is a common misconception that primitive types are stored on the stack. Their storage location depends on their scope and declaration. If they are local variables, they are on the stack; if they are member variables, they are on the heap.

Do you know about the wrapper type caching mechanism?#

Most of the Java primitive wrapper types use a caching mechanism to improve performance.

The wrappers Byte, Short, Integer, and Long cache values in the range [-128, 127] by default; Character caches values in [0, 127]; Boolean simply returns true or false.

If the value falls outside the cached range, new objects are created; the size of the cache range is a trade-off between performance and resources.

The wrappers for floating-point types Float and Double do not implement a caching mechanism.

Remember: all comparisons of values between integer wrapper objects should use equals().

Do you know autoboxing and unboxing? How does it work?#

What is autoboxing and unboxing?

• Boxing: wrap primitive types into their corresponding wrapper type
• Unboxing: convert wrapper types back to primitive types

1
Integer i = 10;  // boxing
2
int n = i;       // unboxing

From the bytecode perspective, boxing is implemented by calling the wrapper class’s valueOf(), and unboxing by calling xxxValue() methods. Thus,

• Integer i = 10 is equivalent to Integer i = Integer.valueOf(10)
• int n = i is equivalent to int n = i.intValue()

Note: Frequent boxing/unboxing can significantly affect performance. Try to avoid unnecessary boxing/unboxing operations.

1
BigDecimal a = new BigDecimal("1.0");
2
BigDecimal b = new BigDecimal("0.9");
3
BigDecimal c = new BigDecimal("0.8");
4

5
BigDecimal x = a.subtract(b);
6
BigDecimal y = b.subtract(c);
7

8
System.out.println(x); /* 0.1 */
9
System.out.println(y); /* 0.1 */
10
System.out.println(Objects.equals(x, y)); /* true */

1
long l = Long.MAX_VALUE;
2
System.out.println(l + 1); // -9223372036854775808
3
System.out.println(l + 1 == Long.MIN_VALUE); // true

Variables#

1
public class StaticVariableExample {
2
    // static variable
3
    public static int staticVar = 0;
4
}

1
public class StringExample {
2
    // Character constant
3
    public static final char LETTER_A = 'A';
4

5
    // String constant
6
    public static final String GREETING_MESSAGE = "Hello, world!";
7
    public static void main(String[] args) {
8
        System.out.println("The number of bytes for a char constant is: " + Character.BYTES);
9
        // 2
10
        System.out.println("The number of bytes for a string constant is: " + GREETING_MESSAGE.getBytes().length);
11
        // 13
12
    }
13
}

Methods#

1
public class Example {
2
    // Define a character constant
3
    public static final char LETTER_A = 'A';
4

5
    // Define a string constant
6
    public static final String GREETING_MESSAGE = "Hello, world!";
7

8
    public static void main(String[] args) {
9
        // Output the value of the character constant
10
        System.out.println("Character constant value: " + LETTER_A);
11

12
        // Output the value of the string constant
13
        System.out.println("String constant value: " + GREETING_MESSAGE);
14
    }
15
}

1
public class Person {
2
    public void method() {
3
      //......
4
    }
5

6
    public static void staicMethod(){
7
      //......
8
    }
9
    public static void main(String[] args) {
10
        Person person = new Person();
11
        // Call instance method
12
        person.method();
13
        // Call static method
14
        Person.staicMethod()
15
    }
16
}

1
public static void method1(String... args) {
2
//......}

1
public static void method2(String arg1, String... args) {
2
//......}

The difference between object-oriented and procedure-oriented programming#

The main difference lies in how problems are approached:

1. Procedural programming breaks the solution into a sequence of procedures and solves the problem by executing those procedures.
2. Object-oriented programming first abstracts objects, then solves problems by invoking methods on objects.

Additionally, object-oriented development generally leads to easier maintenance, reuse, and extension.

How do you create an object? What is the difference between an object instance and an object reference?#

using the new operator. The new operator creates an object instance (which lives on the heap), while an object reference points to the object instance (the reference itself lives on the stack).

• One object reference can point to zero or one object;
• An object can have many references pointing to it.

The difference between object equality and reference equality#

• Object equality generally compares whether the contents stored in memory are equal.
• Reference equality generally compares whether the memory addresses they point to are the same.

If a class does not declare a constructor, can the program still run correctly?#

A constructor is a special method that initializes objects.

If a class does not declare a constructor, the program can still run because every class automatically has a default no-argument constructor unless you explicitly add a constructor. If you do add a constructor (with or without parameters), Java will not create the default no-argument constructor.

What are the characteristics of constructors? Can they be overridden?#

Constructors have the following characteristics:

• They have the same name as the class.
• They have no return type (and you cannot declare a constructor with void).
• They execute automatically when an object is created.

Constructors cannot be overridden, but they can be overloaded, so you may see multiple constructors in a class.

The three core object-oriented concepts#

1. Encapsulation

   Encapsulation hides an object’s state information (i.e., its attributes) inside the object; external objects cannot directly access internal data. However, you can provide methods to operate on the attributes. If you don’t want external access to certain attributes, you simply don’t provide access methods. But if you don’t provide any access methods, the class has little use.

2. Inheritance

   Different types of objects often share common attributes and behaviors. Inheritance uses an existing class as the basis to build a new class. The new class can add new data or functionality, and it can also reuse the parent class’s features, without selectively inheriting from the parent. Inheritance enables rapid creation of new classes, improves code reuse, increases maintainability, and saves time.

   • Subclasses inherit all attributes and methods of the parent (including private ones) but private members are not accessible directly by the subclass.
   • Subclasses can have their own attributes and methods, i.e., they can extend the parent class.
   • Subclasses can implement the parent class’s methods in their own way (to be introduced later).

3. Polymorphism

   Polymorphism means an object can take on multiple forms; concretely, a parent class reference can point to a subclass instance.

   Features:

   • There is an inheritance/implementation relationship between the object’s type and its reference type;
   • The actual method invoked is determined at runtime;
   • Polymorphism cannot call methods that exist only in the subclass and not in the parent;
   • If a subclass overrides a parent method, the overridden method executes; if not, the parent’s method executes.

Interfaces and abstract classes: similarities and differences?#

Similarities:

• Neither can be instantiated.
• Both can contain abstract methods.
• Both can have default methods (Java 8 introduced default methods in interfaces).

Differences:

• Interfaces constrain the class’s behavior; implementing an interface confers the corresponding behavior. Abstract classes promote code reuse and emphasize “is-a” relationships.
• A class can inherit from only one class but can implement multiple interfaces.
• Members in interfaces must be public static final by default and must have initial values, while abstract class members are default (not private) and can be redefined or reassigned in subclasses.

Shallow copy vs deep copy? What is reference copy?#

• Shallow copy creates a new object on the heap, but if the original object contains references to other objects, the shallow copy shares those referenced objects.
• Deep copy entirely copies the original object, including any internal objects it contains.

What are common methods of the Object class?#

Object is the root class of all classes. It provides about 11 methods:

1
/**
2
 * native method, returns the Class object associated with this runtime object. It is declared final and cannot be overridden by subclasses.
3
 */
4
public final native Class<?> getClass()
5
/**
6
 * native method, returns the hash code of the object, mainly used in hash tables like HashMap.
7
 */
8
public native int hashCode()
9
/**
10
 * Used to compare memory addresses to determine if two objects are equal. The String class overrides this method to compare string values.
11
 */
12
public boolean equals(Object obj)
13
/**
14
 * native method, creates and returns a copy of the current object.
15
 */
16
protected native Object clone() throws CloneNotSupportedException
17
/**
18
 * Returns a string in hexadecimal form of the object's hash code. It is recommended that all subclasses override this.
19
 */
20
public String toString()
21
/**
22
 * native method and cannot be overridden. Wakes up a thread waiting on this object's monitor. If multiple threads are waiting, only one will be awakened.
23
 */
24
public final native void notify()
25
/**
26
 * native method and cannot be overridden. Wakes up all threads waiting on this object's monitor.
27
 */
28
public final native void notifyAll()
29
/**
30
 * native method, suspends the execution of the thread. Note: sleep does not release the lock, while wait releases the lock; timeout is the waiting time.
31
 */
32
public final native void wait(long timeout) throws InterruptedException
33
/**
34
 * With nanos parameter representing additional time in nanoseconds (range 0-999999), so the timeout must add nanos too.
35
 */
36
public final void wait(long timeout, int nanos) throws InterruptedException
37
/**
38
 * Similar to the previous two waits but this method waits indefinitely with no timeout.
39
 */
40
public final void wait() throws InterruptedException
41
/**
42
 * Operation triggered when the instance is garbage collected.
43
 */
44
protected void finalize() throws Throwable { }

The difference between == and equals()#

== behaves differently for primitive types and reference types:

• For primitive types, == compares values.
• For reference types, == compares memory addresses.

Because Java uses pass-by-value, for both primitive and reference variables, the essence of == is comparing values; in the case of reference types, the value is the object’s address.

equals() cannot be used to compare primitive type variables; it can only be used to compare objects. The equals() method is defined in the Object class, and since Object is the direct or indirect parent of all classes, all classes have an equals() method.

Object class equals() method:

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

equals() has two typical uses:

• If a class does not override equals(), comparing two objects of that class with equals() is equivalent to using == with the default behavior from Object’s equals().
• If a class overrides equals(), we typically compare the class’s fields to determine equality; if their fields are equal, return true.

When creating a String object, the JVM checks the constant pool to see if an existing object with the same value already exists; if so, it reuses that reference. If not, it creates a new String object in the pool.

What is hashCode() for?#

hashCode() returns a hash code (an int) and is used to determine an object’s index in a hash table.

hashCode() is defined in Object, so every class in Java has hashCode(). Note that Object’s hashCode() is a native method, implemented in C or C++.

Note: In Oracle OpenJDK 8 the default implementation uses thread-local state to implement Marsaglia’s xor-shift random number generation, not the address or a transformation of the address. There are several ways to generate hash codes across JDK/VM; you can enable a specific method by VM argument: -XX=4.

Hash tables store key-value pairs; they rely on hash codes to quickly locate values by key.

Why is hashCode needed?#

To explain why hashCode is needed, consider how HashSet checks for duplicates.

When you add an object to a HashSet, HashSet first computes the object’s hashCode to determine the insertion location, and then compares hashCode values with those of other objects already in the set. If there is no matching hashCode, HashSet assumes there is no duplicate. If there are objects with the same hashCode, equals() is used to check whether they are truly the same. If they are the same, the addition is not performed; if not, the object is rehashed to another location.

Thus, hashCode greatly reduces the number of times equals() needs to be invoked, improving performance.

In fact, hashCode() and equals() are both used to determine object equality.

Why does the JDK provide both?

Because in some containers (e.g., HashMap, HashSet), having hashCode() enables faster checks for membership. When collisions occur (same hashCode), equals() is used to confirm actual equality.

Why not provide only hashCode()?

Because two objects with the same hashCode are not necessarily equal (hash collisions).

Why can two objects have the same hashCode but not be equal?

Because the hash function may produce the same hash value for different objects. The worse the hash function, the more collisions; but collisions also depend on the data value distribution.

• If two objects have equal hashCode, they are not necessarily equal (hash collision).
• If two objects have equal hashCode and equals() returns true, they are equal.
• If two objects have different hashCode, they are not equal.

Differences between String, StringBuffer, and StringBuilder?#

• Mutability

  String is immutable (further analysis later).

  StringBuilder and StringBuffer both extend AbstractStringBuilder; AbstractStringBuilder stores strings in a char[] array and provides many methods such as append.

• Thread safety

  String objects are immutable and thread-safe. AbstractStringBuilder is the shared parent of StringBuilder and StringBuffer; StringBuffer adds synchronization, making it thread-safe; StringBuilder does not, so it is not thread-safe.

• Performance

  When modifying a String, a new String object is created each time. StringBuffer modifies the object itself; StringBuilder also modifies the object itself. In the same conditions, StringBuilder offers about 10%–15% better performance than StringBuffer, but with the risk of thread-unsafe behavior.

Summary:

• For a small amount of data, use String
• For large data in a single-threaded context, use StringBuilder
• For large data in a multi-threaded context, use StringBuffer

Why is String immutable?#

String stores its characters in a field declared with final, and the class is final to prevent subclassing; if the underlying storage is changed by a subclass, immutability could be broken.

1. The array storing the string is final and private; String does not expose a method to modify it.
2. The String class is final to prevent subclassing and thus avoid altering immutability.

From Java 9 onward, Strings, StringBuilder, and StringBuffer implementations use byte arrays.

Newer String implementations support two encodings: Latin-1 and UTF-16. If the string contains only characters representable in Latin-1, Latin-1 is used as the encoding. In Latin-1, a byte uses 8 bits, while a char uses 16 bits, so Latin-1 saves memory. If the string contains characters outside Latin-1, both byte and char storage are used.

Should you use “+” or StringBuilder for string concatenation?#

Java does not support operator overloading; the + and += operators are overloaded for String by the language. A String concatenation using + is compiled to use StringBuilder’s append() and then toString() to create the final String.

However, using + inside loops has a noticeable drawback: the compiler will not reuse a single StringBuilder, leading to many unnecessary StringBuilder objects being created.

This issue was addressed in JDK 9, where string concatenation with + is optimized: the compiler uses a dynamic method makeConcatWithConstants() to implement the concatenation rather than many StringBuilder instances.

What is the difference between String#equals() and Object#equals()?#

String’s equals() is overridden to compare the actual string values; Object’s equals() compares memory addresses.

Do you know about the String intern pool?#

The string intern pool is a JVM optimization to avoid duplicate String objects in memory. When you assign a string literal, the JVM checks the pool and reuses an existing instance if present; otherwise, it creates a new one.

1
// Create a String object "ab" in the heap
2
// The reference to "ab" is stored in the string intern pool
3
String aa = "ab";
4
// Retrieve the reference to the "ab" in the string intern pool
5
String bb = "ab";
6
System.out.println(aa==bb); // true

How many String objects are created by String s1 = new String(“abc”);?#

1 or 2 strings are created.

1. If the literal “abc” is not already in the string const pool, two strings will be created on the heap: one will be stored in the pool.
2. If the pool already contains “abc”, only one String object is created on the heap.

What does String#intern do?#

String.intern() is a native method whose purpose is to store the string in the string intern pool and to return a reference to the interned string. There are two main cases:

1. If the pool already contains a string equal to the one in question, return the reference from the pool.
2. If not, create and return a reference in the pool to the string.

1
// Create a string object "Java" on the heap
2
// Save a reference to the string "Java" in the intern pool
3
String s1 = "Java";
4
// Return the reference to "Java" from the intern pool
5
String s2 = s1.intern();
6
// Create another string object on the heap
7
String s3 = new String("Java");
8
// Return the reference to the interned pool
9
String s4 = s3.intern();
10
// s1 and s2 point to the same heap object
11
System.out.println(s1 == s2); // true
12
// s3 and s4 point to different heap objects
13
System.out.println(s3 == s4); // false
14
// s1 and s4 point to the same interned object
15
System.out.println(s1 == s4); // true

What happens when you concatenate String literals or variables with “+”?#

For compile-time constant strings, the compiler can fold constants at compile time and place them in the constant pool. Example: “str” + “ing” can be optimized to “string” by the compiler.

Not all constants are folded, only those whose values can be determined during compilation:

• Primitive types (byte, boolean, short, char, int, float, long, double) and string literals
• Final primitive types and final strings
• Strings formed by concatenating string literals or using arithmetic on primitives, and bitwise operations on primitive types

References’ values cannot be known at compile time, so cannot be optimized.

Concatenation of object references and strings via + is implemented by the compiler using StringBuilder’s append(), and then toString().

When a String is declared as final, the compiler can treat it as a constant, allowing the value to be known at compile time, effectively making it a constant.

If the compiler cannot know the exact value until runtime, it cannot optimize.

Java exception class hierarchy overview#

What’s the difference between Exception and Error?#

In Java, all exceptions derive from the Throwable class in the java.lang package. Throwable has two important subclasses:

• Exception: exceptions that the program can handle, can be caught with catch. Exception can be further divided into Checked Exceptions (must be handled) and Unchecked Exceptions (can be ignored).
• Error: errors that the program cannot handle; catching is not advised (e.g., VirtualMachineError, OutOfMemoryError, NoClassDefFoundError). When such errors occur, the JVM typically terminates the thread.

What’s the difference between Checked Exception and Unchecked Exception?#

Checked exceptions — in Java, during compilation, if the checked exception is not caught or declared with throws, the code will not compile.

Besides RuntimeException and its subclasses, all other Exception types are checked exceptions. Common checked exceptions include IO-related exceptions, ClassNotFoundException, SQLException, etc.

Unchecked exceptions — in Java, you can compile without handling unchecked exceptions (they are not required to be declared or caught).

RuntimeException and its subclasses are the non-checked exceptions, such as:

• NullPointerException
• IllegalArgumentException
• NumberFormatException
• ArrayIndexOutOfBoundsException
• ClassCastException
• ArithmeticException
• SecurityException
• UnsupportedOperationException

What common methods does Throwable provide?#

• String getMessage(): returns a brief description of the exception
• String toString(): returns detailed information about the exception
• String getLocalizedMessage(): returns a localized message for the exception. Subclasses can override to provide localization; if not overridden, returns the same as getMessage()
• void printStackTrace(): prints the exception’s stack trace

How to use try-catch-finally?#

• try block: used to catch exceptions. It can be followed by zero or more catch blocks; if there are no catch blocks, a finally block must follow.
• catch block: used to handle the exception captured by try.
• finally block: regardless of whether an exception was caught or handled, the statements in finally will be executed. If a return statement is encountered in the try or catch block, the finally block executes before the method returns.

Note: do not use return in finally! When both try and finally blocks contain return statements, the return in the try block is ignored. This is because the return value from the try block is temporarily stored in a local variable; when the finally block executes and returns, that local variable’s value becomes the finally block’s return value.

Do the statements in finally always execute?#

Not always. In some cases, the JVM may terminate before finally executes.

Additionally, finally may not execute in two exceptional cases:

• The thread running the program dies.
• The CPU is shut down.

How to use try-with-resources instead of try-catch-finally?#

1. Scope of resources: any object that implements java.lang.AutoCloseable or java.io.Closeable
2. The order of closing resources and execution of finally: in a try-with-resources statement, any catch or finally blocks run after the resources declared in the try-with-resources have been closed

In Java, resources such as InputStream, OutputStream, Scanner, PrintWriter, etc., typically require you to call close() manually, usually done with a try-catch-finally approach.

Of course, when multiple resources must be closed, try-with-resources is much simpler and avoids many problems that can arise with try-catch-finally.

You can declare multiple resources in a try-with-resources block by separating them with semicolons.

Things to watch out when using exceptions?#

• Do not declare exceptions as static variables, as this can corrupt exception stacks. Each time you throw an exception, you should create a new exception object.
• Exception messages should be meaningful.
• Prefer more specific exceptions; for example, NumberFormatException rather than the parent IllegalArgumentException when a string cannot be parsed as a number.
• After logging an exception, you should not rethrow it (avoid keeping both in one code path).

What are generics? What do they do?#

Java Generics were introduced in JDK 5 to improve code readability and safety. Use generic parameters to specify type constraints, which helps the compiler detect type errors.

For example, ArrayList persons = new ArrayList() indicates that this ArrayList can only contain Person objects; attempting to add other types would cause a compile-time error.

1
ArrayList<E> extends AbstractList<E>

Also, the raw List return type is Object and requires manual casting; with generics, the compiler handles casting automatically.

What are the ways to use generics?#

Generics are generally used in three ways: generic classes, generic interfaces, and generic methods.

1. Generic class

   1
   // T can be any identifier; commonly T, E, K, V, etc.
   2
   // When instantiating a generic class, you must specify T’s concrete type
   3
   public class Generic<T>{
   4
   
   5
       private T key;
   6
   
   7
       public Generic(T key) {
   8
           this.key = key;
   9
       }
   10
   
   11
       public T getKey(){
   12
           return key;
   13
       }
   14
   }

2. Generic interface

   1
   public interface Generator<T> {
   2
       public T next();
   3
   }

3. Generic method

   1
   public static < E > void printArray( E[] inputArray ) {
   2
        for ( E element : inputArray ){
   3
           System.out.printf( "%s ", element );
   4
        }
   5
        System.out.println();
   6
   }

Note: public static < E > void printArray( E[] inputArray ) is commonly called a static generic method; in Java, generics are placeholders and must be bound by a type argument before use. A class’s type parameters are not available to static methods since static members belong to the class, not to any instance. Therefore, static generic methods cannot use the class’s type parameters and must declare their own type parameter like .

Where are generics used in projects?#

• Define a general response type CommonResult whose T parameter lets you specify the response data type at the call site.
• Define Excel processing class ExcelUtil to dynamically specify the data type for Excel export.
• Build collection utility classes (e.g., involving sort or binarySearch in Collections).

What is reflection?#

If you’ve studied the framework internals or written frameworks yourself, you’ll be familiar with the concept of reflection. Reflection is the brain of many frameworks: it enables runtime analysis of classes and invocation of methods, allowing you to inspect a class’s fields and methods at runtime and to invoke them.

Pros and cons of reflection?#

Reflection makes code more flexible and simplifies supporting various frameworks. However, it can introduce security risks (e.g., bypassing generic type checks) and can have performance overhead.

Scenarios for reflection?#

Most of the time, typical application logic doesn’t directly use reflection, but many frameworks rely on reflection to function. Frameworks like Spring/Spring Boot and MyBatis heavily use reflection. Reflection is also used in dynamic proxies.

For example, here is a sample of dynamic proxy implemented with the JDK which calls a Method reflectively:

1
public class DebugInvocationHandler implements InvocationHandler {
2
    /**
3
     * The real object inside the proxy
4
     */
5
    private final Object target;
6

7
    public DebugInvocationHandler(Object target) {
8
        this.target = target;
9
    }
10

11
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
12
        System.out.println("before method " + method.getName());
13
        Object result = method.invoke(target, args);
14
        System.out.println("after method " + method.getName());
15
        return result;
16
    }
17
}

Additionally, reflection is used to implement annotations, a powerful mechanism in Java.

Why does Spring read a class as a Spring Bean with @Component? How does @Value read values from configuration? These are implemented using reflection to analyze classes and read annotations on classes, fields, methods, and method parameters, enabling further processing.

What are annotations?#

Annotation is a feature introduced in Java 5 that can be treated as a special type of comment and is used to annotate classes, methods, or variables to provide information to be used by the compiler or at runtime.

An annotation is a special interface that extends Annotation:

1
@Target(ElementType.METHOD)
2
@Retention(RetentionPolicy.SOURCE)
3
public @interface Override {
4

5
}
6

7
public interface Override extends Annotation{
8

9
}

JDK provides many built-in annotations (e.g., @Override, @Deprecated), and you can also define custom annotations.

What are the ways to parse annotations?#

Annotations only take effect after they are processed. Common processing approaches are twofold:

• Compile-time scanning: the compiler processes the annotations when compiling Java code (e.g., a method annotated with @Override is checked to ensure it actually overrides a method in the parent class).
• Runtime processing via reflection: frameworks like Spring’s @Value or @Component are processed via reflection.

What is SPI?#

SPI stands for Service Provider Interface: an interface that is meant to be implemented by service providers or extension frameworks.

SPI decouples the service interface from its concrete implementation, enabling the service caller and the service provider to be decoupled, increasing extensibility and maintainability. Changing or replacing the service implementation does not require changes to the caller.

Many frameworks use Java’s SPI mechanism, such as Spring, database drivers, logging interfaces, and Dubbo’s extension mechanism.

SPI and API differences?#

SPI and API both refer to interfaces, and it’s easy to confuse them.

Typically modules communicate through interfaces; we introduce an interface between the service caller and the provider (service provider). When the provider offers the interface and its implementation, callers can invoke the provider’s interface to obtain the provider’s capabilities. This is API: the interface and implementation are both provided by the provider.

When the interface exists on the caller’s side, it is SPI: the interface caller defines the interface rules, and different providers implement the interface to provide services.

SPI implementation—ServiceLoader#

Java’s SPI mechanism loads implementations by inspecting META-INF/services files in each jar. All files under the services directory are loaded into memory, and then the interface’s concrete implementations are discovered by the file contents. A reflection-based approach is used to create instances, and they are stored in a list for further use.

Thus, the SPI mechanism relies on reflection at its core. You declare the concrete implementations of a given interface in META-INF/services/ with the interface’s fully qualified name, and each line contains an implementation’s fully qualified name.

SPI is used in many frameworks as well: Spring’s core principles are similar; Dubbo provides an SPI extension mechanism with slightly different implementations, but the overall principle remains the same.

SPI pros and cons?#

SPI greatly enhances the flexibility of interface design, but it also has some drawbacks:

• It requires loading all implementations and cannot do on-demand loading, which can be less efficient.
• When multiple ServiceLoaders load simultaneously, there can be concurrency issues.

What is serialization? What is deserialization?#

Serialization is the process of converting data structures or objects into a binary byte stream for storage or network transmission. Deserialization is the reverse process, reconstructing data structures or objects from the byte stream.

In object-oriented languages like Java, we serialize objects (instances of classes). In C++, structs are data structures, while classes are object types.

Typical use cases:

• When an object is transmitted over the network (e.g., in RPC), it must be serialized; on the receiving end, it must be deserialized.
• When storing objects in a file, serialization is used; deserialization reads the file back into objects.
• When storing objects in a database (e.g., Redis), serialization is used; deserialization reads the cached data back.
• When storing objects in memory, serialization can be used and deserialization is used again when reading back.

The main purpose of serialization is to transfer objects over the network or to store them in files, databases, or memory.

Which layer of the TCP/IP four-layer model does a serialization protocol belong to?#

We know that network protocols have to align. The TCP/IP four-layer model is as follows, and serialization protocols belong to which layer?

As shown in the figure, in the OSI seven-layer model, the presentation and session layers are responsible for processing and converting application-layer data to a binary stream and vice versa. This corresponds to serialization and deserialization, respectively. Since the presentation layer is part of the application layer in the OSI model, the serialization protocol belongs to the application layer of the TCP/IP model.

What if some fields should not be serialized?#

For fields that you don’t want to serialize, use the transient keyword.

The transient keyword’s role is to prevent those fields marked with transient from being serialized; after deserialization, transient fields will revert to their default values.

Some notes about transient:

• transient can only be applied to variables, not to classes or methods.
• After deserialization, a transient field’s value is set to the type’s default value. For example, an int becomes 0.
• static variables don’t belong to any instance (Object), so whether or not they are marked transient, they are not serialized.

What are common serialization protocols?#

JDK’s built-in serialization is usually not used due to poor efficiency and security concerns. Common serialization protocols include Hessian, Kryo, Protobuf, ProtoStuff, which are binary-based. Text-like JSON and XML are easier to read but have poorer performance, so they are not typically chosen for serialization in performance-sensitive scenarios.

Why is JDK serialization not recommended?#

We rarely use JDK’s built-in serialization directly for several reasons:

• It doesn’t support cross-language calls: it cannot serialize/deserialize data to be consumed by services written in other languages.
• Performance is poor: the serialized payload is large, increasing transmission costs.
• Security concerns: serialization/deserialization itself is not problematic, but if user-controlled input influences what gets deserialized, attackers can craft malicious inputs to create unintended objects and execute code during deserialization.

Do you know Java I/O streams?#

I/O means Input/Output. Input is data entering memory; output is data leaving to external storage (database, file, remote host). Data transfer can be thought of as a flow of water; hence the term IO streams. In Java, IO streams are divided into input streams and output streams, and they are categorized as byte streams or character streams according to how data is processed.

Java’s IO streams are derived from four main abstract base classes:

• InputStream/Reader: base classes for all input streams; the former is a byte input stream, the latter is a character input stream.
• OutputStream/Writer: base classes for all output streams; the former is a byte output stream, the latter is a character output stream.

Why are I/O streams split into byte streams and character streams?#

The essential question is: since information is stored in bytes, why are there two categories for streams? The reasons are:

• Character streams are created from bytes by the JVM, a relatively costly operation.
• If you don’t know the encoding, using byte streams can lead to garbled text.

What design patterns exist in Java IO?#

1
class PollingWatchService
2
    extends AbstractWatchService
3
{
4
    // A daemon thread that polls for file changes
5
    private final ScheduledExecutorService scheduledExecutor;
6

7
    PollingWatchService() {
8
        scheduledExecutor = Executors
9
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
10
                 @Override
11
                 public Thread newThread(Runnable r) {
12
                     Thread t = new Thread(r);
13
                     t.setDaemon(true);
14
                     return t;
15
                 }});
16
    }
17

18
  void enable(Set<? extends WatchEvent.Kind<?>> events, long period) {
19
    synchronized (this) {
20
      // Update watch events
21
      this.events = events;
22

23
        // Start periodic polling
24
      Runnable thunk = new Runnable() { public void run() { poll(); }};
25
      this.poller = scheduledExecutor
26
        .scheduleAtFixedRate(thunk, period, period, TimeUnit.SECONDS);
27
    }
28
  }
29
}

What is syntactic sugar?#

Syntactic sugar refers to language constructs that make programming easier to read or express but do not introduce new functionality. In many cases, the same functionality can be achieved without sugar, but the sugar makes code cleaner and more readable.

For example, the for-each loop in Java is a common syntactic sugar that is implemented based on a regular for loop and an iterator.

1
String[] strs = {"JavaGuide", "公众号：JavaGuide", "博客：<https://javaguide.cn/>"};
2
for (String s : strs) {
3
    System.out.println(s);
4
}

However, the JVM itself does not understand syntactic sugar directly. Java’s syntax sugar must be desugared by the compiler — i.e., converted into the basic syntax that the JVM recognizes during compilation. This also shows that the Java compiler (not the JVM) is what supports syntactic sugar. If you look at the source of com.sun.tools.javac.main.JavaCompiler, you’ll see a desugar() step in the compile() method, which is responsible for desugaring.

What are common syntactic sugars in Java?#

The most common syntactic sugars in Java include generics, autoboxing/unboxing, varargs, enums, inner classes, enhanced for loops, try-with-resources, and lambda expressions.

JVM#

Java 仮想機（JVM）は Java バイトコードを実行する仮想機です。JVM には Windows、Linux、macOS などの各システム向けの特定実装があり、同じバイトコードを用いて同じ結果を得られることを目的としています。バイトコードと異なるシステムの JVM 実装が、Java 言語の「一度書けばどこでも実行」というキーとなる点です。

JVM は1つではありません！JVM 規格を満たしていれば、各社・組織・個人が自分たちの専用 JVM を開発できます。つまり普段触れている HotSpot VM は JVM 規格の1つの実装に過ぎません。

HotSpot VM のほかにも J9 VM、Zing VM、JRockit VM などの JVM があります。Wikipedia には一般的な JVM の比較が掲載されています：Comparison of Java virtual machines

JDKとJRE#

JDK（Java Development Kit）は、機能が揃った Java の SDK で、開発者向けの開発キット。JRE を含み、さらに java のソースコードをコンパイルするコンパイラ javac やその他のツール（例えば javadoc、jdb、jconsole、javap など）を含む。

JRE（Java Runtime Environment）は Java の実行時環境。既にコンパイル済みの Java プログラムを動作させるのに必要なすべてを含む集合で、主に Java 仮想機械（JVM）と Java 標準ライブラリを含む。

要するに、JRE は Java の実行時環境のみで、アプリケーションの実行と必要なライブラリを含む。一方 JDK は JRE を含みつつ、javac などの開発ツールを含むため、Java アプリケーションの開発とデバッグに使用される。Java のプログラミング作業（プログラムの作成・コンパイル、Java API ドキュメントの利用など）を行うには JDK が必要です。また、JSP の変換、反射など Java の機能を活用するアプリケーションには JDK の利用が必須となる場合があるため、Java アプリ開発を行う予定がなくても JDK の導入が必要になることがあります。

ただし、JDK 9 以降は JDK と JRE の区別は不要となり、モジュールシステム（JDK は 94 個のモジュールに再編成）と jlink（Java 9 と同時にリリースされた新しいコマンドラインツールで、特定アプリケーションに必要なモジュールだけを含むカスタム Java 実行イメージを生成）という形へ移行しました。さらに JDK 11 以降は Oracle は単独の JRE ダウンロードを提供していません。