Java 基础面试300题 （261-290）

261.CompletableFuture.runAsync和CompletableFuture.supplyAsync方法有什么区别？

这两个方法都可用于异步运行代码。但两者之间有一些区别如下 ：

• runAsync不返回结果，返回的是一个CompletableFuture<Void>，另一方面 supplyAsync 从线程返回一个CompletableFuture<T>

• runAsync方法接受Runnable 为参数。另一方面，supplyAsync 接受Supplier 为参数。

• runAsync方法在单独的线程中执行Runnable 中的代码。另一方面，supplyAsync在单独的线程中执行Supplier提供的代码，并返回由 Supplier生成的值。

262.什么是模块？它们有什么好处？

一个模块由一组相关包组成。就像将一组相关类放入一个包中一样，可以将一组相关包放入一个模块中。模块提供以下几个好处：

• 如果应用程序有大量包，则很难跟踪。模块充当救援角色，它们有助于组织包，相关包可以分组到一个模块中。

• 模块可以自行部署， 有助于减小应用程序的大小。

• 模块提供更好的安全性。在模块之前，使类在其他包中可重用的唯一方法是将其公开。然而，这构成了一个安全问题，因为公共 类对每个人都开放，都可以访问。将包分组到模块中，确保无法在模块外访问该类。

• 由于Java 9之前没有模块，像rt.jar这样的Java API jar文件的非常大。有了模块后，Java 9将其拆分为更小的模块，这些小模块更易于测试和维护。

• 在Java 9之前，安全性一直是个问题，因为开发人员能够访问内部JDK文件。模块也有助于解决这个问题。模块增加了更多的访问控制，可以控制模块内哪些包在模块外可见和可访问。

263.模块描述符是什么？

模块描述符是一个名为module-info.java的Java文件。它包含有关模块的信息。它需要出现在模块的根部。以下代码行演示了模块描述符的结构：

module demomodule {
//optional directives
}

模块描述符可以包含一些可选指令， 下表是其中的指令：

指令	描述
Name	指定模块的名称。
exports	指定该模块中将对其他模块可用的包的名称。
requires	指定当前模块依赖的模块的名称。如果未指定这些模块，则当前模块可能无法正常工作。
provides	指定当前模块提供的服务。当一个模块作为服务提供者时，应使用此指令。
uses	指定当前模块消耗的服务。当模块是服务消费者时，应使用此指令。
open	指定当前模块中的类可以通过Java反射访问。

264. 包和模块有什么区别？

包和模块都是一个逻辑单元，都封装了一些Java文件。然而，两者之间存在以下几个差异：

包直接来自Java的早期版本。另一个模块则是在Java 9后增加的。

• 包可以避免名称冲突，它们允许在不同包中拥有相同名称的类。Java添加了模块，以模块化JDK并提高安全性。

• 一个包包含一组相关Java文件。另一方面，一个模块包含一组相关包。

• 包不需要描述符（元数据），模块需要一个名为module-info.java的模块描述符。

• 包不能自行部署；模块可以自行部署。

• 包中的类通过反射可见。除非在模块描述符中明确指定了open 指令，否则模块中的类无法通过反射可见。

265. Java 9对JDK有哪些主要改进？

Java 9利用模块的优点对JDK进行了一些根本性的更改。在Java 9之前，在安装JDK后，会创建一个名为jre\lib的文件夹， 其中包含所有核心的jar文件。安装Java 9时，不会再创建jre\lib文件夹，而是在JDK安装的根目录中创建了一个名为jmods 的文件夹。 该文件夹包含所有与核心Java文件相对应的模块。因此，JDK 9没有一个巨大rt.jar，而是一些单独的模块。

266. 如何将下面代码作为模块的一部分进行部署？

package mypackage;
public class MyClass {
public void doSomething() {
}
}

上面的代码定义了一个名为MyClass的类，位于 mypackage的包中。为了将上述代码作为模块的一部分部署，需要创建一个模块描述符，如下所示：

module mymodule {
exports mypackage;
}

上述模块描述符指定了一个名为mymodule的模块，使用exports将包mypackage导出, 表示mypackage可用于其他模块。

267. requires static 模块指令有什么作用？

requires static模块指令用于指定可选的依赖项，即在编译时需要但在运行时不需要的依赖项。假设已经开发了一个模块，并且需要一些第三方库，而最终用户永远不会需要这些库 。在这种情况下， 可以在定义模块时通过requires static指令指定第三方库， 在编译时需要这些库，运行时不需要它。

268.Java 9在Stream接口上做了哪些改进？

以下是Java 9在Stream接口上所做的一些改进：

• 增加了Stream.ofNullable()方法，用于创建一个值可能为空的流。 如果将非空值传递给此方法，它将创建一个流，否则创建一个空流。

• 增加了takeWhile和dropWhile方法，用于获取输入流的子集。

• 增加了 Stream.iterate()方法的重载版本，它接受谓词，并在谓词指定的条件为真时终止流。

269.下面的代码有效吗？如果没有，可以做些什么来修复它？

Stream<String> strStream = Stream.of(null);
strStream.forEach(str–> System.out.println(str));

上面的代码是有效的，不会导致任何编译错误。然而，执行时，会导致NullPointerException异常。这是因为无法使用Stream.of()方法创建具有空值的流。为了修复上述代码，需要进行以下更改：

Stream<String> strStream = Stream.ofNullable(null);
strStream.forEach(str–> System.out.println(str));

Java 9为流接口增加了ofNullable()方法 ，可用来创建具有null值的流。修改后的代码不会导致NullPointerException。

270.下面的代码片段有什么问题，如何修复？

List<Integer> numbers = List.of(5,10,15); //Line 1
numbers.add(20); //Line 2
System.out.println(numbers); //Line 3

Java 9为所有集合接口添加了一个of()静态方法,  用来创建一个无法修改的不可变集合。上面的代码使用此方法在第1行创建了一个整数列表。 第2行试图向该列表添加一个值，会导致运行异常，因为numbers是不可变的，不能够修改。为了修复上面的代码，需要按以下方式重写代码：

List<Integer> numbers = List.of(5,10,15,20); //Line 1
System.out.println(numbers); //Line 3

271. 可以使用Java 9的哪种方法创建字符串集合？

Java 9在Set接口中增加了一个of()静态工厂方法, 可用
来创建 字符串值的集合。如下代码所示：

Set<String> months = Set.of(“January”,”February”,”March”);

272. 下面代码片段的输出是什么？

Stream<Integer> oddNumbers = Stream.iterate(1, num–> num <= 20, num–> num+2);
oddNumbers.forEach(num–> System.out.print(num+” “));

在Java 9之前，Stream.iterate()方法用于创建一个无限 流。Java 9增加了该方法的一个重载版本，用于创建一个有限流 ， 这个重载接受一个额外的谓词参数， 并在谓词为真时立即停止流。因此，上述代码输出一个有限流如下：

1 3 5 7 9 11 13 15 17 19

273.Java 9对接口进行了哪些更改，为什么？

Java 9允许在接口中使用私有方法。在Java 8之前，接口只能有抽象方法。Java 8增加了对静态和默认接口方法的支持。默认和静态方法是带有方法主体的接口。Java 9更进一步，允许在接口中使用私有方法。私有接口方法允许重用代码。因此，如果一个接口有几个默认和静态方法，并且这些方法之间有一些通用代码，则该代码可以移动到私有方法。如下代码所示：

public interface Sample {
default method1(){
//some code
doSomething();
}
default method2(){
//some code
doSomething();
}
private void doSomething(){
System.out.println(“Doing something..”);
}
}

上述代码中，doSomething()是一个私有接口方法，在默认方法method1()和method2()中使用。

274.什么是JShell？

Jshell 上是一个命令行工具。允许编写和运行Java代码，而无需创建类文件。通过在命令窗口键入jshell来启动。 启动可以在其中键入任何Java代码，JShell将显示代码的执行结果。 例如，如果 键入以下内容：

System.out.println(“Hello World”);

JShell将打印文本“Hello World”

JShell为Java添加了REPL支持。REPL代表Read Evaluate Print Loop，Python等许多语言都提供REPL功能。

275. 下面代码片段的输出是什么？

Optional<Double> myDoubleOptional = Optional.of(10.0);
Optional<Double> defaultOptional = Optional.of(50.0);
double value = myDoubleOptional.or(()–> defaultOptional).get();
System.out.println(value);

Java 9在Optional类上增加了一个名为or() 的新方法， 该接受一个 Supplier<Optional> 函数接口为参数， 并返回一个Optional 。因此，如果调用它的可选项是非空的，则返回该可选项，否则它将返回一个新的Optional，该可选项由已传递的Supplier<Optional>参数生成。在上面的代码片段中，在myDoubleOptional上调用or方法，这是一个值为10的 Optional，因为是一个非空的可选项，or方法返回其值，而不是defaultOptional ，因此代码打印以下输出：

10.0

276.Java 9对try-with语句进行了哪些更改？

try-with语句是Java 7增加的， 它允许在没有明确关闭语句的情况下自动关闭资源。 例如，如果正在编写文件写代码，如果使用try-with语句，一旦try语句完成，FileWriter 会自动关闭。这样做的缺点是，需要自动关闭的资源必需是try语句的一部分。因此，如果资源在try-with语句之外声明，则需要作为try-with的一部分再次声明，比较繁琐。Java 9废除了这一限制。 使用Java 9， 可以在try-with语句之外声明的资源，并自动关闭。

277.Java 9在Optional类上增加的流方法有什么用处？

Java 9在Optional上增加的stream()方法可用于将Optional 转换为流。从而允许在Optional类上应用流的所有操作。如下代码示例 ：

Optional<String> str = Optional.of(“Hello”);
Stream<String> strStream = str.stream();

上述代码中， str是一个字符串类型的Optional ， 其值是 Hello ，然后使用stream()方法，将其转换为具有一个String 流。 现在所有流操作，如map、filter 等，都可以应用于此流。

278. ProcessHandle类的主要作用是什么？

Java 9增加了一个名为java.lang.ProcessHandle的新类，用于管理与操作系统相关的进程， 主要用途是方便与操作系统交互。该类的一些主要方法如下：

方法	描述
current()	这是一个静态方法，返回当前进程对应的 ProcessHandle 对象。
isAlive()	返回一个布尔值，指示进程是否存活。
pid()	返回进程的 ID。
children()	返回一个流，其中包含当前进程的子进程对应的 ProcessHandle 对象。

279. 补充下面代码中第1行， 使代码具有下面的预期输出 ？

Optional<Double> price = <code here>; //Line 1
price.ifPresentOrElse(val–> System.out.println(“Price is not null”), ()–> System.out.println(“Price not specified”));

预期输出：

Price not specified

上面的代码使用了Java 9在Optional类上新增的ifPresentOrElse()方法。该此方法接受Consumer实例和Runnable 实例为参数。如果Optional中存在值 ，则调用传入的 Consumer对其进行处理 ， 否则 ，它将执行传入Runnable 代码。对于上述情况，因为需要打印未指定价格的输出。与此对应的打印语句应在Runnable参数中指定，price应该是为空的Optional 。 因此，第1行代码需要补充如下：

Optional<Double> price = Optional.empty();

280.Java 9引入的新HttpClient有什么优势？

Java 9引入了一个新的HttpClient类 ，用于通过Java代码发出HTTP请求。在Java 9之前，UrlConnection和HttpUrlConnection类也可用于发出HTTP请求。与这些类相比，新的Java HttpClient有下面几个优势：

• HttpUrlConnection仅支持HTTP 1.1，这是一个非常古老的HTTP版本。HttpClient 则支持 Http 2.0，是HTTP的最新版本。

• 与通过HttpUrlConnection编写的代码相比， HttpClient编写的代码要干净得多。

• HttpClient通过CompletableFuture支持异步处理，它有一个名为sendAsync的方法，可以异步发送HTTP请求， 并返回一个CompletableFuture，可用于在请求完成后立即获取响应。

281.解释Java泛型。

Java 范型允许创建仅接受特定类型数据的集合，避免类型转换。泛型的另一个优点是， 可以创建适用于不同数据类型的通用算法或方法，而无需为每个数据类型单独编程。

List<String> listGen = new ArrayList<String>();  // 定义ArrayList以存储字符串对象.
listGen.add("hello");  // 增加一个字符串
String strGen = listGen.get(0);  // ArrayList是字符串类型列表 ，因此不需要类型转换.

在上述代码中，如果增加以下行，会出现编译错误：

listGen.add(21); // 编译错误，因为21不是字符串

282. 编写一个程序来解释范型方法。

下面程序展示了如何定义一个范型方法：

public class exampleForGenericMethod{  
public static <E> void printArrayElements(E[] elementsVal) {
for ( E elementVal : elementsVal){ 
System.out.println(elementVal); 
} 
System.out.println(); 
} 
public static void main( String abcs[] ) {  
Integer[] myIntArray = { 15, 25, 35, 45, 55 };  
Character[] myCharArray = { 'H', 'E', 'L', 'L', 'O','W','O','R','L','D' }; 
System.out.println( "The Integer Array is:" ); 
printArrayElements (myIntArray  ); 
System.out.println( "The Character Array is: " ); 
printArrayElements ( myCharArray ); 
} 
} 

上面代码使用了Java范型方法，避免了方法重载，既可以打印整数数组，也可以打印字符串数组。

283. List<? extends T> 和 List <? super T>有什么区别？

Java范型中，符号?是一种类型通配符，表示任何类型。? extends T意味着List 将接受任何扩展T的类型,也就是T的子类对象。 ? super T 意味着 List 将接受这样一些类型的对象，它们是T的任何超级类。

284. 解释以下代码：

案例 1:

List listORTExample = new ArrayList(); // Line 1
listORTExample.add("abc");  // Line 2
listORTExample.add(123);  // Line 3
String strItem = (String) listORTExample.get(0); // Line 4
strItem = (String) listORTExample.get(1); // Line 5

案例 2:

List<String> listOSExample = new ArrayList(); // Line 6
listOSExample.add("abcd");  // Line 7
listOSExample.add(1234); // Line 8
strItem = listOSExample.get(0); // Line 9

第3行- 编译没有问题，但运行时将抛出异常。

第4行-必须要显式转换，因为列表元素类型显示声明为字符串。

第5行-将抛出ClassCastException，因为Integer类型无法转换为String类型

第8行- 编译时出现错误，因为列表使用了范型声明为字符串列表

第9行-因为列表已经声明为字符串列表，因此不需要显式转换

上述两段代码时使用Java范型如何改进程序的经典示例。

285. 什么是泛型中的类型参数？

类型参数是参数类型的占位符。类型参数可用于方法的参数和方法的返回类型， 以及类型转换中的目标类型和参数化方法的开放类型参数。类型参数不能用于创建对象、数组或异常处理。它不能是静态的，也不能与instanceOf运算符一起使用。它不能用作超类型或类的字面量。

Java有5种类型的类型参数。通常遵守如下约定：

T表示一种类型

E表示一种（集合中）元素（类型）

K表示键（类型）

N表示数值（类型）

V表示值（类型）

286. 从集合中检索元素时如何避免类型转换?

使用范型集合可以避免类型转换。举例如下:

List<String> gList = new ArrayList<String>();
gList.add("str1");
gList.add("str2");
String g0 =  gList.get(0);   //无需类型转换

287. 下面代码会编译吗？能否正确运行?

public static void main(String[] args) {
List<String> typeSafeList = newArrayList<String>();
typeSafeList.add(new String("string1"));
addElementsToList(typeSafeList);
String a = typeSafeList.get(1);
}
private static void addElementsToList(List list){
list.add(new Integer(10));
} 

代码编译没有问题，但运行会出现如下类型转换错误：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

288.在范型声明中可以使用多个参数化类型吗？

可以。如下示例：

public class UseTwo<T, X> { }

289. 如何定义泛型方法？

定义范型方法的语法有点棘手，需要在返回类型前声明范型参数。下面是一个示例：

public  <T>  void makeList(T t) { }

289.可以实例化一个范型数组吗？

可以声明范型数组，但不能像普通数组一样实例化 。否则会编译错误，因为编译器在编译过程中还不知道数组的类型。 它必须使用 new 操作符和类型转换为数组进行实例化。

//声明并初始化范型数组
arrType<String> [] abc = new arrType[50];//下面代码错误
arrType2<xyz> [] abc = new arrType<xyz>[50];

290.什么是对象序列化？ 如何实现序列化 ？

对象序列化是将对象的属性和行为写入字节流或文件， 对象中引用的的所有可序列化对象也都写入文件中， 序列化操作保存了对象的瞬时状态 。当对象必须通过网络发送时，通常会使用序列化。如果类实现了Externalizable接口或者Serializable接口 ，其对象便是可序列化的。前者必须实现readExternal()和writeExternal() 方法,后者是一个标记接口，没有定义任何方法。 序列化的具体过程是，对象可以传递给ObjectOutputStream，而ObjectOutputStream又将其传递给文件输出流。 。