Java 中的异常处理
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 之后抛出异常并终止运行。
finally
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Main.main(Main.java:7)
Exited with error status 1
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 原因有以下几个：
- 数据库资源没有关闭；
- 加载特别大的图片；
- 递归次数过多，并一直操作未释放的变量。
==Tips==：什么是OOM**？** OOM，全称“Out Of Memory”，翻译成中文就是“内存用完了”，来源于java.lang.OutOfMemoryError。看下关于的官方说明： Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector. 意思就是说，当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收时，就会抛出这个error（注：非exception，因为这个问题已经严重到不足以被应用处理）
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 才会不管发生什么情况都会执行。
时间操作
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
答：SimpleDateFormat 是非线程安全的。因为查看 SimpleDateFormat
的源码可以得知，所有的格式化和解析，都需要通过一个中间对象进行转换，这个中间对象就是
Calendar，这样的话就造成非线程安全。试想一下当我们有多个线程操作同一个 Calendar
的时候后来的线程会覆盖先来线程的数据，那最后其实返回的是后来线程的数据，因此 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，提供了多线程下的线程安全和易用性，让我们可以更好的操作时间。
数组和排序算法的应用
1. 数组和集合有什么区别？
答：数组和集合的区别如下：
- 集合可以存储任意类型的对象数据，数组只能存储同一种数据类型的数据；
- 集合的长度是会发生变化的，数组的长度是固定的；
- 集合相比数组功能更强大，数组相比集合效率更高。
2. 以下代码访问数组元素打印的结果是多少？
int[] arr = new int[5] {1, 2, 3, 4, 5};
System.out.println(arr[4]);
答：程序编译报错，在 Java 中初始化数组时，如果直接给数组赋值，不能声明数组长度；如果声明了数组长度，则不能赋值给数组，否则编译器报错。
Main.java:3: error: array creation with both dimension expression and initialization is illegal
int[] arr = new int[5] {1, 2, 3, 4, 5};
^
1 error
正确的写法如下：
int[] arr = new int[]{1, 2, 3, 4, 5};
System.out.println(arr[4]);
输出的结果为：5，访问元素从 0 开始。
3. 执行以下代码会输出什么结果？
public static void main(String[] args) {
int[] arr = {2, 3, 4, 8};
change(arr);
System.out.println(arr[2]);
}
private static void change(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i % 2 == 0) {
arr[i] *= i;
}
}
}
答：输出的结果是 8。
题目解析：在 Java 中数组本质是引用类型，因此在调用方法中修改数组，就是对原数组本身的修改。
4. 以下程序打印的结果是多少？
int[] intArr = new int[3];
String[] StrArr = new String[3];
System.out.println(intArr[1]);
System.out.println(StrArr[1]);
答：以上程序打印的结果是：0 和 null。
题目解析：new int[3] 相当于声明了数组的长度为 3，每个元素初始化为 0，而 new String[3] 相当于声明了数组的长度为
3，每个元素初始化为 null。
5. 数组转换字符串有哪些方式？
答：数组转换字符串，有以下几种方式。
方式一：遍历拼接，完整代码如下：
String[] arr = {"laowang", "stone", "wanglei"};
StringBuffer sb = new StringBuffer();
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i]);
if (i != arr.length - 1)
sb.append(",");
}
System.out.println(sb.toString());
方式二：Arrays.toString() 转换，完整代码如下：
String[] arr = {"laowang", "stone", "wanglei"};
String str2 = Arrays.toString(arr);
System.out.println(str2);
方式三：StringUtils.join() 转换，完整代码如下：
String[] arr = {"laowang", "stone", "wanglei"};
String str3 = StringUtils.join(Arrays.asList(arr), ","); // 使用英文逗号分隔
System.out.println(str3);
6. 数组遍历有哪几种方式？
答：常见的数组遍历有以下三种方式。
- 传统 for 循环，如 for (int i = 0; i < arr.length; i++) { //...... }
- for each 循环，如 for (int i : arr) { //...... }
- jdk 8 Lambda 方式，如
Integer[] arr = {2, 3, 6, 7, 9}; Arrays._asList_(arr).forEach(x -> System._out_.println(x));
7. 以下数组比较的结果分别是什么？
String[] strArr = {"dog", "cat", "pig", "bird"};
String[] strArr2 = {"dog", "cat", "pig", "bird"};
System.out.println(Arrays.equals(strArr, strArr2));
System.out.println(strArr.equals(strArr2));
System.out.println(strArr == strArr2);
答：上面代码执行的结果，分别为：true、false、false。
题目解析：strArr == strArr2 为引用比较，因此结果一定是 false，而数组本身的比较也就是 strArr.equals(strArr2)
为 false 的原因是因为数组没有重写 equals 方法，因此也是引用比较。数组 equals 源码实现如下：
public boolean equals(Object obj) {
return (this == obj);
}
而 Arrays.equals 的结果之所以是 true 是因为 Arrays.equals 重写了 equals 方法。源代码实现如下：
public static boolean equals(Object[] a, Object[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++) {
Object o1 = a[i];
Object o2 = a2[i];
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return true;
}
8. 以下程序使用 Arrays.binarySearch 返回的结果是 true 还是 false？
String[] arr = {"dog", "cat", "pig", "bird"};
int result = Arrays.binarySearch(arr, "bird");
System.out.println(result == -1);
答：返回的结果是：true。
题目解析：使用 Arrays.binarySearch 之前一定要先调用 Arrays.sort() 对数组进行排序，否则返回的结果有误，本数组返回的结果是
﹣1，是因为没有使用排序的结果，正确的使用请查看以下代码：
String[] arr = {"dog", "cat", "pig", "bird"};
Arrays.sort(arr);
int result = Arrays.binarySearch(arr, "bird");
System.out.println(result == -1);
9. Arrays 对象有哪些常用的方法？
答：Arrays 常用方法如下：
- Arrays.copyOf() 数组拷贝
- Arrays.asList() 数组转为 List 集合
- Arrays.fill() 数组赋值
- Arrays.sort() 数组排序
- Arrays.toString() 数组转字符串
- Arrays.binarySearch() 二分法查询元素
- Arrays.equals() 比较两个数组的值
10. 查询字符串数组中是否包含某个值有几种方法？
答：常见查询数组中是否包含某个值有以下两种方式：
- 方式一：Arrays.asList(array).contains("key");
- 方式二：Arrays.binarySearch(array, "key");
具体的实现代码如下：
String[] arr = {"doc", "pig", "cat"};
// 方式一：Arrays.asList(array).contains
boolean bool = Arrays.asList(arr).contains("cat");
System.out.println(bool);
// 方式二：Arrays.binarySearch
Arrays.sort(arr);
boolean bool2 = Arrays.binarySearch(arr, "cat") > -1;
System.out.println(bool2);
11. 如何修改数组的第三个到第五个元素的值为 6？
答：本题考察的知识点显然不是使用 for 循环修改那么简单，而是考察对 Arrays.fill() 方法的掌握，以下提供了两种实现方式可供参考。
方式一：for 循环方式
int[] arrInt = new int[10];
for (int i = 0; i < arrInt.length; i++) {
if (i >= 2 && i < 5) {
arrInt[i] = 6;
}
}
方式二：Arrays.fill() 方式
int[] arrInt = new int[10];
Arrays.fill(arrInt, 2, 5, 6);
总结
在 Java 中数组本质是引用类型，数组只能用来存储固定大小的同类型元素。在 Java 中很多集合的内部都是依赖数组实现的，如ArrayList 和HashMap等。数组的冒泡排序和选择排序也是面试常考的内容，很多公司会要求面试者手写冒泡排序。本文也介绍了数组、字符串和集合之间的相互转换，只有掌握好这些技能才能开发出更好的Java 程序。
发表于 2021-2-19 10:35
|
发表于 2021-2-20 19:16
