Java SE 8面试必备问题与答案详解（第二部分）：2023最新Java开发者通关指南
在我之前的帖子中，我已经讨论了一些重要的Java SE 8面试问题和答案。在这篇帖子中，我们将讨论更多关于Java SE 8的面试问题和答案。在阅读本文之前，请先阅读我之前的帖子：“Java SE 8面试问题（第一部分）”。
Java SE 8面试问题
-
Java SE 8中的内部迭代是什么？
- Java SE 8中的内部迭代是什么？
-
- 外部迭代和内部迭代的区别是什么？
-
- 外部迭代的主要缺点是什么？
-
- 相较于外部迭代，内部迭代的主要优势是什么？
-
- 内部迭代相对于外部迭代的主要缺点是什么？
-
- 外部迭代相对于内部迭代的主要优势是什么？
-
- 何时需要使用内部迭代？何时需要使用外部迭代？
-
- Java 8的Stream API中的中间操作和终端操作有什么区别？
-
- 在Java接口中是否可以提供方法实现？如果可以，应该如何提供实现？
-
- 什么是默认方法？为什么我们需要Java 8接口中的默认方法？
-
- 什么是静态方法？为什么我们需要Java 8接口中的静态方法？
-
- 函数式编程和面向对象编程之间的区别是什么？
-
- 解释一下旧的Java日期API存在的问题？Java 8的日期和时间API相较于旧的日期API和Joda Time API有什么优势？
-
- 为什么我们需要在Java SE 8中引入新的日期和时间API？解释一下Java SE 8日期和时间API如何解决旧的Java日期API存在的问题？
-
- Java的旧日期API和Java 8的日期和时间API之间的区别是什么？
-
- 什么是多重继承？Java 8如何支持多重继承？
- 由于默认方法，接口中的钻石问题是什么？Java 8是如何解决这个问题的？
Java SE 8面试问题与回答
在Java SE 8中，什么是内部迭代？在Java 8之前，我们没有”内部迭代”的概念。Java 8引入了一个新特性，称为”内部迭代”。在Java 8之前，Java语言只有”外部迭代”来迭代聚合对象（如集合、数组等）的元素。”内部迭代”指的是”通过Java API内部逐一迭代聚合对象的元素”。与Java应用程序外部迭代不同，我们要求Java API在内部执行此任务。
外部迭代和内部迭代之间的区别是什么？
S.No.
External Iteration
Internal Iteration
1.
Available before Java 8 too.
It is introduced in Java SE 8
2.
Iterating an Aggregated Object elements externally.
Iterating an Aggregated Object elements internally (background).
3.
Iterate elements by using for-each loop and Iterators like Enumeration, Iterator, ListIterator.
Iterate elements by using Java API like “forEach” method.
4.
Iterating elements in Sequential and In-Order only.
Not required to iterate elements in Sequential order.
5.
It follows OOP approach that is Imperative Style.
It follows Functional Programming approach that is Declarative Style.
6.
It does NOT separate responsibilities properly that is, it defines both “What is to be done” and “How it is to be done”.
It defines only “What is to be done”. No need to worry about “How it is to be done”. Java API takes care about “How to do”.
7.
Less Readable Code.
More Readable code.
外部迭代的主要缺点是什么？外部迭代具有以下缺点：
- We need to write code in Imperative Style.
- There is no clear separation of Responsibilities. Tightly-Coupling between “What is to be done” and “How it is to be done” code.
- Less Readable Code.
- More Verbose and Boilerplate code.
- We have to iterate elements in Sequential order only.
- It does not support Concurrency and Parallelism properly.
内部迭代比外部迭代有哪些主要优势？与外部迭代相比，内部迭代具有以下优势：
- As it follows Functional Programming style, we can write Declarative Code.
- More Readable and concise code.
- Avoids writing Verbose and Boilerplate code
- No need to iterate elements in Sequential order.
- It supports Concurrency and Parallelism properly.
- We can write Parallel code to improve application performance.
- Clear separation of Responsibilities. Loosely-Coupling between “What is to be done” and “How it is to be done” code.
- We need to write code only about “What is to be done” and Java API takes care about “How it is to be done” code.
内部迭代相对于外部迭代的主要缺点是什么？与外部迭代相比，内部迭代有一个主要的缺点:
- In Internal Iteration, as Java API takes care about Iterating elements internally, we do NOT have control over Iteration.
外部迭代相较于内部迭代的主要优势是什么？与内部迭代相比，外部迭代有一个主要的优势。
- In External Iteration, as Java API does NOT take care about Iterating elements, we have much control over Iteration.
我们何时需要使用内部迭代？我们何时需要使用外部迭代？
这是文章《Java SE 8 面试问题与答案（第二部分）》的第2部分（共3部分）。
内容片段: 我们需要了解使用内部迭代或外部迭代的情况。
- 当我们需要对迭代进行更多控制时，可以使用外部迭代。
- 当我们不需要对迭代进行更多控制时，可以使用内部迭代。
- 当我们需要开发高并发和并行应用程序时，应该使用内部迭代。
Java 8的Stream API中中间操作和终端操作有什么区别？
序号
Stream中间操作
Stream终端操作
1.
Stream中间操作在我们将其与Stream终端操作链接之前不会被评估。
Stream终端操作是独立评估的，不需要其他操作的帮助。
2.
中间操作的输出是另一个Stream。
终端操作的输出不是Stream，而是Stream之外的其他内容。
3.
中间操作是惰性评估的。
终端操作是即时评估的。
4.
我们可以链接任意数量的Stream中间操作。
我们不能链接Stream终端操作。
5.
每个语句中我们可以使用任意数量的Stream中间操作。
每个语句中我们只能使用一个Stream终端操作。
在Java接口中是否可以提供方法实现？如果可以，应该如何提供？
在Java 7或以前的版本中，接口无法提供方法实现。但在Java 8及以后的版本中，可以实现这一功能。在Java SE 8中，我们可以通过使用以下两个新概念来在接口中提供方法实现：
- 默认方法（Default Methods）
- 静态方法（Static Methods）
什么是默认方法？为什么我们需要在Java 8接口中使用默认方法？
默认方法是在接口中使用”default”关键字实现的方法。它是在Java SE 8中引入的新功能。我们需要默认方法的原因如下：
- 它允许我们在接口中提供方法的实现。
- 在不破坏实现该接口的类的情况下，向接口添加新功能。
- 提供优雅的向后兼容性功能。
- 便于扩展现有功能。
- 便于维护现有功能。
什么是静态方法？为什么我们需要在Java 8接口中使用静态方法？
静态方法是一种实用方法或助手方法，与类（或接口）相关联。它不与任何对象相关联。我们需要静态方法的原因有以下几点：
- 我们可以将与特定接口相关的辅助或实用方法保留在同一接口中，而不是放在单独的实用类中。
- 我们不需要像Collections、Arrays等单独的实用类来保存实用方法。
- 职责的清晰分离。也就是说，我们不需要一个实用类来保存Collection API的所有实用方法，如Collections等。
- 便于扩展API。
- 便于维护API。
函数式编程和面向对象编程有什么区别？
函数式编程
面向对象编程
不存在状态
存在状态
使用不可变数据
使用可变数据
遵循声明式编程模型
遵循命令式编程模型
无状态编程模型
有状态编程模型
主要关注：”你在做什么”
主要关注：”你如何做”
适合并行（并发）编程
不适合并行（并发）编程
适合大数据处理和分析
不适合大数据处理和分析
支持纯封装
破坏封装概念
函数无副作用
方法有副作用
函数是一等公民
对象是一等公民
主要操作单元是”函数”
主要操作单元是对象（类的实例）
流控制：函数调用，带递归的函数调用
流控制：循环，条件语句
使用”递归”概念来迭代集合数据。
使用”循环”概念来迭代集合数据。例如：Java中的for-each循环
执行顺序的重要性较低。
执行顺序是必须且非常重要的。
同时支持”数据抽象”和”行为抽象”。
仅支持”数据抽象”。
当我们有少量事物和更多操作时，我们使用函数式编程。
当我们有少量操作和更多事物时，我们使用面向对象编程。例如：在Java中，事物是类，操作是方法。
请阅读我之前的帖子：”比较FP，OOP（IP）”以了解有关FP，IP和OOP的更多信息。
请解释一下旧的Java Date API存在哪些问题？相较于旧的Date API和Joda Time API，Java 8的Date and Time API有哪些优势？
Java的旧日期API是指Java SE 8之前可用的日期API，例如Date、Calendar、SimpleDateFormat等。与Java 8的日期和时间API以及Joda Time API相比，Java的旧日期API存在以下问题或缺点。
- Most of the API is deprecated.
- Less Readability.
- java.util.Date is Mutable and not Thread-Safe.
- java.text.SimpleDateFormat is not Thread-Safe.
- Less Performance.
与Java的旧日期API相比，Java SE 8的日期和时间API具有以下优势。
- Very simple to use.
- Human Readable Syntax that is More Readability.
- All API is Thread-Safe.
- Better Performance.
为什么我们需要Java SE 8中的新日期和时间API？请解释一下Java SE 8日期和时间API如何解决旧的Java日期API的问题。我们需要Java 8的日期和时间API来开发高性能、线程安全和高可扩展的Java应用程序。Java 8的日期和时间API通过遵循不可变性和线程安全原则解决了所有旧的Java日期API的问题。
Java的旧Java日期API和Java 8的日期和时间API有什么区别？Java的旧日期API和Java 8的日期和时间API之间的区别。
S.No.
Java’s OLD Java Date API
Java 8’s Date and Time API
1.
Available before Java 8 too.
It is introduced in Java SE 8
2.
Not Thread Safe.
Thread Safe.
3.
Mutable API.
Immutable API.
4.
Less Performance.
Better Performance.
5.
Less Readability.
More Readability.
6.
It’s not recommended to use as its deprecated.
It’s always recommended to use.
7.
Not Extendable.
Easy to Extend.
8.
It defines months values from 0 to 11, that is January = 0.
It defines months values from 1 to 12, that is January = 1.
9.
It’s an old API.
It’s a new API.
多重继承是什么？Java 8 如何支持多重继承？多重继承意味着一个类可以从多个父类继承或扩展特性和功能。在Java 7或之前的版本中，多重继承是不可能的，因为Java遵循“一个类只能继承一个类或抽象类”的规则。然而，通过使用接口，可以实现多重实现继承，因为Java遵循“一个类可以继承任意数量的接口”的规则。然而，Java 8通过引入新特性“接口中的默认方法”来支持“在接口中实现方法”。由于这个特性，Java 8支持有一些限制的多重继承。
默认方法在接口中导致的钻石问题是什么？Java 8是如何解决这个问题的？
interface A {
default void display() {
System.out.println("A");
}
}
interface B extends A {
default void display() {
System.out.println("B");
}
}
interface C extends A {
default void display() {
System.out.println("C");
}
}
class D implements B, C {
}
在上面的代码片段中，类D出现编译时错误，错误信息为“从类型C和B继承的display()方法存在重复的默认方法，参数为()和()”。这是因为Java编译器在类D中对于使用哪个display()方法感到困惑。类D从接口B和C中都继承了display()方法。为了解决这个问题，Java 8提供了以下解决方案。
class D implements B, C {
@Override
public void display() {
B.super.display();
}
}
这个B.super.display();将解决这个钻石问题。如果你想使用C接口的默认方法，那么使用C.super.display();。这就是关于Java 8面试问题的全部内容。在我的后续帖子中，我们将讨论更多的Java SE 8面试问题。如果你喜欢我的帖子或有任何问题/建议，请给我留言。
外部迭代和内部迭代之间的区别是什么？
S.No.
External Iteration
Internal Iteration
1.
Available before Java 8 too.
It is introduced in Java SE 8
2.
Iterating an Aggregated Object elements externally.
Iterating an Aggregated Object elements internally (background).
3.
Iterate elements by using for-each loop and Iterators like Enumeration, Iterator, ListIterator.
Iterate elements by using Java API like “forEach” method.
4.
Iterating elements in Sequential and In-Order only.
Not required to iterate elements in Sequential order.
5.
It follows OOP approach that is Imperative Style.
It follows Functional Programming approach that is Declarative Style.
6.
It does NOT separate responsibilities properly that is, it defines both “What is to be done” and “How it is to be done”.
It defines only “What is to be done”. No need to worry about “How it is to be done”. Java API takes care about “How to do”.
7.
Less Readable Code.
More Readable code.
外部迭代的主要缺点是什么？外部迭代具有以下缺点：
- We need to write code in Imperative Style.
- There is no clear separation of Responsibilities. Tightly-Coupling between “What is to be done” and “How it is to be done” code.
- Less Readable Code.
- More Verbose and Boilerplate code.
- We have to iterate elements in Sequential order only.
- It does not support Concurrency and Parallelism properly.
内部迭代比外部迭代有哪些主要优势？与外部迭代相比，内部迭代具有以下优势：
- As it follows Functional Programming style, we can write Declarative Code.
- More Readable and concise code.
- Avoids writing Verbose and Boilerplate code
- No need to iterate elements in Sequential order.
- It supports Concurrency and Parallelism properly.
- We can write Parallel code to improve application performance.
- Clear separation of Responsibilities. Loosely-Coupling between “What is to be done” and “How it is to be done” code.
- We need to write code only about “What is to be done” and Java API takes care about “How it is to be done” code.
内部迭代相对于外部迭代的主要缺点是什么？与外部迭代相比，内部迭代有一个主要的缺点:
- In Internal Iteration, as Java API takes care about Iterating elements internally, we do NOT have control over Iteration.
外部迭代相较于内部迭代的主要优势是什么？与内部迭代相比，外部迭代有一个主要的优势。
- In External Iteration, as Java API does NOT take care about Iterating elements, we have much control over Iteration.
我们何时需要使用内部迭代？我们何时需要使用外部迭代？
这是文章《Java SE 8 面试问题与答案（第二部分）》的第2部分（共3部分）。
内容片段: 我们需要了解使用内部迭代或外部迭代的情况。
- 当我们需要对迭代进行更多控制时，可以使用外部迭代。
- 当我们不需要对迭代进行更多控制时，可以使用内部迭代。
- 当我们需要开发高并发和并行应用程序时，应该使用内部迭代。
Java 8的Stream API中中间操作和终端操作有什么区别？
序号
Stream中间操作
Stream终端操作
1.
Stream中间操作在我们将其与Stream终端操作链接之前不会被评估。
Stream终端操作是独立评估的，不需要其他操作的帮助。
2.
中间操作的输出是另一个Stream。
终端操作的输出不是Stream，而是Stream之外的其他内容。
3.
中间操作是惰性评估的。
终端操作是即时评估的。
4.
我们可以链接任意数量的Stream中间操作。
我们不能链接Stream终端操作。
5.
每个语句中我们可以使用任意数量的Stream中间操作。
每个语句中我们只能使用一个Stream终端操作。
在Java接口中是否可以提供方法实现？如果可以，应该如何提供？
在Java 7或以前的版本中，接口无法提供方法实现。但在Java 8及以后的版本中，可以实现这一功能。在Java SE 8中，我们可以通过使用以下两个新概念来在接口中提供方法实现：
- 默认方法（Default Methods）
- 静态方法（Static Methods）
什么是默认方法？为什么我们需要在Java 8接口中使用默认方法？
默认方法是在接口中使用”default”关键字实现的方法。它是在Java SE 8中引入的新功能。我们需要默认方法的原因如下：
- 它允许我们在接口中提供方法的实现。
- 在不破坏实现该接口的类的情况下，向接口添加新功能。
- 提供优雅的向后兼容性功能。
- 便于扩展现有功能。
- 便于维护现有功能。
什么是静态方法？为什么我们需要在Java 8接口中使用静态方法？
静态方法是一种实用方法或助手方法，与类（或接口）相关联。它不与任何对象相关联。我们需要静态方法的原因有以下几点：
- 我们可以将与特定接口相关的辅助或实用方法保留在同一接口中，而不是放在单独的实用类中。
- 我们不需要像Collections、Arrays等单独的实用类来保存实用方法。
- 职责的清晰分离。也就是说，我们不需要一个实用类来保存Collection API的所有实用方法，如Collections等。
- 便于扩展API。
- 便于维护API。
函数式编程和面向对象编程有什么区别？
函数式编程
面向对象编程
不存在状态
存在状态
使用不可变数据
使用可变数据
遵循声明式编程模型
遵循命令式编程模型
无状态编程模型
有状态编程模型
主要关注：”你在做什么”
主要关注：”你如何做”
适合并行（并发）编程
不适合并行（并发）编程
适合大数据处理和分析
不适合大数据处理和分析
支持纯封装
破坏封装概念
函数无副作用
方法有副作用
函数是一等公民
对象是一等公民
主要操作单元是”函数”
主要操作单元是对象（类的实例）
流控制：函数调用，带递归的函数调用
流控制：循环，条件语句
使用”递归”概念来迭代集合数据。
使用”循环”概念来迭代集合数据。例如：Java中的for-each循环
执行顺序的重要性较低。
执行顺序是必须且非常重要的。
同时支持”数据抽象”和”行为抽象”。
仅支持”数据抽象”。
当我们有少量事物和更多操作时，我们使用函数式编程。
当我们有少量操作和更多事物时，我们使用面向对象编程。例如：在Java中，事物是类，操作是方法。
请阅读我之前的帖子：”比较FP，OOP（IP）”以了解有关FP，IP和OOP的更多信息。
请解释一下旧的Java Date API存在哪些问题？相较于旧的Date API和Joda Time API，Java 8的Date and Time API有哪些优势？
Java的旧日期API是指Java SE 8之前可用的日期API，例如Date、Calendar、SimpleDateFormat等。与Java 8的日期和时间API以及Joda Time API相比，Java的旧日期API存在以下问题或缺点。
- Most of the API is deprecated.
- Less Readability.
- java.util.Date is Mutable and not Thread-Safe.
- java.text.SimpleDateFormat is not Thread-Safe.
- Less Performance.
与Java的旧日期API相比，Java SE 8的日期和时间API具有以下优势。
- Very simple to use.
- Human Readable Syntax that is More Readability.
- All API is Thread-Safe.
- Better Performance.
为什么我们需要Java SE 8中的新日期和时间API？请解释一下Java SE 8日期和时间API如何解决旧的Java日期API的问题。我们需要Java 8的日期和时间API来开发高性能、线程安全和高可扩展的Java应用程序。Java 8的日期和时间API通过遵循不可变性和线程安全原则解决了所有旧的Java日期API的问题。
Java的旧Java日期API和Java 8的日期和时间API有什么区别？Java的旧日期API和Java 8的日期和时间API之间的区别。
S.No.
Java’s OLD Java Date API
Java 8’s Date and Time API
1.
Available before Java 8 too.
It is introduced in Java SE 8
2.
Not Thread Safe.
Thread Safe.
3.
Mutable API.
Immutable API.
4.
Less Performance.
Better Performance.
5.
Less Readability.
More Readability.
6.
It’s not recommended to use as its deprecated.
It’s always recommended to use.
7.
Not Extendable.
Easy to Extend.
8.
It defines months values from 0 to 11, that is January = 0.
It defines months values from 1 to 12, that is January = 1.
9.
It’s an old API.
It’s a new API.
多重继承是什么？Java 8 如何支持多重继承？多重继承意味着一个类可以从多个父类继承或扩展特性和功能。在Java 7或之前的版本中，多重继承是不可能的，因为Java遵循“一个类只能继承一个类或抽象类”的规则。然而，通过使用接口，可以实现多重实现继承，因为Java遵循“一个类可以继承任意数量的接口”的规则。然而，Java 8通过引入新特性“接口中的默认方法”来支持“在接口中实现方法”。由于这个特性，Java 8支持有一些限制的多重继承。
默认方法在接口中导致的钻石问题是什么？Java 8是如何解决这个问题的？
interface A {
default void display() {
System.out.println("A");
}
}
interface B extends A {
default void display() {
System.out.println("B");
}
}
interface C extends A {
default void display() {
System.out.println("C");
}
}
class D implements B, C {
}
在上面的代码片段中，类D出现编译时错误，错误信息为“从类型C和B继承的display()方法存在重复的默认方法，参数为()和()”。这是因为Java编译器在类D中对于使用哪个display()方法感到困惑。类D从接口B和C中都继承了display()方法。为了解决这个问题，Java 8提供了以下解决方案。
class D implements B, C {
@Override
public void display() {
B.super.display();
}
}
这个B.super.display();将解决这个钻石问题。如果你想使用C接口的默认方法，那么使用C.super.display();。这就是关于Java 8面试问题的全部内容。在我的后续帖子中，我们将讨论更多的Java SE 8面试问题。如果你喜欢我的帖子或有任何问题/建议，请给我留言。
| S.No. | External Iteration | Internal Iteration |
|---|---|---|
| 1. | Available before Java 8 too. | It is introduced in Java SE 8 |
| 2. | Iterating an Aggregated Object elements externally. | Iterating an Aggregated Object elements internally (background). |
| 3. | Iterate elements by using for-each loop and Iterators like Enumeration, Iterator, ListIterator. | Iterate elements by using Java API like “forEach” method. |
| 4. | Iterating elements in Sequential and In-Order only. | Not required to iterate elements in Sequential order. |
| 5. | It follows OOP approach that is Imperative Style. | It follows Functional Programming approach that is Declarative Style. |
| 6. | It does NOT separate responsibilities properly that is, it defines both “What is to be done” and “How it is to be done”. | It defines only “What is to be done”. No need to worry about “How it is to be done”. Java API takes care about “How to do”. |
| 7. | Less Readable Code. | More Readable code. |
外部迭代的主要缺点是什么？外部迭代具有以下缺点：
- We need to write code in Imperative Style.
- There is no clear separation of Responsibilities. Tightly-Coupling between “What is to be done” and “How it is to be done” code.
- Less Readable Code.
- More Verbose and Boilerplate code.
- We have to iterate elements in Sequential order only.
- It does not support Concurrency and Parallelism properly.
内部迭代比外部迭代有哪些主要优势？与外部迭代相比，内部迭代具有以下优势：
- As it follows Functional Programming style, we can write Declarative Code.
- More Readable and concise code.
- Avoids writing Verbose and Boilerplate code
- No need to iterate elements in Sequential order.
- It supports Concurrency and Parallelism properly.
- We can write Parallel code to improve application performance.
- Clear separation of Responsibilities. Loosely-Coupling between “What is to be done” and “How it is to be done” code.
- We need to write code only about “What is to be done” and Java API takes care about “How it is to be done” code.
内部迭代相对于外部迭代的主要缺点是什么？与外部迭代相比，内部迭代有一个主要的缺点:
- In Internal Iteration, as Java API takes care about Iterating elements internally, we do NOT have control over Iteration.
外部迭代相较于内部迭代的主要优势是什么？与内部迭代相比，外部迭代有一个主要的优势。
- In External Iteration, as Java API does NOT take care about Iterating elements, we have much control over Iteration.
我们何时需要使用内部迭代？我们何时需要使用外部迭代？
- As it follows Functional Programming style, we can write Declarative Code.
- More Readable and concise code.
- Avoids writing Verbose and Boilerplate code
- No need to iterate elements in Sequential order.
- It supports Concurrency and Parallelism properly.
- We can write Parallel code to improve application performance.
- Clear separation of Responsibilities. Loosely-Coupling between “What is to be done” and “How it is to be done” code.
- We need to write code only about “What is to be done” and Java API takes care about “How it is to be done” code.
内部迭代相对于外部迭代的主要缺点是什么？与外部迭代相比，内部迭代有一个主要的缺点:
- In Internal Iteration, as Java API takes care about Iterating elements internally, we do NOT have control over Iteration.
外部迭代相较于内部迭代的主要优势是什么？与内部迭代相比，外部迭代有一个主要的优势。
- In External Iteration, as Java API does NOT take care about Iterating elements, we have much control over Iteration.
我们何时需要使用内部迭代？我们何时需要使用外部迭代？
- In External Iteration, as Java API does NOT take care about Iterating elements, we have much control over Iteration.
我们何时需要使用内部迭代？我们何时需要使用外部迭代？
这是文章《Java SE 8 面试问题与答案（第二部分）》的第2部分（共3部分）。
内容片段: 我们需要了解使用内部迭代或外部迭代的情况。
- 当我们需要对迭代进行更多控制时，可以使用外部迭代。
- 当我们不需要对迭代进行更多控制时，可以使用内部迭代。
- 当我们需要开发高并发和并行应用程序时，应该使用内部迭代。
Java 8的Stream API中中间操作和终端操作有什么区别？
| 序号 | Stream中间操作 | Stream终端操作 |
|---|---|---|
| 1. | Stream中间操作在我们将其与Stream终端操作链接之前不会被评估。 | Stream终端操作是独立评估的，不需要其他操作的帮助。 |
| 2. | 中间操作的输出是另一个Stream。 | 终端操作的输出不是Stream，而是Stream之外的其他内容。 |
| 3. | 中间操作是惰性评估的。 | 终端操作是即时评估的。 |
| 4. | 我们可以链接任意数量的Stream中间操作。 | 我们不能链接Stream终端操作。 |
| 5. | 每个语句中我们可以使用任意数量的Stream中间操作。 | 每个语句中我们只能使用一个Stream终端操作。 |
在Java接口中是否可以提供方法实现？如果可以，应该如何提供？
在Java 7或以前的版本中，接口无法提供方法实现。但在Java 8及以后的版本中，可以实现这一功能。在Java SE 8中，我们可以通过使用以下两个新概念来在接口中提供方法实现：
- 默认方法（Default Methods）
- 静态方法（Static Methods）
什么是默认方法？为什么我们需要在Java 8接口中使用默认方法？
默认方法是在接口中使用”default”关键字实现的方法。它是在Java SE 8中引入的新功能。我们需要默认方法的原因如下：
- 它允许我们在接口中提供方法的实现。
- 在不破坏实现该接口的类的情况下，向接口添加新功能。
- 提供优雅的向后兼容性功能。
- 便于扩展现有功能。
- 便于维护现有功能。
什么是静态方法？为什么我们需要在Java 8接口中使用静态方法？
静态方法是一种实用方法或助手方法，与类（或接口）相关联。它不与任何对象相关联。我们需要静态方法的原因有以下几点：
- 我们可以将与特定接口相关的辅助或实用方法保留在同一接口中，而不是放在单独的实用类中。
- 我们不需要像Collections、Arrays等单独的实用类来保存实用方法。
- 职责的清晰分离。也就是说，我们不需要一个实用类来保存Collection API的所有实用方法，如Collections等。
- 便于扩展API。
- 便于维护API。
函数式编程和面向对象编程有什么区别？
| 函数式编程 | 面向对象编程 |
|---|---|
| 不存在状态 | 存在状态 |
| 使用不可变数据 | 使用可变数据 |
| 遵循声明式编程模型 | 遵循命令式编程模型 |
| 无状态编程模型 | 有状态编程模型 |
| 主要关注：”你在做什么” | 主要关注：”你如何做” |
| 适合并行（并发）编程 | 不适合并行（并发）编程 |
| 适合大数据处理和分析 | 不适合大数据处理和分析 |
| 支持纯封装 | 破坏封装概念 |
| 函数无副作用 | 方法有副作用 |
| 函数是一等公民 | 对象是一等公民 |
| 主要操作单元是”函数” | 主要操作单元是对象（类的实例） |
| 流控制：函数调用，带递归的函数调用 | 流控制：循环，条件语句 |
| 使用”递归”概念来迭代集合数据。 | 使用”循环”概念来迭代集合数据。例如：Java中的for-each循环 |
| 执行顺序的重要性较低。 | 执行顺序是必须且非常重要的。 |
| 同时支持”数据抽象”和”行为抽象”。 | 仅支持”数据抽象”。 |
| 当我们有少量事物和更多操作时，我们使用函数式编程。 | 当我们有少量操作和更多事物时，我们使用面向对象编程。例如：在Java中，事物是类，操作是方法。 |
请阅读我之前的帖子：”比较FP，OOP（IP）”以了解有关FP，IP和OOP的更多信息。
请解释一下旧的Java Date API存在哪些问题？相较于旧的Date API和Joda Time API，Java 8的Date and Time API有哪些优势？
Java的旧日期API是指Java SE 8之前可用的日期API，例如Date、Calendar、SimpleDateFormat等。与Java 8的日期和时间API以及Joda Time API相比，Java的旧日期API存在以下问题或缺点。
- Most of the API is deprecated.
- Less Readability.
- java.util.Date is Mutable and not Thread-Safe.
- java.text.SimpleDateFormat is not Thread-Safe.
- Less Performance.
与Java的旧日期API相比，Java SE 8的日期和时间API具有以下优势。
- Very simple to use.
- Human Readable Syntax that is More Readability.
- All API is Thread-Safe.
- Better Performance.
为什么我们需要Java SE 8中的新日期和时间API？请解释一下Java SE 8日期和时间API如何解决旧的Java日期API的问题。我们需要Java 8的日期和时间API来开发高性能、线程安全和高可扩展的Java应用程序。Java 8的日期和时间API通过遵循不可变性和线程安全原则解决了所有旧的Java日期API的问题。
Java的旧Java日期API和Java 8的日期和时间API有什么区别？Java的旧日期API和Java 8的日期和时间API之间的区别。
S.No.
Java’s OLD Java Date API
Java 8’s Date and Time API
1.
Available before Java 8 too.
It is introduced in Java SE 8
2.
Not Thread Safe.
Thread Safe.
3.
Mutable API.
Immutable API.
4.
Less Performance.
Better Performance.
5.
Less Readability.
More Readability.
6.
It’s not recommended to use as its deprecated.
It’s always recommended to use.
7.
Not Extendable.
Easy to Extend.
8.
It defines months values from 0 to 11, that is January = 0.
It defines months values from 1 to 12, that is January = 1.
9.
It’s an old API.
It’s a new API.
多重继承是什么？Java 8 如何支持多重继承？多重继承意味着一个类可以从多个父类继承或扩展特性和功能。在Java 7或之前的版本中，多重继承是不可能的，因为Java遵循“一个类只能继承一个类或抽象类”的规则。然而，通过使用接口，可以实现多重实现继承，因为Java遵循“一个类可以继承任意数量的接口”的规则。然而，Java 8通过引入新特性“接口中的默认方法”来支持“在接口中实现方法”。由于这个特性，Java 8支持有一些限制的多重继承。
默认方法在接口中导致的钻石问题是什么？Java 8是如何解决这个问题的？
interface A {
default void display() {
System.out.println("A");
}
}
interface B extends A {
default void display() {
System.out.println("B");
}
}
interface C extends A {
default void display() {
System.out.println("C");
}
}
class D implements B, C {
}
在上面的代码片段中，类D出现编译时错误，错误信息为“从类型C和B继承的display()方法存在重复的默认方法，参数为()和()”。这是因为Java编译器在类D中对于使用哪个display()方法感到困惑。类D从接口B和C中都继承了display()方法。为了解决这个问题，Java 8提供了以下解决方案。
class D implements B, C {
@Override
public void display() {
B.super.display();
}
}
这个B.super.display();将解决这个钻石问题。如果你想使用C接口的默认方法，那么使用C.super.display();。这就是关于Java 8面试问题的全部内容。在我的后续帖子中，我们将讨论更多的Java SE 8面试问题。如果你喜欢我的帖子或有任何问题/建议，请给我留言。
| S.No. | Java’s OLD Java Date API | Java 8’s Date and Time API |
|---|---|---|
| 1. | Available before Java 8 too. | It is introduced in Java SE 8 |
| 2. | Not Thread Safe. | Thread Safe. |
| 3. | Mutable API. | Immutable API. |
| 4. | Less Performance. | Better Performance. |
| 5. | Less Readability. | More Readability. |
| 6. | It’s not recommended to use as its deprecated. | It’s always recommended to use. |
| 7. | Not Extendable. | Easy to Extend. |
| 8. | It defines months values from 0 to 11, that is January = 0. | It defines months values from 1 to 12, that is January = 1. |
| 9. | It’s an old API. | It’s a new API. |
多重继承是什么？Java 8 如何支持多重继承？多重继承意味着一个类可以从多个父类继承或扩展特性和功能。在Java 7或之前的版本中，多重继承是不可能的，因为Java遵循“一个类只能继承一个类或抽象类”的规则。然而，通过使用接口，可以实现多重实现继承，因为Java遵循“一个类可以继承任意数量的接口”的规则。然而，Java 8通过引入新特性“接口中的默认方法”来支持“在接口中实现方法”。由于这个特性，Java 8支持有一些限制的多重继承。
默认方法在接口中导致的钻石问题是什么？Java 8是如何解决这个问题的？
interface A {
default void display() {
System.out.println("A");
}
}
interface B extends A {
default void display() {
System.out.println("B");
}
}
interface C extends A {
default void display() {
System.out.println("C");
}
}
class D implements B, C {
}
在上面的代码片段中，类D出现编译时错误，错误信息为“从类型C和B继承的display()方法存在重复的默认方法，参数为()和()”。这是因为Java编译器在类D中对于使用哪个display()方法感到困惑。类D从接口B和C中都继承了display()方法。为了解决这个问题，Java 8提供了以下解决方案。
class D implements B, C {
@Override
public void display() {
B.super.display();
}
}
这个B.super.display();将解决这个钻石问题。如果你想使用C接口的默认方法，那么使用C.super.display();。这就是关于Java 8面试问题的全部内容。在我的后续帖子中，我们将讨论更多的Java SE 8面试问题。如果你喜欢我的帖子或有任何问题/建议，请给我留言。
interface A {
default void display() {
System.out.println("A");
}
}
interface B extends A {
default void display() {
System.out.println("B");
}
}
interface C extends A {
default void display() {
System.out.println("C");
}
}
class D implements B, C {
}
在上面的代码片段中，类D出现编译时错误，错误信息为“从类型C和B继承的display()方法存在重复的默认方法，参数为()和()”。这是因为Java编译器在类D中对于使用哪个display()方法感到困惑。类D从接口B和C中都继承了display()方法。为了解决这个问题，Java 8提供了以下解决方案。
class D implements B, C {
@Override
public void display() {
B.super.display();
}
}
这个B.super.display();将解决这个钻石问题。如果你想使用C接口的默认方法，那么使用C.super.display();。这就是关于Java 8面试问题的全部内容。在我的后续帖子中，我们将讨论更多的Java SE 8面试问题。如果你喜欢我的帖子或有任何问题/建议，请给我留言。
