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()
方法返回该值。因此,代码最终打印以下输出:
200
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()));