当前位置：首页 > news >正文

Java 基础面试300题（231-260）

news 2025/6/24 15:03:47

Java 基础面试300题（231-260）

231 `String::toUpperCase`是什么类型的方法引用？

String::toUpperCase是任意方法引用的示例。它指的是String 类的toUpperCase方法，但不是指任何特定对象。通常在遍历集合或流时使用。例如，假设想将列表的所有元素转换为大写。可以使用此String::toUppercase，如下所示：

List<String> colours = Arrays.asList(“Red”,”Blue”,”Green”);
List<String> upperCaseColours =
colours.stream().map(String::toUpperCase).collect(Collectors.toList());

232. 以下代码片段有什么问题？如何修复？

LocalDate date1 = LocalDate.of(2018, 7, 24);
LocalTime time1 = date1.atTime(5, 30);

上面的代码片段首先创建一个名为date1的LocalDate，然后在date1上调用atTime（）方法，并将结果分配给名为time1的LocalTime对象，atTime()方法将当前时间对象中的日期与指定的时间相结合，返回一个LocalDateTime对象而不是LocalTime对象，因而上述代码会出现编译错误。按如下方式修改即可修复错误：

LocalDateTime time1 = date1.atTime(5, 30);

233.有哪些方式创建`LocalDate`？。

LocalDate类有几个静态方法用于创建LocalDate ：

LocalDate.now() 方法：该方法创建与当前日期对应的LocalDate ，如下代码所示：

LocalDate date1 = LocalDate.now();

LocalDate.of()方法: 该方法创建与指定年份、月份和日期相对应的LocalDate ，如下代码所示：

LocalDate date2 = LocalDate.of(2018, 7, 24);

LocalDate.parse()方法：该方法创建与字符串表示的日期对应的LocalDate可用于此，如下代码所示：

LocalDate date3 = LocalDate.parse(“2014–08–11”);

234.如何检查一个日期是否在另一个日期之前？

LocalDate类有一个名为isBefore()的方法，可以用它来检查一个日期是否在另一个日期之前，如下代码所示：

LocalDate date1 = LocalDate.of(2018, 7, 24);
LocalDate date2 = LocalDate.parse(“2014–08–11”);
boolean isBefore = date1.isBefore(date2);
System.out.println(“isBefore：”+isBefore);

上述代码创建两个日期对象，date1和date2，在date1上以date2为参数调用isBefore()方法，由于date1在date2之后，所以isBefore()方法返回false。因此代码输出如下：

isBefore：false

235. 解释`ZonedDateTime`类。

ZonedDateTime类表示日期和时间，该日期和时间也具有时区信息。因此，除了年、月、日、小时、分钟、秒和纳秒组件外，它还有一个ZoneId组件。ZoneId 是java.time.ZoneId的实例，表示时区。大约有40个时区可以通过ZoneID表示。下面代码显示了如何创建ZonedDateTime：

ZoneId zoneId = ZoneId.of(“Asia/Kolkata”);
ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);

上述代码片段首先创建一个与Asia/Kolkata对应的时区，也就是IST时区。然后，它创建一个ZonedDateTime，该时间与系统时钟的当前时间相对应，但具有此时区的ID。

236.以下代码片段的输出是什么？

LocalTime localTime = LocalTime.of(7, 15);
System.out.println(localTime.minusMinutes(30));

上述代码创建一个LocalTime实例。LocalTime表示具有小时、分钟、秒和纳秒成分的时间。在这里，创建一个对应于7-15(7小时，15分钟）的LocalTime对象，然后调用minusMinutes（）方法减去 30分钟,。从7-15减去30分钟后，时间是6-45，因此代码打印如下输出：

06–45

237.如何获取与日期相对应的星期几？

LocalDate 类有一个名为getDayOfWeek()的方法，可以使用它获取与日期对应的星期几，如以下代码所示：

LocalDate date = LocalDate.parse(“2017–04–25”);
System.out.println(date.getDayOfWeek());

上述代码创建一个对应于2017年4月25日的LocalDate，然后在此日期对象上调用getDayOfWeek（）方法，该方法返回一个名为DayOfWeek的枚举，表示一周中的每一天。由于2017年4月25日对应于星期二，因此getDayOfWeek方法返回对应于星期二的枚举值。因此代码将打印如下所示的输出：

TUESDAY

238. `Period`和`Duration`类之间有什么区别？

Period 和Duration都是DateTime API引入的类，表示一段持续的时间，或者时间间隔。两者之间有如下一些区别：
Period表示以年、月和天为单位的时间间隔,而 Duration 表示以秒和纳秒为单位的时间间隔。
Period用于测量两个LocalDate对象之间的时间间隔, 而，Duration用于测量两个LocalTime对象之间的时间间隔。
Duration通常用于测量较长的时间间隔，而Duration 用于测量较短的时间间隔。

239. 如何从`yyyy/mm/dd`格式表示的字符串日期中获得对应的`LocalDate`对象？

LocalDate有一个静态parse()方法，可用于将字符串日期转换为LocalDate对象。parse()方法默认接受yyyy-MM-dd格式。对于本例场景，日期的格式是 yyyy/MM/dd ，因此不能够直接使用parse()方法，而应使用 parse()方法的重载版本。重栽版本可以接受DateTimeFormatter实例，而该实例可以通过其静态DateTimeFormatter.ofPattern()方法创建。以下代码演示了如何将yyyy/mm/dd格式的字符串日期转换为LocalDate：

String strDate = “2012/10/11”;
LocalDate date = LocalDate.
parse(strDate, DateTimeFormatter. ofPattern(“yyyy/MM/dd”));
System.out.println(date);

因此，上述代码将打印如下输出：

2012–10–11

240.以下代码片段的输出是什么？

LocalDateTime dateTime = LocalDateTime.parse(“2014–12–28T08–45–00”);
dateTime = dateTime.withYear(1998);
System.out.println(dateTime);

上面的代码创建一个LocalDateTime实例，它调用dateTime.withYear()方法，此方法更新LocalDateTime 的年份组件，将其设置为指定年份。在上述情况下，它将dateTime的年份设置为1998。因此，代码最终打印输出如下：

1998–12–28T08–45

241 如何判断`LocalDate`是否是闰年？

LocalDate类有一个名为isLeapYear()的方法，用于检查一年是否是闰年，如下代码所示：

LocalDate date1 = LocalDate.of(2020, 7, 24);
boolean isLeapYear = date1.isLeapYear();

上述代码创建一个名为date1的LocalDate对象，然后调用isLeapYear()方法, 该方法返回一个布尔值，表示是否是润年。在上述情况下，由于date1的年份是2020年，即闰年，因此isLeapYear()方法将返回true。

242.什么是静态接口方法和默认接口方法？

在Java 8之前，接口只能有抽象方法，它们没有方法体，不能够有具体的实现代码。Java 8则允许接口具有静态方法和默认方法，它们不是抽象的方法，它们有方法体，有具体的实现代码。主要出于下面原因：

默认接口方法有助于保持代码向后兼容。在Java 8之前，如果将新方法添加到接口中，则需要修改所有实现该接口的类。默认方法克服了这一限制，它们允许在接口中添加带有方法主体的方法。所有实现类都不需要修改而使用默认的方法。
静态接口方法有助于将实用程序方法组合在一起。静态接口方法无法在实现该方法的类中重写。可避免由于接口的不正确实现而导致的不良结果，并提供了额外的安全级别。

243.抽象类和Java 8之后的接口有什么区别？

Java 8的增加的默认接口方法的减少了抽象类和接口之间的区别。在Java 8之前，接口不可能有具体的方法。然而，Java 8在接口中增加了默认和静态方法，这些方法都有方法主体，是具体的实现。从而减少了抽象类和接口之间的区别。然而，两者之间有下面一些区别：

抽象类可以有实例字段，因而具有状态，而接口不能有实例字段，也不能有状态。
抽象类可以有一个构造函数，并且可以实例化。而接口不能有构造函数。

244.编写一个演示默认方法的代码示例。

默认接口方法是一个在接口定义中具有方法主体的方法，并用default关键字说明。如下代码所示：

public interface MyInterface {
public void doSomething();
public default void doSomethingElse() {
System.out.println(“Doing something else....”);
}
}

上述代码声明了一个名为MyInterface的接口，它有一个名为doSomething()的抽象方法和一个名为doSomethingElse()的默认方法，在其方法主体中简单打印了一些信息。

245.静态方法和默认方法有什么区别？

静态方法和默认方法都有一个方法主体。两者之间有一些如下区别：

静态方法用static关键字说明，而默认方法用 default关键字活吗说明。
默认接口方法可以重写，静态接口方法不能够重写。
默认接口方法可以通过实现接口的类的对象来调用，静态接口方法不能通过实现接口的类的类的对象调用。它们需要通过接口名称调用。

246.下面代码片段中有什么错误？如何修复？

public interface MyInterface {
public static void doSomething() {
System.out.println(“Doing something....”);
}
}
public class MyClass implements MyInterface{
public static void main(String args[]) {
MyClass obj = new MyClass();
obj.doSomething(); //Line 1
}
}

上面代码定义了一个名为MyInterface的接口，它有一个名为doSomething()的静态方法，然后创建一个名为MyClass的类，该类实现了MyInterface。MyClass的主方法创建了一个名为obj 的MyClass的对象，并在第1行调用doSomething（）方法。导致第1行出现编译错误。因为不能通过类的对象访问静态接口方法，只能通过接口名称访问。为了修复错误，第1行代码需要替换如下：

MyInterface.doSomething();

247.什么是`Optional` ，为什么它是由Java 8添加的？

Optional是Java 8新增加的一个类，用于表示可以存在或不存在的值（可以认为它是一个值的容器，该值可能为空），它有一些检索底层（容器中的）值是否存在的方法。如下代码演示了一个Optional：

Optional<Integer> number;

其中，number是类型为Integer 的可选项，可能包含也可能不包含一个值。

使用Optional，可以避免与空值检查相关的样板代码。有时，一个方法可能会返回一个null。这可能会导致NullPointerException，为了避免此类异常，调用该方法的代码需要有明确的空值检查，代码因此难以阅读。Java 8的Optional有助于避免这类板代码。

248.有哪些方式创建`Optional`？

Optional类上有一些静态方法用于创建Optional 实例。主要有下面几种方式：

Optional.isEmpty()方法: 该方法创建一个空的Optional，如下代码所示：

Optional<Integer> number = Optional.empty();

Optional.of()方法：该方法创建一个具有特定值的Optional ，如下代码所示：

Optional<Integer> number = Optional.of(10); //creates Optional with the value 10

Optional.ofNullable()方法：该方法会创建一个可能是空值或非空值的Optional ，如下代码所示：

Optional<Integer> number = Optional.ofNullable(10); //creates Optional with the value 10Optional<Integer> number1 = Optional.ofNullable(null);

249.解释`Optional.ifPresent`方法。

Optional.ifPresent方法对Optional中的值执行某种操作，如果值存在的话。具体要执行的操作是一个Consumer函数接口的实例，因而可以用lambda表达式实现。如果Optional中没有值，它不会做任何事情。如下代码所示：

Optional<String> strOptional = Optional.of(“Test”);
strOptional.ifPresent(str–> System.out.println(str.toUpperCase()));

上述代码创建一个可选的strOptional，其中的值是Test。然后调用 ifPresent方法，使用lambda表达式作为其参数，该表达式Optional中的值转换为大写并在控制台输出。因此，此代码打印以下输出：

TEST

250.`orElse`和`orElseThrow`方法有什么区别？

orElse()和orElseThrow()都是Optional类上的方法。如果Optional中的值存在，两个方法都返回该值。当值不存在时，两个方法的处理方式有所不同。

orElse()方法接受一个值作为参数，如果Optional中的值不存，则返回此参数值。如下代码所示：

Optional<String> strOptional1 = Optional.empty();
String strValue1 = strOptional1.
orElse(“Default”);

在这里，由于strOptional1是空的Optional，因此orElse()方法返回Default

如果在空的Optional上调用 orElseThrow()方法会抛出异常。j具体抛出的什么异常由其函数参数决定。如下代码示例：

Optional<String> strOptional2 = Optional.empty();
String strValue2 = strOptional1.orElseThrow(()–> new IllegalArgumentException());

上述代码中，由于strOptional2是一个空的Optional，因此orElseThrow()方法抛出一个IllegalArgumentException

251.以下代码片段的输出是什么？

Optional<Integer> opInt1 = Optional.of(200); //Line 1
Optional<Integer> opInt2 = opInt1.filter(num–> num > 100); //Line 2
System.out.println(opInt2.get()); //Line 3

Optional 类有一个名为filter()的方法，它接受一个谓词Predictate为参数，并将谓词应用于可选值（如果存在的话）。如果谓词中的条件满足，则返回可选值，否则返回空的可选值。在上述情形，第1行创建一个值为200的整数类型的Optional ，第2行调用filter()方法，检查其中的值是否大于100，因为这是真的，所以filter()方法返回原值，并将值分配给opInt2 ，第3行中调用get()方法返回该值。因此，代码最终打印以下输出：

252. `forEach`方法如何工作？

Java 8 为Iterable接口添加了一个新的默认方法forEach ，java.util.Collection 接口扩展了Iterable 接口，因此forEach 可用于所有集合类，这个方法有助于在没有显式循环的情况下通过集合进行内部遍历。如下代码示例：

List<String> colours = Arrays.asList(“Red”,”Blue”,”Black”,”White”);
colours.forEach(str–> System.out.println(str));

上述代码声明一个名为colours的字符串列表，然后在此列表中调用forEach()方法，这个方法接受一个Consumer 函数实际例。在上述情况下，Consumer通过lambda表达式实现，其主体逻辑是仅打印传递给它的值。因此，此代码将打印以下输出：

Red
Blue
Black
White

253.Java 8在`List` 接口上有哪些改进？

Java 8在列表接口中增加了以下一些方法：

List.sort：该方法用于对列表进行排序。它接受一个Comparator 为参数，并据此对输入列表进行排序

List.replaceAll：该方法用于替换列表中的所有值。它接受一个UnaryOperator函数接口参数，该接口接受特定数据类型的输入（列表中的数据元素），并返回相同数据类型的结果（替换操作）。replaceAll()方法将UnaryOperator应用于列表中的每个元素。

254.`Map.getOrDefault`方法是如何工作的？

Java 8为Map接口增加了一个getOrDefault方法，该方法接受一个键，并在Map中按键检索值。如果值存在，返回值，否则，返回传递的默认值。如下代码示例：

Map<Integer, String> fruits = new HashMap<Integer, String>();
fruits.put(1,”Apple”);
fruits.put(2,”Orange”);
String fruit1 = fruits.getOrDefault(1,”Mango”); //returns apple
String fruit2 = fruits.getOrDefault(3,”Mango”); //returns mango

255.以面代码片段的输出是什么？

Map<Integer, String> fruits = new HashMap<Integer, String>();
fruits.put(1,”Apple”);
fruits.put(2,”Orange”);
fruits.put(3,”Strawberry”);
fruits.replace(1, “Mango”); //Line 1
fruits.replace(2, “Orange”,”Banana”); //Line 2
fruits.replace(3, “Blackberry”,”Pineapple”); //Line 3
System.out.println(fruits.get(1));
System.out.println(fruits.get(2));
System.out.println(fruits.get(3));

Map.replace（key,value)方法仅在Map 的键值对存在时才会替换值。在上面的示例中，键1映射到Apple值，因此replace()方法将Apple值替换为Mango ，键2映射到值Orange ，第2行的替换方法也将值Orange替换为值Banana ，键3映射到值Strawberry，第3行的替换方法不会生效，因为键3没有映射到Blackberry。所以最后代码打印以下输出：

Mango
Banana
Strawberry

256. `Iterator`和`SplitIterator`之间有什么区别？

Iterator和SplitIterator都可用于遍历集合中的元素，然而，这些接口之间有如下一些区别：

Iterator接口来自早期版本的Java。SplitIterator是Java 8新增加的接口。
Iterator接口仅支持顺序处理。SplitIterator既支持顺序又支持并行处理。
Iterator可用于遍历集合，SplitIterator可用于遍历集合和流。
Iterator仅允许遍历集合中的单个元素。另一方面，SplitIterator可以遍历集合中单个元素和多个元素。

257.相比 `Future`接口 ,`CompletableFuture`类有什么优势？

在Java 8之前，Java有Callable类和Future接口，它门可用于返回异步计算的结果。 Future 接口有一些非常显著的问题， CompletableFuture类则克服了所有这些问题。

Future 无法手动完成，如果任务被挂起，则没有办法手动完成。另一方面，CompletableFuture有一个名为complete()的方法，允许手动完成任务。
Future有一个 get()方法，返回计算结果。然而它会阻止塞，直到结果可用。因此，如果想对Future的结果进行任何进一步计算，需要一直等待结果可用。另一方面 CompletableFuture 允许将回调附加到计算结果。一旦结果可用，这些回调就会立即执行而无需等待。
Future接口没有任何异常处理机制。另一方面，CompletableFuture 有一个exceptionally() 方法，允许在发生异常时运行备用代码。

258. `StringJoiner`类的作用是什么？

StringJoiner是Java 8新增加的类，用于连接由分隔符分隔并具有前缀和后缀的字符串。如下代码演示了StringJoiner的功能和用法：

StringJoiner strJoiner = new StringJoiner(“:”,”[“,”]”); //Line 1
strJoiner.add(“cat”); //Line 2
strJoiner.add(“dog”); //Line 3
strJoiner.add(“mouse”); //Line 4
System.out.println(strJoiner); //Line 5

上述代码创建一个StringJoiner，它使用冒号 : 作为分隔符，方括号[] 分别作为前缀和后缀。然后，调用其add()方法增加几个字符串。代码打印输出如下：

[cat:dog:mouse]

259. `Comparator.reversed`和`Comparator.reverseOrder` 这两个方法有什么区别？

这两个方法都是Java 8为接口Comparator接口增加的新方法。两者都用于以相反的顺序对Collection 进行排序。但两者之间有如下一些区别：

Comparator.reversed 是默认方法，而Comparator.reverseOrder是静态方法。
Comparator.reversed需要一个Comparator 实例存在。它根据当前比较器生成一个反向排序的比较器并返回。Comparator.reverseOrder是静态方法，它不需要Comparator实例存在，它直接返回一个按相反顺序排序的Comparator。
The Comparator.reversed返回一个比较器，该比较器与调用它的比较器的排序方向相反。另一方面，Comparator.reverseOrder返回一个比较器，该比较器与集合中元素的自然顺序相反。

260. 下面代码片段中有什么错误？如何修复？

public class Employee {
private String name;
private double salary;
//constructor, getters and setters
}
List<Employee> employees = new ArrayList<Employee>();
employees.add(new Employee(“A”,10000));
employees.add(new Employee(“B”,5000.50));
employees.add(new Employee(“C”,15000));
employees.sort(Comparator.comparingInt(employee–> employee.getSalary())); //Line 1

上述代码第1行的 lambda表达式返回了双精度类型工资额salary ，与comparingInt方法需要的类型不一致，这会导致编译错误，为修复错误，按如下方式修改：

employees.sort(Comparator.comparingDouble(employee–> employee.getSalary()));