java基础整理及常见面试

1、Java 程序是如何执行的
Java 介绍
Java 诞生于 1991 年，Java 的前身叫做 Oak（橡树），但在注册商标的时候，发现这个名字已经被人注册了，后来团队的人就在咖啡馆讨论这件事该怎么办，有人灵机一动说叫 Java 如何，因为当时他们正在喝着一款叫做 Java 的咖啡。就这样，这个后来家喻户晓的名字，竟以这种“随意”的方式诞生了，并一直沿用至今。

Java 发展历程：

1990，Sun 成立了“Green Team”项目小组
1991，Java 语言前身 Oak（橡树）诞生
1995，Oak 语言更名为 Java
1996，Java 1.0 发布
1997，Java 1.1 发布
1998，Java 1.2 发布
2000，Java 1.3 发布
2000，Java 1.4 发布
2004，Java 5 发布
2006，Java 6 发布
2011，Java 7 发布
2014，Java 8 发布
2017，Java 9（非长期支持版）发布
2018.03，Java 10（非长期支持版） 发布
2018.09，Java 11（长期支持版）发布
2019.03, Java 12（非长期支持版） 发布
注：长期支持版指的是官方发布版本后的一段时间内，通常以“年”为计数单位，会对此版本进行持续维护和升级。

版本发布时间

Java 10 之后，官方表示每半年推出一个大版本，长期支持版本（LTS）每三年发布一次。

Java 和 JDK 的关系
JDK（Java Development Kit）Java 开发工具包，它包括：编译器、Java 运行环境（JRE，Java Runtime Environment）、JVM（Java 虚拟机）监控和诊断工具等，而 Java 则表示一种开发语言。

Java 程序是怎么执行的？
我们日常的工作中都使用开发工具（IntelliJ IDEA 或 Eclipse 等）可以很方便的调试程序，或者是通过打包工具把项目打包成 jar 包或者 war 包，放入 Tomcat 等 Web 容器中就可以正常运行了，但你有没有想过 Java 程序内部是如何执行的？

其实不论是在开发工具中运行还是在 Tomcat 中运行，Java 程序的执行流程基本都是相同的，它的执行流程如下：

先把 Java 代码编译成字节码，也就是把 .java 类型的文件编译成 .class 类型的文件。这个过程的大致执行流程：Java 源代码 -> 词法分析器 -> 语法分析器 -> 语义分析器 -> 字节码生成器 -> 最终生成字节码，其中任何一个节点执行失败就会造成编译失败；
把 class 文件放置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官方自带的 Hotspot JVM；
Java 虚拟机使用类加载器（Class Loader）装载 class 文件；
类加载完成之后，会进行字节码校验，字节码校验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。但不是所有代码都是解释执行的，JVM 对此做了优化，比如，以 Hotspot 虚拟机来说，它本身提供了 JIT（Just In Time）也就是我们通常所说的动态编译器，它能够在运行时将热点代码编译为机器码，这个时候字节码就变成了编译执行。
Java 程序执行流程图如下：

avatar

Java 虚拟机是如何判定热点代码的？
Java 虚拟机判定热点代码的方式有两种：

基于采样的热点判定
主要是虚拟机会周期性的检查各个线程的栈顶，若某个或某些方法经常出现在栈顶，那这个方法就是“热点方法”。这种判定方式的优点是实现简单；缺点是很难精确一个方法的热度，容易受到线程阻塞或外界因素的影响。

基于计数器的热点判定
主要就是虚拟机给每一个方法甚至代码块建立了一个计数器，统计方法的执行次数，超过一定的阀值则标记为此方法为热点方法。

Hotspot 虚拟机使用的基于计数器的热点探测方法。它使用了两类计数器：方法调用计数器和回边计数器，当到达一定的阀值是就会触发 JIT 编译。

方法调用计数器：在 client 模式下的阀值是 1500 次，Server 是 10000 次，可以通过虚拟机参数： -XX:CompileThreshold=N 对其进行设置。但是JVM还存在热度衰减，时间段内调用方法的次数较少，计数器就减小。

回边计数器：主要统计的是方法中循环体代码执行的次数。

由上面的知识我们可以看出，要想做到对 Java 了如指掌，必须要好好学习 Java 虚拟机，那除了 Java 虚拟机外，还有哪些知识是面试必考，也是 Java 工程师必须掌握的知识呢？

1. Java 基础中的核心内容
   字符串和字符串常量池的深入理解、Array 的操作和排序算法、深克隆和浅克隆、各种 IO 操作、反射和动态代理（JDK 自身动态代理和 CGLIB）等。

2. 集合
   集合和 String 是编程中最常用的数据类型，关于集合的知识也是面试备考的内容，它包含：链表（LinkedList）、TreeSet、栈（Stack）、队列（双端、阻塞、非阻塞队列、延迟队列）、HashMap、TreeMap 等，它们的使用和底层存储数据结构都是热门的面试内容。

3. 多线程
   多线程使用和线程安全的知识也是必考的面试题目，它包括：死锁、6 种线程池的使用与差异、ThreadLocal、synchronized、Lock、JUC（java.util.concurrent包）、CAS（Compare and Swap）、ABA 问题等。

4. 热门框架
   Spring、Spring MVC、MyBatis、SpringBoot

5. 分布式编程
   消息队列（RabbitMQ、Kafka）、Dubbo、Zookeeper、SpringCloud 等。

6. 数据库
   MySQL 常用引擎的掌握、MySQL 前缀索引、回表查询、数据存储结构、最左匹配原则、MySQL 的问题分析和排除方案、MySQL 读写分离的实现原理以及 MySQL 的常见优化方案等。 Redis 的使用场景、缓存雪崩和缓存穿透的解决方案、Redis 过期淘汰策略和主从复制的实现方案等。

7. Java 虚拟机
   虚拟机的组成、垃圾回收算法、各种垃圾回收器的区别、Java 虚拟机分析工具的掌握、垃圾回收器的常用调优参数等。

8. 其他
   常用算法的掌握、设计模式的理解、网络知识和常见 Linux 命令的掌握等。

值得庆幸的是以上所有内容都包含在本专栏中，接下来就让我们一起学习，一起构建 Java 的认知体系吧!

相关面试题

1. Java 语言都有哪些特点？
   答：Java 语言包含以下特点。

面向对象，程序容易理解、开发简单、方便；
跨平台，可运行在不同服务器类型上，比如：Linux、Windows、Mac 等；
执行性能好，运行效率高；
提供大量的 API 扩展，语言强大；
有多线程支持，增加了响应和实时交互的能力；
安全性好，自带验证机制，确保程序的可靠性和安全性。
2. Java 跨平台实现的原理是什么？
答：要了解 Java 跨平台实现原理之前，必须先要了解 Java 的执行过程，Java 的执行过程如下：

执行过程

Java 执行流程：Java 源代码（.java）-> 编译 -> Java 字节码（.class） ->通过 JVM（Java 虚拟机）运行 Java 程序。每种类型的服务器都会运行一个 JVM，Java 程序只需要生成 JVM 可以执行的代码即可，JVM 底层屏蔽了不同服务器类型之间的差异，从而可以在不同类型的服务器上运行一套 Java 程序。

3. JDK、JRE、JVM 有哪些区别？
   答：了解了 JDK、JRE、JVM 的定义也就明白了它们之间的区别，如下所述。

JDK：Java Development Kit（Java 开发工具包）的简称，提供了 Java 的开发环境和运行环境；
JRE：Java Runtime Environment（Java 运行环境）的简称，为 Java 的运行提供了所需环境；
JVM：Java Virtual Machine（Java虚拟机）的简称，是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的，简单来说就是所有的 Java 程序都是运行在 JVM（Java 虚拟机）上的。
总体来说，JDK 提供了一整套的 Java 运行和开发环境，通常使用对象为 Java 的开发者，当然 JDK 也包含了 JRE；而 JRE 为 Java 运行的最小运行单元，一般安装在 Java 服务器上，所以 JDK 和 JRE 可以从用途上进行理解和区分。JVM 不同于 JDK 和 JRE，JVM 是 Java 程序运行的载体，Java 程序只有通过 JVM 才能正常的运行。

4. Java 中如何获取明天此刻的时间？
   答：JDK 8 之前使用 Calendar.add() 方法获取，代码如下：

Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, 1);
System.out.println(calendar.getTime());
JDK 8 有两种获取明天时间的方法。

方法一，使用 LocalDateTime.plusDays() 方法获取，代码如下：

LocalDateTime today = LocalDateTime.now();
LocalDateTime tomorrow = today.plusDays(1);
System.out.println(tomorrow);
方法二，使用 LocalDateTime.minusDays() 方法获取，代码如下：

LocalDateTime today = LocalDateTime.now();
LocalDateTime tomorrow = today.minusDays(-1);
System.out.println(tomorrow);
minusDays() 方法为当前时间减去 n 天，传负值就相当于当前时间加 n 天。

5. Java 中如何跳出多重嵌套循环？
   答：Java 中跳出多重嵌套循环的两种方式。

方法一：定义一个标号，使用 break 加标号的方式
方法二：使用全局变量终止循环
方法一，示例代码：

myfor:for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
System.out.println(“J:” + j);
if (j == 10) {
// 跳出多重循环
break myfor;
}
}
}
方法二，示例代码：

boolean flag = true;
for (int i = 0; i < 100 && flag; i++) {
for (int j = 0; j < 100; j++) {
System.out.println(“J:” + j);
if (j == 10) {
// 跳出多重循环
flag = false;
break;
}
}
}
6. char 变量能不能存贮一个中文汉字？为什么？
答：char 变量可以存贮一个汉字，因为 Java 中使用的默认编码是 Unicode ，一个 char 类型占 2 个字节（16 bit），所以放一个中文是没问题的。

7. Java 中会存在内存泄漏吗？请简单描述一下。
   答：一个不再被程序使用的对象或变量一直被占据在内存中就造成了内存泄漏。

Java 中的内存泄漏的常见情景如下：

长生命周期对象持有短生命的引用，比如，缓存系统，我们加载了一个对象放在缓存中，然后一直不使用这个缓存，由于缓存的对象一直被缓存引用得不到释放，就造成了内存泄漏；
各种连接未调用关闭方法，比如，数据库 Connection 连接，未显性地关闭，就会造成内存泄漏；
内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露；
改变哈希值，当一个对象被存储进 HashSet 集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则对象修改后的哈希值与最初存储进 HashSet 集合中时的哈希值就不同了，在这种情况下，即使在 contains 方法使用该对象的当前引用作为的参数去 HashSet 集合中检索对象，也将返回找不到对象的结果，这也会导致无法从 HashSet 集合中单独删除当前对象，造成内存泄露。

2、你不知道的基本数据类型和包装类 + 面试题
基本数据类型
Java 基本数据按类型可以分为四大类：布尔型、整数型、浮点型、字符型，这四大类包含 8 种基本数据类型。

布尔型：boolean
整数型：byte、short、int、long
浮点型：float、double
字符型：char
8 种基本类型取值如下：

数据类型 代表含义 默认值 取值 包装类
boolean 布尔型 false 0(false) 到 1(true) Boolean
byte 字节型 (byte)0 ﹣128 到 127 Byte
char 字符型 ‘\u0000’(空) ‘\u0000’ 到 ‘\uFFFF’ Character
short 短整数型 (short)0 -
2
15
到
2
15
﹣1 Short
int 整数型 0 ﹣
2
31
到
2
31
﹣1 Integer
long 长整数型 0L ﹣
2
63
到
2
63
﹣1 Long
float 单浮点型 0.0f 1.4e-45 到 3.4e+38 Float
double 双浮点型 0.0d 4.9e-324 到 1.798e+308 Double
除 char 的包装类 Character 和 int 的包装类 Integer 之外，其他基本数据类型的包装类只需要首字母大写即可。包装类的作用和特点，本文下半部分详细讲解。

我们可以在代码中，查看某种类型的取值范围，代码如下：

public static void main(String[] args) {
// Byte 取值：-128 ~ 127
System.out.println(String.format(“Byte 取值：%d ~ %d”, Byte.MIN_VALUE, Byte.MAX_VALUE));
// Int 取值：-2147483648 ~ 2147483647
System.out.println(String.format(“Int 取值：%d ~ %d”, Integer.MIN_VALUE, Integer.MAX_VALUE));
}
包装类型
我们知道 8 种基本数据类型都有其对应的包装类，因为 Java 的设计思想是万物既对象，有很多时候我们需要以对象的形式操作某项功能，比如说获取哈希值（hashCode）或获取类（getClass）等。

那包装类特性有哪些？

1. 功能丰富

包装类本质上是一个对象，对象就包含有属性和方法，比如 hashCode、getClass 、max、min 等。

2. 可定义泛型类型参数

包装类可以定义泛型，而基本类型不行。

比如使用 Integer 定义泛型，代码：

List list = new ArrayList<>();
如果使用 int 定义就会报错，代码：

List list = new ArrayList<>(); // 编译器代码报错
3. 序列化

因为包装类都实现了 Serializable 接口，所以包装类天然支持序列化和反序列化。比如 Integer 的类图如下：

Integer 类图

4. 类型转换

包装类提供了类型转换的方法，可以很方便的实现类型之间的转换，比如 Integer 类型转换代码：

String age = “18”;
int ageInt = Integer.parseInt(age) + 2;
// 输出结果：20
System.out.println(ageInt);
5. 高频区间的数据缓存

此特性为包装类很重要的用途之一，用于高频区间的数据缓存，以 Integer 为例来说，在数值区间为 -128~127 时，会直接复用已有对象，在这区间之外的数字才会在堆上产生。

我们使用 == 对 Integer 进行验证，代码如下：

public static void main(String[] args) {
// Integer 高频区缓存范围 -128~127
Integer num1 = 127;
Integer num2 = 127;
// Integer 取值 127 == 结果为 true（值127 num1num2 => true）
System.out.println("值127 num1num2 => " + (num1 == num2));
Integer num3 = 128;
Integer num4 = 128;
// Integer 取值 128 == 结果为 false（值128 num3num4 => false）
System.out.println("值128 num3num4 => " + (num3 == num4));
}
从上面的代码很明显可以看出，Integer 为 127 时复用了已有对象，当值为 128 时，重新在堆上生成了新对象。

为什么会产生高频区域数据缓存？我们查看源码就能发现“线索”，源码版本 JDK8，源码如下：

public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
由此可见，高频区域的数值会直接使用已有对象，非高频区域的数值会重新 new 一个新的对象。

各包装类高频区域的取值范围：

Boolean：使用静态 final 定义，就会返回静态值
Byte：缓存区 -128~127
Short：缓存区 -128~127
Character：缓存区 0~127
Long：缓存区 -128~127
Integer：缓存区 -128~127
包装类的注意事项
int 的默认值是 0，而 Integer 的默认值是 null。

推荐所有包装类对象之间的值比较使用 equals() 方法，因为包装类的非高频区数据会在堆上产生，而高频区又会复用已有对象，这样会导致同样的代码，因为取值的不同，而产生两种截然不同的结果。代码示例：

public static void main(String[] args) {
// Integer 高频区缓存范围 -128~127
Integer num1 = 127;
Integer num2 = 127;
// Integer 取值 127 == 结果为 true（值127 num1num2 => true）
System.out.println("值127 num1num2 => " + (num1 == num2));
Integer num3 = 128;
Integer num4 = 128;
// Integer 取值 128 == 结果为 false（值128 num3num4 => false）
System.out.println("值128 num3num4 => " + (num3 == num4));
// Integer 取值 128 equals 结果为 true（值128 num3.equals(num4) => true）
System.out.println("值128 num3.equals(num4) => " + num3.equals(num4));
}
Float 和 Double 不会有缓存，其他包装类都有缓存。

Integer 是唯一一个可以修改缓存范围的包装类，在 VM optons 加入参数：

-XX:AutoBoxCacheMax=666 即修改缓存最大值为 666 。

示例代码如下：

public static void main(String[] args) {
Integer num1 = -128;
Integer num2 = -128;
System.out.println("值为-128 => " + (num1 == num2));
Integer num3 = 666;
Integer num4 = 666;
System.out.println("值为666 => " + (num3 == num4));
Integer num5 = 667;
Integer num6 = 667;
System.out.println("值为667 => " + (num5 == num6));
}
执行结果如下：

值为-128 => true
值为666 => true
值为667 => false
由此可见将 Integer 最大缓存修改为 666 之后，667 不会被缓存，而 -128~666 之间的数都被缓存了。

相关面试题

1. 以下 Integer 代码输出的结果是？
   Integer age = 10;
   Integer age2 = 10;
   Integer age3 = 133;
   Integer age4 = 133;
   System.out.println((age == age2) + “,” + (age3 == age4));
   答：true,false

2. 以下 Double 代码输出的结果是？
   Double num = 10d;
   Double num2 = 10d;
   Double num3 = 133d;
   Double num4 = 133d;
   System.out.println((num == num2) + “,” + (num3 == num4));
   答：false,false

3. 以下程序输出结果是？
   int i = 100;
   Integer j = new Integer(100);
   System.out.println(i == j);
   System.out.println(j.equals(i));
   A：true,true
   B：true,false
   C：false,true
   D：false,false

答：A

题目分析：有人认为这和 Integer 高速缓存有关系，但你发现把值改为 10000 结果也是 true,true，这是因为 Integer 和 int 比较时，会自动拆箱为 int 相当于两个 int 比较，值一定是 true,true。

4. 以下程序执行的结果是？
   final int iMax = Integer.MAX_VALUE;
   System.out.println(iMax + 1);
   A：2147483648
   B：-2147483648
   C：程序报错
   D：以上都不是

答：B

题目解析：这是因为整数在内存中使用的是补码的形式表示，最高位是符号位 0 表示正数，1 表示负数，当执行 +1 时，最高位就变成了 1，结果就成了 -2147483648。

5. 以下程序执行的结果是？
   Set set = new HashSet<>();
   for (short i = 0; i < 5; i++) {
   set.add(i);
   set.remove(i - 1);
   }
   System.out.println(set.size());
   A：1
   B：0
   C：5
   D：以上都不是

答：5

题目解析：Short 类型 -1 之后转换成了 Int 类型，remove() 的时候在集合中找不到 Int 类型的数据，所以就没有删除任何元素，执行的结果就是 5。

6. short s=2;s=s+1; 会报错吗？short s=2;s+=1; 会报错吗？
   答：s=s+1 会报错，s+=1 不会报错，因为 s=s+1 会导致 short 类型升级为 int 类型，所以会报错，而 s+=1 还是原来的 short 类型，所以不会报错。

7. float f=3.4; 会报错吗？为什么？
   答：会报错，因为值 3.4 是 double 类型，float 类型级别小于 double 类型，所以会报错。如下图所示：

报错示例图

8. 为什么需要包装类？
   答：需要包装类的原因有两个。

① Java 的设计思想是万物既对象，包装类体现了面向对象的设计理念；
② 包装类包含了很多属性和方法，比基本数据类型功能多，比如提供的获取哈希值（hashCode）或获取类（getClass）的方法等。

9. 基本类 int 和包装类 Integer，在 -128~127 之间都会复用已有的缓存对象，这种说法正确吗？
   答：不正确，只有包装类高频区域数据才有缓存。

10. 包装类 Double 和 Integer 一样都有高频区域数据缓存，这种说法正确吗？
    答：不正确，基本数据类型的包装类只有 Double 和 Float 没有高频区域的缓存。

11. 包装类的值比较要使用什么方法？
    答：包装类因为有高频区域数据缓存，所以推荐使用 equals() 方法进行值比较。

12. 包装类有哪些功能？
    答：包装类提供的功能有以下几个。

功能丰富：包装类包含了有 hashCode、getClass 、max、min 等方法；
可定义泛型类型参数：例如 List list = new ArrayList<>(); ;
序列化：包装类实现了 Serializable 接口，所以包装类天然支持序列化和反序列化；
类型转换：包装类提供了方便的类型转换方法，比如 Integer 的 parseInt() 方法；
高频区域数据缓存：高频区域可使用已有的缓存对象。
详见正文“包装类型”部分内容。

13. 泛型可以为基本类型吗？为什么？
    答：泛型不能使用基本数据类型。泛型在 JVM（Java虚拟机）编译的时候会类型檫除，比如代码 List list 在 JVM 编译的时候会转换为 List list ，因为泛型是在 JDK 5 时提供的，而 JVM 的类型檫除是为了兼容以前代码的一个折中方案，类型檫除之后就变成了 Object，而 Object 不能存储基本数据类型，但可以使用基本数据类型对应的包装类，所以像 List list 这样的代码是不被允许的，编译器阶段会检查报错，而 List list 是被允许的。

14. 选择包装类还是基本类的原则有哪些？
    答：我们知道正确的使用包装类，可以提供程序的执行效率，可以使用已有的缓存，一般情况下选择基本数据类型还是包装类原则有以下几个。

① 所有 POJO 类属性必须使用包装类；
② RPC 方法返回值和参数必须使用包装类；
③ 所有局部变量推荐使用基本数据类型。

15. 基本数据类型在 JVM 中一定存储在栈中吗？为什么？
    答：基本数据类型不一定存储在栈中，因为基本类型的存储位置取决于声明的作用域，来看具体的解释。

当基本数据类型为局部变量的时候，比如在方法中声明的变量，则存放在方法栈中的，当方法结束系统会释放方法栈，在该方法中的变量也会随着栈的销毁而结束，这也是局部变量只能在方法中使用的原因；
当基本数据类型为全局变量的时候，比如类中的声明的变量，则存储在堆上，因为全局变量不会随着某个方法的执行结束而销毁。
16. 以下程序执行的结果是？
Integer i1 = new Integer(10);
Integer i2 = new Integer(10);
Integer i3 = Integer.valueOf(10);
Integer i4 = Integer.valueOf(10);
System.out.println(i1 == i2);
System.out.println(i2 == i3);
System.out.println(i3 == i4);
A：false,false,false
B：false,false,true
C：false,true,true
D：true,false,false

答：B

题目解析：new Integer(10) 每次都会创建一个新对象，Integer.valueOf(10) 则会使用缓存池中的对象。

17. 3*0.1==0.3 返回值是多少？
    答：返回值为：false。

题目解析：因为有些浮点数不能完全精确的表示出来，如下代码：

System.out.println(3 * 0.1);

返回的结果是：0.30000000000000004

3、深入理解字符串 + 面试题
字符串介绍
字符串是程序开发当中，使用最频繁的类型之一，有着与基础类型相同的地位，甚至在 JVM（Java 虚拟机）编译的时候会对字符串做特殊的处理，比如拼加操作可能会被 JVM 直接合成为一个最终的字符串，从而到达高效运行的目的。

1 String 特性
String 是标准的不可变类（immutable），对它的任何改动，其实就是创建了一个新对象，再把引用指向该对象；
String 对象赋值之后就会在常量池中缓存，如果下次创建会判定常量池是否已经有缓存对象，如果有的话直接返回该引用给创建者。
2 字符串创建
字符串创建的两种方式：

String str = “laowang”;
String str = new String(“laowang”);
3 注意事项
查看下面代码：

String s1 = “laowang”;
String s2 = s1;
String s3 = new String(s1);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
输出结果：true、false。

为什么会这样？原因是 s3 使用 new String 时一定会在堆中重新创建一个内存区域，而 s2 则会直接使用了 s1 的引用，所以得到的结果也完全不同。

字符串的使用
1 字符串拼加
字符串拼加的几种方式：

String str = “lao” + “wang”;
String str = “lao”; str += “wang”;
String str = “lao”; String str2 = str + “wang”;
2 JVM 对字符串的优化
根据前面的知识我们知道，对于 String 的任何操作其实是创建了一个新对象，然后再把引用地址返回该对象，但 JVM 也会对 String 进行特殊处理，以此来提供程序的运行效率，比如以下代码：

String str = “hi,” + “lao” + “wang”;
经过 JVM 优化后的代码是这样的：

String str = “hi,laowang”;
验证代码如下：

String str = “hi,” + “lao” + “wang”;
String str2 = “hi,laowang”;
System.out.println(str == str2);
执行的结果：true。

这就说明 JVM 在某些情况下会特殊处理 String 类型。

3 字符串截取
字符串的截取使用 substring() 方法，使用如下：

String str = “abcdef”;
// 结果：cdef（从下标为2的开始截取到最后，包含开始下标）
System.out.println(str.substring(2));
// 结果：cd（从下标为2的开始截取到下标为4的，包含开始下标不包含结束下标）
System.out.println(str.substring(2,4));
4 字符串格式化
字符串格式化可以让代码更简洁更直观，比如，“我叫老王，今年 30 岁，喜欢读书”在这条信息中：姓名、年龄、兴趣都是要动态改变的，如果使用“+”号拼接的话很容易出错，这个时候字符串格式化方法 String.format() 就派上用场了，代码如下：

String str = String.format(“我叫%s，今年%d岁，喜欢%s”, “老王”, 30, “读书”);
转换符说明列表：

转换符 说明
%s 字符串类型
%d 整数类型（十进制）
%c 字符类型
%b 布尔类型
%x 整数类型（十六进制）
%o 整数类型（八进制）
%f 浮点类型
%a 浮点类型（十六进制）
%e 指数类型
%% 百分比类型
%n 换行符
5 字符对比
根据前面的知识我们知道，使用 String 和 new String 声明的对象是不同的，那有没有简单的方法，可以忽略它们的创建方式（有没有 new）而只对比它们的值是否相同呢？答案是肯定的，使用 equals() 方法可以实现，代码如下：

String s1 = “hi,” + “lao” + “wang”;
String s2 = “hi,”;
s2 += “lao”;
s2 += “wang”;
String s3 = “hi,laowang”;
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // true
System.out.println(s2.equals(s3)); // true
以上使用 equals 对比的结果都为 true。

如果要忽略字符串的大小写对比值可以使用 equalsIgnoreCase()，代码示例：

String s1 = “Hi,laowang”;
String s2 = “hi,laowang”;
System.out.println(s1.equals(s2)); // false
System.out.println(s1.equalsIgnoreCase(s2)); // true
s1.equals(s2) 执行的结果为：false，s1.equalsIgnoreCase(s2) 执行的结果为：true。

6 String、StringBuffer、StringBuilder
字符串相关类型主要有这三种：String、StringBuffer、StringBuilder，其中 StringBuffer、StringBuilder 都是可以变的字符串类型，StringBuffer 在字符串拼接时使用 synchronized 来保障线程安全，因此在多线程字符串拼接中推荐使用 StringBuffer。

StringBuffer 使用：

StringBuffer sf = new StringBuffer(“lao”);
// 添加字符串到尾部
sf.append(“wang”); // 执行结果：laowang
// 插入字符串到到当前字符串下标的位置
sf.insert(0,“hi,”); // 执行结果：hi,laowang
// 修改字符中某个下标的值
sf.setCharAt(0,‘H’); // 执行结果：Hi,laowang
StringBuilder 的使用方法和 StringBuffer 一样，它们都继承于 AbstractStringBuilder。

相关面试题

1. String 属于基础数据类型吗？
   答：String 不是基础数据类型，它是从堆上分配来的。基础数据类型有 8 个，分别为：boolean、byte、short、int、long、float、double、char。

2. 以下可以正确获取字符串长度的是？
   A：str.length
   B：str.size
   C：str.length()
   D：str.size()

答：C

题目解析：字符串没有 length 属性，只有 length() 方法。

3. “" 和 equals 的区别是什么？
   答："” 对基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

① “==” 解读

对于基本类型和引用类型 == 的作用效果是不同的，如下所示：

基本类型：比较的是值是否相同；
引用类型：比较的是引用是否相同。
代码示例：

String x = “string”;
String y = “string”;
String z = new String(“string”);
System.out.println(xy); // true
System.out.println(xz); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true
代码说明：因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String() 方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。

② equals 解读

equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。看下面的代码就明白了。

首先来看默认情况下 equals 比较一个有相同值的对象，代码如下：

class Cat {
public Cat(String name) {
this.name = name;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Cat c1 = new Cat(“王磊”);
Cat c2 = new Cat(“王磊”);
System.out.println(c1.equals(c2)); // false
输出结果出乎我们的意料，竟然是 false？！

这是怎么回事，看了 equals 源码就知道了，源码如下：

public boolean equals(Object obj) {
return (this == obj);
}
原来 equals 本质上就是 ==。

那问题来了，两个相同值的 String 对象，为什么返回的是 true？代码如下：

String s1 = new String(“老王”);
String s2 = new String(“老王”);
System.out.println(s1.equals(s2)); // true
同样的，当我们进入 String 的 equals 方法，找到了答案，代码如下：

public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
原来是 String 重写了 Object 的 equals 方法，把引用比较改成了值比较。

总结来说，"==" 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

4. 以下代码输出的结果是？
   String str = “laowang”;
   str.substring(0,1);
   System.out.println(str);
   A：l
   B：a
   C：la
   D：laowang

答：D

题目解析：因为 String 的 substring() 方法不会修改原字符串内容，所以结果还是 laowang。

5. 以下字符串对比的结果是什么？
   String s1 = “hi,” + “lao” + “wang”;
   String s2 = “hi,”;
   s2 += “lao”;
   s2 += “wang”;
   String s3 = “hi,laowang”;
   System.out.println(s1 == s2);
   System.out.println(s1 == s3);
   System.out.println(s2 == s3);
   答：false true false

题目解析：String s1 = “hi,” + “lao” + “wang” 代码会被 JVM 优化为：String s1 = “hi,laowang”，这样就和 s3 完全相同，s1 创建的时候会把字符"hi,laowang"放入常量池，s3 创建的时候，常量池中已经存在对应的缓存，会直接把引用返回给 s3，所以 s1==s3 就为 true，而 s2 使用了 += 其引用地址就和其他两个不同。

6. 以下 String 传值修改后执行的结果是什么？
   public static void main(String[] args) {
   String str = new String(“laowang”);
   change(str);
   System.out.println(str);
   }
   public static void change(String str) {
   str = “xiaowang”;
   }
   答：laowang

7. 以下 StringBuffer 传值修改后的执行结果是什么？
   public static void main(String[] args) {
   StringBuffer sf = new StringBuffer(“hi,”);
   changeSf(sf);
   System.out.println(sf);
   }
   public static void changeSf(StringBuffer sf){
   sf.append(“laowang”);
   }
   答：hi,laowang

题目解析：String 为不可变类型，在方法内对 String 修改的时候，相当修改传递过来的是一个 String 副本，所以 String 本身的值是不会被修改的，而 StringBuffer 为可变类型，参数传递过来的是对象的引用，对其修改它本身就会发生改变。

8. 以下使用 substring 执行的结果什么？
   String str = “abcdef”;
   System.out.println(str.substring(3, 3));
   答：""(空)。

9. 判定字符串是否为空，有几种方式？
   答：常用的方式有以下两种。

str.equals("")
str.length()==0
10. String、StringBuffer、StringBuilder 的区别？
答：以下是 String、StringBuffer、StringBuilder 的区别：

可变性：String 为字符串常量是不可变对象，StringBuffer 与 StringBuilder 为字符串变量是可变对象；
性能：String 每次修改相当于生成一个新对象，因此性能最低；StringBuffer 使用 synchronized 来保证线程安全，性能优于 String，但不如 StringBuilder；
线程安全：StringBuilder 为非线程安全类，StringBuffer 为线程安全类。
11. String 对象的 intern() 有什么作用？
答：intern() 方法用于查找常量池中是否存在该字符值，如果常量池中不存在则先在常量池中创建，如果已经存在则直接返回。

示例代码：

String s = “laowang”;
String s2 = s.intern();
System.out.println(s == s2); // 返回 true
12. String s=new String(“laowang”) 创建了几个对象？
答：总共创建了两个对象，一个是字符串 “laowang”，另一个是指向字符串的变量 s。new String() 不管常量池有没有相同的字符串，都会在内存（非字符串常量池）中创建一个新的对象。

13. 什么是字符串常量池？
    字符串常量池是存储在 Java 堆内存中的字符串池，是为防止每次新建字符串带的时间和空间消耗的一种解决方案。在创建字符串时 JVM 会首先检查字符串常量池，如果字符串已经存在池中，就返回池中的实例引用，如果字符串不在池中，就会实例化一个字符串放到池中并把当前引用指向该字符串。

14. String 不可变性都有哪些好处？
    答：不可变的好处如下。

只有当字符串是不可变的，字符串常量池才能实现，字符串池的实现可以在运行时节约很多堆空间，因为不同的字符串变量都指向池中的同一个字符串；
可以避免一些安全漏洞，比如在 Socket 编程中，主机名和端口都是以字符串的形式传入，因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞；
多线程安全，因为字符串是不可变的，所以同一个字符串实例可以被多个线程共享，保证了多线程的安全性；
适合做缓存的 key，因为字符串是不可变的，所以在它创建的时候哈希值就被缓存了，不需要重新计算速度更快，所以字符串很适合作缓存的中的 key。
15. String 是否可以被继承？为什么？
答：String 不能被继承。因为 String 被声明为 final（最终类），所以不能被继承，源码如下（JDK 8）。

public final class String
implements java.io.Serializable, Comparable, CharSequence {
//…
}

4、Java 中的运算符和流程控制 + 面试题
算术运算符
Java 中的算法运算符，包括以下几种：

算术运算符 名称 举例

• 加法 1+2=3

• 减法 2-1=1

• 乘法 2*3=6
  / 除法 24/8=3
  % 求余 24%7=3
  ++ 自增1 int i=1;i++
  – 自减1 int i=1;i–
  我们本讲要重点讲的是 “++” 和 “–”，其他的算术运算符相对比较简单直观，本讲就不花精力去讲解了，之所以要把 “++” 和 “–” 单独拿出来讲，是因为在使用他们的时候有很多坑需要开发者注意，最重要的是 “++” 和 “–” 也是面试中高频出现的面试题。

先来看 “++” 的基本使用：

int i = 1;
int i2 = ++i; // ++i 相当于 i = 1+i;
System.out.println(i); // 2
System.out.println(i2); // 2
++i 和 i++ 的区别

++i 先自加再赋值
i++ 先赋值再自加
比如：

int i = 0;
int i2 = i++;
int j = 0;
int j2 = ++j;
System.out.println(“i2=” + i2);
System.out.println(“j2=” + j2);
输出的结果：

i2=0
j2=1
代码解析：i++ 是先给 i2 赋值再自身 +1 ，所以 i2 等于0，而 ++j 是先自加等于 1 之后，再赋值给 j2，所以 j2 等于 1。

注意事项

++/-- 是非线程安全的，也就是说 ++/-- 操作在多线程下可能会引发混乱，例如下面代码：

new Thread() {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
System.out.println(“thread:” + this.getName() + “,count=” + (++count));
}
}
}.start();
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
System.out.println(“thread:” + this.getName() + “,count=” + (++count));
}
}
}.start();
执行的结果，如下图：

执行结果

如上图所示，每台机器的执行可能略有差距，但大多数情况下并不能给我们想要的真实值 200000。

原理分析

“++” 操作在多线程下引发混乱的原因：因为 ++ 操作对于底层操作系统来说，并不是一条 CPU 操作指令，而是三条 CPU 操作指令——取值、累加、存储，因此无法保证原子性，就会出现上面代码执行后的误差。

如何避免 ++/-- 操作在多线程下的“误差”？

方法一：++/-- 操作放在同步块 synchronized 中。
方法二：自己申明锁，把 ++/-- 操作放入其中。
方法三：使用 AtomicInteger 类型替代 int 类型。
最后，因为 – 的语法和 ++ 完全一致，所以 – 的操作，请参照上面的 ++ 语法。

条件运算符（三元运算符）
条件运算符（?:）也叫“三元运算符”。

语法：

布尔表达式 ? 表达式1 ：表达式2

运算过程：如果布尔表达式的值为 true，则返回 表达式 1 的值，否则返回 表达式 2 的值。

例如：

String s = 3 > 1 ? “三大于一” : “三小于一”;
System.out.println(s);
执行结果：三大于一。

流程控制
在 Java 语言中使用条件语句和循环结构来实现流程控制。

1 条件语句
条件语句的语法格式：

if(…) …

其中的条件判断必须使用括号括起来不能省略。

基础用法使用：

int i = 1;
if (i > 1) {
System.out.println(“i大于一”);
} else if (i == 1) {
System.out.println(“i等于一”);
} else {
System.out.println(“其他”);
}
2 循环
while 当条件成立的时候执行下一条语句。

while 语法格式：

while(…) …

基本语法使用：

int i = 0;
while (i < 3) {
System.out.println(++i);
}
while 是先判断再决定是否执行，有可能一次也不执行，如果希望至少执行一次，可以使用 do/while。

do/while 语法格式：

do{…}while(…);

基本语法使用：

int i = 0;
do {
System.out.println(++i);
} while (i < 3);
3 确定循环
for 循环是程序中最长使用的循环之一，它是利用每次迭代之后更新计数器来控制循环的次数。

for 语法格式：

for(int i=0;i<n;i++){ … }

基础语法使用：

for (int i = 0; i < 10; i++) {
System.out.println(“i=” + i);
}
for 循环中可使用关键字 continue，跳过后续操作，继续下一次迭代。

例如：

for (int i = 1; i < 4; i++) {
if (i == 2) continue;
System.out.println(“i=” + i);
}
执行结果：

i=1
i=3
如结果所示，第二次循环就会跳过，执行下一次循环。

for 注意事项

在循环中检查两个浮点数是否相等要格外小心，例如下面代码：

public static void main(String[] args) {
for (float i = 0; i != 1; i += 0.1) {
System.out.println(i);
}
}
循环永远不会停下来，由于舍入误差，因为 0.1 无法精确的用二级制表示，所以上面代码到 0.9000001 之后，会直接跳到 1.0000001，不会等于 1，所以循环就永远不会停下来。

4 多重选择
switch 的特点是可以判断多个条件，if 的特点是执行少量判断，它们两个刚好形成互补的关系。

switch 语法格式：

switch(…){ case 1: … break; … default: … break; }

switch 基础使用：

int i = 3;
switch (i) {
case 1:
System.out.println(“等于1”);
break;
case 2:
System.out.println(“等于2”);
break;
case 3:
System.out.println(“等于3”);
break;
default:
System.out.println(“等于其他”);
break;
}
可用于 case 的类型有：

byte、char、short、int
枚举
字符串（Java SE 7 新加入）
switch 注意事项

switch 使用时，每个选项最末尾一定不要忘记加 break 关键字，否则会执行多个条件。

案例：

int i = 1;
switch (i) {
case 1:
System.out.println(“等于1”);
case 2:
System.out.println(“等于2”);
case 3:
System.out.println(“等于3”);
default:
System.out.println(“等于其他”);
}
程序执行的结果：

等于1
等于2
等于3
等于其他
所以使用 switch 时，每个选项的末尾一定得加 break 关键字。

相关面试题

1. Java 中 i++ 和 ++i 有什么区别？
   答：i 先赋值再运算；i 先运算再赋值。

示例代码：

int i = 0;
int i2 = i++;
int j = 0;
int j2 = ++j;
System.out.println(“i2=” + i2);
System.out.println(“j2=” + j2);
输出结果：i2=0，j2=1

2. 以下代码 i 的值是多少？
   int i = 0;
   i = i++;
   System.out.println(i);
   答：i=0

题目解析：因为 Java 虚拟机在执行 i++ 时，把这个值有赋值给了 i，而 i++ 是先赋值再相加，所以这个时候 i 接收到的结果自然是 0 了。

3. 以下代码 i2 和 i3 的值分别为多少？
   int i = 0;
   int i2 = i++;
   int i3 = ++i;
   答：i2=0，i3=2

4. 以下代码能不能正常执行？
   if (true) System.out.println(“laowang”);
   答：可以正常执行，其中判断条件的括号不能省略，大括号是可以省略的（作者并不建议为了省代码的而牺牲代码的可读性）。

5. 以下 switch 执行的结果是什么？
   int num = 1;
   switch (num) {
   case 0:
   System.out.print(“0”);
   case 1:
   System.out.print(“1”);
   case 2:
   System.out.print(“2”);
   case 3:
   System.out.print(“3”);
   default:
   System.out.print(“default”);
   }
   答：123default

6. switch 能否用于 byte 类型的判断上？能否用于 long 类型的判断上？
   答：switch 支持 byte 类型的判断，不支持 long 类型的判断。

题目解析：switch 支持的全部类型（JDK 8）：char、byte、short、int、Charachter、Byte、Short、Integer、String、enum。

7. while 必须配合 break 一起使用的说法正确吗？
   答：错误，while 可以单独使用。

例如：

int i = 0;
while (i < 3) {
System.out.println(++i);
}
8. 以下代码可以正常运行吗？为什么？
int i = 0;
while (i < 3) {
if (i == 2) {
return;
}
System.out.println(++i);
}
答：可以正常运行，这里的 return 和 break 的效果是一致的，while 可以配合 return 或 break 一起使用。

9. 以下的程序执行结果什么？
   int i = 0;
   do {
   System.out.println(++i);
   } while (i < 3)
   答：编译器报错，do/while 之后必须使用分号 ; 结尾。

10. 以下程序输出的结果是？
    String s = new String(“laowang”);
    String s2 = new String(“laowang”);
    System.out.println(s == s2);
    switch (s) {
    case “laowang”:
    System.out.println(“laowang”);
    break;
    default:
    System.out.println(“default”);
    break;
    }
    A：true,default
    B：false,default
    C：false,laowang
    D：true,laowang

答：C

11. 以下代码循环执行了几次？
    for (float i = 0; i != 10; i += 0.1) {
    System.out.println(“hi”);
    }
    答：无数次，循环永远不会停下来。由于舍入误差，因为 0.1 无法精确的用二级制表示，所以上面代码到 0.9000001 之后，会直接跳到 1.0000001，不会等于 1，所以循环就永远不会停下来。

12. 以下代码输出的结果是？
    int num = -4;
    System.out.println(num % 2 == 1 || num % 2 == -1);
    A：1
    B：-1
    C：true
    D：false

答：D

题目解析：-4 % 2 = 0 既不等于 1 也不等于 -1，所以结果为 false。

13. 以下代码输出的结果是？
    int num = 4;
    num = ((num & 1) == 1);
    System.out.println(num);
    A：4
    B：1
    C：以上都不是

答：C

题目解析：== 运算返回的是 boolean 类型，不能使用 int 接收，所以程序会报错。

5、深入了解 Java 中的异常处理 + 面试题
在程序开发中，异常处理也是我们经常使用到的模块，只是平常很少去深究异常模块的一些知识点。比如，try-catch 处理要遵循的原则是什么，finally 为什么总是能执行，try-catch 为什么比较消耗程序的执行性能等问题，我们本讲内容都会给出相应的答案，当然还有面试中经常被问到的异常模块的一些面试题，也是我们本篇要讲解的重点内容。

异常处理基础介绍
先来看看异常处理的语法格式：

try{ … } catch(Exception e){ … } finally{ … }

其中，

try：是用来监测可能会出现异常的代码段。
catch：是用来捕获 try 代码块中某些代码引发的异常，如果 try 里面没有异常发生，那么 catch 也一定不会执行。在 Java 语言中，try 后面可以有多个 catch 代码块，用来捕获不同类型的异常，需要注意的是前面的 catch 捕获异常类型一定不能包含后面的异常类型，这样的话，编译器会报错。
finally：不论 try-catch 如何执行，finally 一定是最后执行的代码块，所有通常用来处理一些资源的释放，比如关闭数据库连接、关闭打开的系统资源等。
异常处理的基本使用，具体可以参考下面的代码段：

try {
int i = 10 / 0;
} catch (ArithmeticException e) {
System.out.println(e);
} finally {
System.out.println(“finally”);
}
多 catch 的使用，具体可以参考下面的代码段：

try {
int i = Integer.parseInt(null);
} catch (ArithmeticException ae) {
System.out.println(“ArithmeticException”);
} catch (NullPointerException ne) {
System.out.println(“NullPointerException”);
} catch (Exception e) {
System.out.println(“Exception”);
}
需要注意的是 Java 虚拟机会从上往下匹配错误类型，因此前面的 catch 异常类型不能包含后面的异常类型。比如上面的代码如果把 Exception 放在最前面编译器就会报错，具体可以参考下面的图片。

enter image description here

异常处理的发展
随着 Java 语言的发展，JDK 7 的时候引入了一些更加便利的特性，用来更方便的处理异常信息，如 try-with-resources 和 multiple catch，具体可以参考下面的代码段：

try (FileReader fileReader = new FileReader("");
FileWriter fileWriter = new FileWriter("")) { // try-with-resources
System.out.println(“try”);
} catch (IOException | NullPointerException e) { // multiple catch
System.out.println(e);
}
异常处理的基本原则
先来看下面这段代码，有没有发现一些问题？

try {
// …
int i = Integer.parseInt(null);
} catch (Exception e) {
}
以上的这段代码，看似“正常”，却违背了异常处理的两个基本原则：

第一，尽量不要捕获通用异常，也就是像 Exception 这样的异常，而是应该捕获特定异常，这样更有助于你发现问题；
第二，不要忽略异常，像上面的这段代码只是加了 catch，但没有进行如何的错误处理，信息就已经输出了，这样在程序出现问题的时候，根本找不到问题出现的原因，因此要切记不要直接忽略异常。
异常处理对程序性能的影响
异常处理固然好用，但一定不要滥用，比如下面的代码片段：

// 使用 com.alibaba.fastjson
JSONArray array = new JSONArray();
String jsonStr = “{‘name’:‘laowang’}”;
try {
array = JSONArray.parseArray(jsonStr);
} catch (Exception e) {
array.add(JSONObject.parse(jsonStr));
}
System.out.println(array.size());
这段代码是借助了 try-catch 去处理程序的业务逻辑，通常是不可取的，原因包括下列两个方面。

try-catch 代码段会产生额外的性能开销，或者换个角度说，它往往会影响 JVM 对代码进行优化，因此建议仅捕获有必要的代码段，尽量不要一个大的 try 包住整段的代码；与此同时，利用异常控制代码流程，也不是一个好主意，远比我们通常意义上的条件语句（if/else、switch）要低效。
Java 每实例化一个 Exception，都会对当时的栈进行快照，这是一个相对比较重的操作。如果发生的非常频繁，这个开销可就不能被忽略了。
以上使用 try-catch 处理业务的代码，可以修改为下列代码：

// 使用 com.alibaba.fastjson
JSONArray array = new JSONArray();
String jsonStr = “{‘name’:‘laowang’}”;
if (null != jsonStr && !jsonStr.equals("")) {
String firstChar = jsonStr.substring(0, 1);
if (firstChar.equals("{")) {
array.add(JSONObject.parse(jsonStr));
} else if (firstChar.equals("[")) {
array = JSONArray.parseArray(jsonStr);
}
}
System.out.println(array.size());
相关面试题

1. try 可以单独使用吗？
   答：try 不能单独使用，否则就失去了 try 的意义和价值。

2. 以下 try-catch 可以正常运行吗？
   try {
   int i = 10 / 0;
   } catch {
   System.out.println(“last”);
   }
   答：不能正常运行，catch 后必须包含异常信息，如 catch (Exception e)。

3. 以下 try-finally 可以正常运行吗？
   try {
   int i = 10 / 0;
   } finally {
   System.out.println(“last”);
   }
   答：可以正常运行。

4. 以下代码 catch 里也发生了异常，程序会怎么执行？
   try {
   int i = 10 / 0;
   System.out.println(“try”);
   } catch (Exception e) {
   int j = 2 / 0;
   System.out.println(“catch”);
   } finally {
   System.out.println(“finally”);
   }
   System.out.println(“main”);
   答：程序会打印出 finally 之后抛出异常并终止运行。

5. 以下代码 finally 里也发生了异常，程序会怎么运行？
   try {
   System.out.println(“try”);
   } catch (Exception e) {
   System.out.println(“catch”);
   } finally {
   int k = 3 / 0;
   System.out.println(“finally”);
   }
   System.out.println(“main”);
   答：程序在输出 try 之后抛出异常并终止运行，不会再执行 finally 异常之后的代码。

6. 常见的运行时异常都有哪些？
   答：常见的运行时异常如下：

java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象；
java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误，通常是程序
试图通过字符串来加载某个类时引发的异常；

java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符；
java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生；
java.lang.ClassCastException 数据类型转换异常；
java.lang.NoClassDefFoundException 未找到类定义错误；
java.lang.NoSuchMethodException 方法不存在异常；
java.lang.IllegalArgumentException 方法传递参数错误。
7. Exception 和 Error 有什么区别？
答：Exception 和 Error 都属于 Throwable 的子类，在 Java 中只有 Throwable 及其之类才能被捕获或抛出，它们的区别如下：

Exception（异常）是程序正常运行中，可以预期的意外情况，并且可以使用 try/catch 进行捕获处理的。Exception 又分为运行时异常（Runtime Exception）和受检查的异常（Checked Exception），运行时异常编译能通过，但如果运行过程中出现这类未处理的异常，程序会终止运行；而受检查的异常，要么用 try/catch 捕获，要么用 throws 字句声明抛出，否则编译不会通过。
Error（错误）是指突发的非正常情况，通常是不可以恢复的，比如 Java 虚拟机内存溢出，诸如此类的问题叫做 Error。
8. throw 和 throws 的区别是什么？
答：它们的区别如下：

throw 语句用在方法体内，表示抛出异常由方法体内的语句处理，执行 throw 一定是抛出了某种异常；
throws 语句用在方法声明的后面，该方法的调用者要对异常进行处理，throws 代表可能会出现某种异常，并不一定会发生这种异常。
9. Integer.parseInt(null) 和 Double.parseDouble(null) 抛出的异常一样吗？为什么？
答：Integer.parseInt(null) 和 Double.parseDouble(null) 抛出的异常类型不一样，如下所示：

Integer.parseInt(null) 抛出的异常是 NumberFormatException；
Double.parseDouble(null) 抛出的异常是 NullPointerException。
至于为什么会产生不同的异常，其实没有特殊的原因，主要是由于这两个功能是不同人开发的，因而就产生了两种不同的异常信息。

10. NoClassDefFoundError 和 ClassNoFoundException 有什么区别？
    NoClassDefFoundError 是 Error（错误）类型，而 ClassNoFoundExcept 是 Exception（异常）类型；
    ClassNoFoundExcept 是 Java 使用 Class.forName 方法动态加载类，没有加载到，就会抛出 ClassNoFoundExcept 异常；
    NoClassDefFoundError 是 Java 虚拟机或者 ClassLoader 尝试加载类的时候却找不到类订阅导致的，也就是说要查找的类在编译的时候是存在的，运行的时候却找不到，这个时候就会出现 NoClassDefFoundError 的错误。

11. 使用 try-catch 为什么比较耗费性能？
    答：这个问题要从 JVM（Java 虚拟机）层面找答案了。首先 Java 虚拟机在构造异常实例的时候需要生成该异常的栈轨迹，这个操作会逐一访问当前线程的栈帧，并且记录下各种调试信息，包括栈帧所指向方法的名字，方法所在的类名、文件名，以及在代码中的第几行触发该异常等信息，这就是使用异常捕获耗时的主要原因了。

12. 常见的 OOM 原因有哪些？
    答：常见的 OOM 原因有以下几个：

数据库资源没有关闭；
加载特别大的图片；
递归次数过多，并一直操作未释放的变量。
13. 以下程序的返回结果是？
public static int getNumber() {
try {
int number = 0 / 1;
return 2;
} finally {
return 3;
}
}
A：0

B：2

C：3

D：1

答：3

题目解析：程序最后一定会执行 finally 里的代码，会把之前的结果覆盖为 3。

14. finally、finalize 的区别是什么？
    答：finally、finalize 的区别如下：

finally 是异常处理语句的一部分，表示总是执行；
finalize 是 Object 类的一个方法，子类可以覆盖该方法以实现资源清理工作，垃圾回收之前会调用此方法。
15. 为什么 finally 总能被执行？
答：finally 总会被执行，都是编译器的作用，因为编译器在编译 Java 代码时，会复制 finally 代码块的内容，然后分别放在 try-catch 代码块所有的正常执行路径及异常执行路径的出口中，这样 finally 才会不管发生什么情况都会执行。

6、玩转时间操作 + 面试题
在 JDK 8 之前，Java 语言为我们提供了两个类用于操作时间，它们分别是：java.util.Date 和 java.util.Calendar，但在 JDK 8 的时候为了解决旧时间操作类的一些缺陷，提供了几个新的类，用于操作时间和日期，它们分别是：LocalTime、LocalDateTime、Instant，都位于 java.time 包下。

时间的操作在我们日常的开发中经常见到，比如，业务数据都要记录创建时间和修改时间，并要把这些时间格式化之后显示到前端页面，再比如我们需要计算业务数据的时间间隔等，都离不开对时间的操作，那如何正确而优雅地使用时间？这就是我们接下来要讨论的话题。

时间基础知识科普
格林威治时间
格林威治（又译格林尼治）是英国伦敦南郊原格林威治天文台的所在地，它是世界计算时间和地球经度的起点，国际经度会议 1884 年在美国华盛顿召开，会上通过协议，以经过格林威治天文台的经线为零度经线（即本初子午线），作为地球经度的起点，并以格林威治为“世界时区”的起点。

格林威治时间和北京时间的关系
格林威治时间被定义为世界时间，就是 0 时区，北京是东八区。也就是说格林威治时间的 1 日 0 点，对应到北京的时间就是 1 日 8 点。

时间戳
时间戳是指格林威治时间 1970-01-01 00:00:00（北京时间 1970-01-01 08:00:00）起至现在的总秒数。

JDK 8 之前的时间操作
1 获取时间
Date date = new Date();
System.out.println(date);
Calendar calendar = Calendar.getInstance();
Date time = calendar.getTime();
System.out.println(time);
2 获取时间戳
long ts = new Date().getTime();
System.out.println(ts);
long ts2 = System.currentTimeMillis();
System.out.println(ts2);
long ts3 = Calendar.getInstance().getTimeInMillis();
System.out.println(ts3);
3 格式化时间
SimpleDateFormat sf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
System.out.println(sf.format(new Date())); // output:2019-08-16 21:46:22
SimpleDateFormat 构造参数的含义，请参考以下表格信息：

字符 含义 示例
y 年 yyyy-1996
M 月 MM-07
d 月中的天数 dd-02
D 年中的天数 121
E 星期几 星期四
H 小时数（0-23） HH-23
h 小时数（1-12） hh-11
m 分钟数 mm-02
s 秒数 ss-03
Z 时区 +0800
使用示例：

获取星期几：new SimpleDateFormat(“E”).format(new Date())
获取当前时区：new SimpleDateFormat(“Z”).format(new Date*())
注意事项：在多线程下 SimpleDateFormat 是非线程安全的，因此在使用 SimpleDateFormat 时要注意这个问题。在多线程下，如果使用不当，可能会造成结果不对或内存泄漏等问题。

4 时间转换
SimpleDateFormat sf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
// String 转 Date
String str = “2019-10-10 10:10:10”;
System.out.println(sf.parse(str));
//时间戳的字符串 转 Date
String tsString = “1556788591462”;
// import java.sql
Timestamp ts = new Timestamp(Long.parseLong(tsString)); // 时间戳的字符串转 Date
System.out.println(sf.format(ts));
注意事项：当使用 SimpleDateFormat.parse() 方法进行时间转换的时候，SimpleDateFormat 的构造函数必须和待转换字符串格式一致。

5 获得昨天此刻时间
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -1);
System.out.println(calendar.getTime());
JDK 8 时间操作
JDK 8 对时间操作新增了三个类：LocalDateTime、LocalDate、LocalTime。

LocalDate 只包含日期，不包含时间，不可变类，且线程安全。
LocalTime 只包含时间，不包含日期，不可变类，且线程安全。
LocalDateTime 既包含了时间又包含了日期，不可变类，且线程安全。
线程安全性

值得一提的是 JDK 8 中新增的这三个时间相关的类，都是线程安全的，这极大地降低了多线程下代码开发的风险。

1 获取时间
// 获取日期
LocalDate localDate = LocalDate.now();
System.out.println(localDate); // output:2019-08-16
// 获取时间
LocalTime localTime = LocalTime.now();
System.out.println(localTime); // output:21:09:13.708
// 获取日期和时间
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime); // output:2019-08-16T21:09:13.708
2 获取时间戳
long milli = Instant.now().toEpochMilli(); // 获取当前时间戳（精确到毫秒）
long second = Instant.now().getEpochSecond(); // 获取当前时间戳（精确到秒）
System.out.println(milli); // output:1565932435792
System.out.println(second); // output:1565932435
3 时间格式化
// 时间格式化①
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”);
String timeFormat = dateTimeFormatter.format(LocalDateTime.now());
System.out.println(timeFormat); // output:2019-08-16 21:15:43
// 时间格式化②
String timeFormat2 = LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));
System.out.println(timeFormat2); // output:2019-08-16 21:17:48
4 时间转换
String timeStr = “2019-10-10 06:06:06”;
LocalDateTime dateTime = LocalDateTime.parse(timeStr,DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));
System.out.println(dateTime);
5 获得昨天此刻时间
LocalDateTime today = LocalDateTime.now();
LocalDateTime yesterday = today.plusDays(-1);
System.out.println(yesterday);
相关面试题

1. 获取当前时间有几种方式？
   答：获取当前时间常见的方式有以下三种：

new Date()
Calendar.getInstance().getTime()
LocalDateTime.now()
2. 如何获取昨天此刻的时间？
答：以下为获取昨天此刻时间的两种方式：

// 获取昨天此刻的时间（JDK 8 以前）
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE,-1);
System.out.println(c.getTime());
// 获取昨天此刻的时间（JDK 8）
LocalDateTime todayTime = LocalDateTime.now();
System.out.println(todayTime.plusDays(-1));
3. 如何获取本月的最后一天？
答：以下为获取本月最后一天的两种方式：

// 获取本月的最后一天（JDK 8 以前）
Calendar ca = Calendar.getInstance();
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
System.out.println(ca.getTime());
// 获取本月的最后一天（JDK 8）
LocalDate today = LocalDate.now();
System.out.println(today.with(TemporalAdjusters.lastDayOfMonth()));
4. 获取当前时间的时间戳有几种方式？
答：以下为获取当前时间戳的几种方式：

System.currentTimeMillis()
new Date().getTime()
Calendar.getInstance().getTime().getTime()
Instant.now().toEpochMilli()
LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli()
其中，第四种和第五种方式是 JDK 8 才新加的。

5. 如何优雅地计算两个时间的相隔时间？
   答：JDK 8 中可以使用 Duration 类来优雅地计算两个时间的相隔时间，代码如下：

LocalDateTime dt1 = LocalDateTime.now();
LocalDateTime dt2 = dt1.plusSeconds(60);
Duration duration = Duration.between(dt1, dt2);
System.out.println(duration.getSeconds()); // output:60
6. 如何优雅地计算两个日期的相隔日期？
答：JDK 8 中可以使用 Period 类来优雅地计算两个日期的相隔日期，代码如下：

LocalDate d1 = LocalDate.now();
LocalDate d2 = d1.plusDays(2);
Period period = Period.between(d1, d2);
System.out.println(period.getDays()); //output:2
7. SimpleDateFormat 是线程安全的吗？为什么？
答：SimpleDateFormat 是非线程安全的。因为查看 SimpleDateFormat 的源码可以得知，所有的格式化和解析，都需要通过一个中间对象进行转换，这个中间对象就是 Calendar，这样的话就造成非线程安全。试想一下当我们有多个线程操作同一个 Calendar 的时候后来的线程会覆盖先来线程的数据，那最后其实返回的是后来线程的数据，因此 SimpleDateFormat 就成为了非线程的了。

8. 怎么保证 SimpleDateFormat 的线程安全？
   答：保证 SimpleDateFormat 线程安全的方式如下：

使用 Synchronized，在需要时间格式化的操作使用 Synchronized 关键字进行包装，保证线程堵塞格式化；
手动加锁，把需要格式化时间的代码，写到加锁部分，相对 Synchronized 来说，编码效率更低，性能略好，代码风险较大（风险在于不要忘记在操作的最后，手动释放锁）；
使用 JDK 8 的 DateTimeFormatter 替代 SimpleDateFormat。
9. JDK 8 中新增的时间类都有哪些优点？
答：JDK 8 中的优点具体有以下几个优点，如下：

线程安全性
使用的便利性（如获取当前时间戳的便利性、增减日期的便利性等）
编写代码更简单优雅，如当前时间的格式化：LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));
10. 如何比较两个时间（Date）的大小？
答：时间比较有以下三种方式：

获取两个时间的时间戳，得到两个 long 类型的变量，两个变量相减，通过结果的正负值来判断大小；
通过 Date 自带的 before()、after()、equals() 等方法比较，代码示例 date1.before(date2)；
通过 compareTo() 方法比较，代码示例：date1.compareTo(date2)，返回值 -1 表示前一个时间比后一个时间小，0 表示两个时间相等，1 表示前一个时间大于后一个时间。
总结
JDK 8 之前使用 java.util.Date 和 java.util.Calendar 来操作时间，它们有两个很明显的缺点，第一，非线程安全；第二，API 调用不方便。JDK 8 新增了几个时间操作类 java.time 包下的 LocalDateTime、LocalDate、LocalTime、Duration（计算相隔时间）、Period（计算相隔日期）和 DateTimeFormatter，提供了多线程下的线程安全和易用性，让我们可以更好的操作时间。