Java面试（2025）—

Java语言有哪些特点？

Java语言具有多个显著特点，使其在编程领域广受欢迎。首先，Java的跨平台性非常强，通过Java虚拟机（JVM）实现“编写一次，随处运行”，使得开发者能够在不同操作系统上无缝运行应用程序。其次，Java是一种面向对象的编程语言，支持封装、继承和多态等特性，这使得代码更加模块化，易于维护和重用。此外，Java提供了强大的安全机制，降低了恶意代码的风险，并且其语法相对简洁，去掉了许多复杂特性，易于上手。

Java还拥有自动内存管理的垃圾回收机制，减少了内存泄漏和指针错误的风险，同时提供了内置的多线程支持，方便编写高性能的并发程序。它的丰富标准库涵盖了数据结构、网络编程和图形用户界面等多个领域，大大提高了开发效率。作为一种强类型语言，Java在编译时进行类型检查，可以捕捉潜在错误，从而提高代码的安全性和可靠性。

最后，Java持续进行版本更新，引入新特性，保持与时俱进，并且拥有庞大的开发者社区和丰富的第三方库及框架，如Spring和Hibernate等，这些都为开发者提供了广泛的支持和资源。总的来说，Java的这些特点使其成为企业级开发、移动应用和Web开发等领域的热门选择。

Java SE vs Java EE

Java SE（Java Standard Edition）和Java EE（Java Enterprise Edition）是Java平台的两个不同版本。Java SE是标准版，适用于桌面应用程序和小型应用的开发，提供了基本的Java编程环境和核心类库，包括输入输出、集合框架和多线程支持等功能。而Java EE是专为企业级应用设计的扩展版，除了包含Java SE的所有功能外，还提供了如Servlet、JSP、EJB、JTA和JMS等企业级特性，适用于构建大型、分布式和多层次的企业应用。Java SE的应用通常打包为JAR文件，开发环境简单，适合初学者，而Java EE则需要在兼容的应用服务器上运行，通常打包为WAR或EAR文件，适合于对可扩展性和高可用性有高要求的项目。选择哪个版本取决于项目的需求和规模。

JVM vs JDK vs JRE

JVM（Java Virtual Machine）是Java虚拟机，是Java程序执行的核心组件，负责将Java字节码转换为机器代码并在特定操作系统上运行。它提供了Java程序的运行环境，管理内存（包括堆和栈的分配）以及垃圾回收，同时实现了Java“一次编写，处处运行”的理念，确保Java程序能够在不同的操作系统上无缝运行。

JRE（Java Runtime Environment）是Java运行环境，包含了JVM和一组用于运行Java程序的标准类库及其他文件。它提供了运行Java应用程序所需的所有环境，但不包含开发工具，如编译器和调试器，因此只能用于运行Java应用，而不能用于开发。

JDK（Java Development Kit）是Java开发工具包，是软件开发的完整工具包，包含了JRE和用于开发Java应用程序的工具。它不仅提供了运行Java程序所需的环境，还包含编译器（javac）、调试器、文档生成工具（javadoc）等，使开发者能够编写、编译、调试和运行Java程序。JDK适合开发者使用，旨在支持Java应用程序的开发过程。

在Java 9及以后版本中，JRE和JDK之间的界限被进一步模糊，主要是通过引入模块化系统（JPMS，Java Platform Module System）实现的。这个模块化系统允许开发者以模块的形式组织代码，使得可以更灵活地管理依赖关系和模块化的发布。通过这种方式，Java平台的运行时环境得以更加精简，同时也提高了性能和安全性。开发者可以选择只包含他们应用所需的模块，从而减少应用的体积和复杂性。这一变化标志着Java在现代软件开发中的适应性和可扩展性的增强。

什么是字节码?采用字节码的好处是什么?

字节码是Java编程语言的一种中间表示形式。在Java中，当程序员编写的源代码（.java文件）经过Java编译器（javac）编译后，生成的不是直接可执行的机器代码，而是字节码（.class文件），通常以.class文件的形式存在。字节码的主要优势在于其跨平台性，使得Java程序能够在任何安装有Java虚拟机（JVM）的设备上运行，真正实现“一次编写，到处运行”。此外，字节码在执行前会经过JVM的验证，确保安全性，并且JVM可以对字节码进行即时编译（JIT），提高执行效率，同时进行内存管理和垃圾回收。字节码也相对易于分析和调试，便于开发者使用调试工具，提升开发和维护的效率。这些特性共同使得Java成为在企业级和跨平台应用开发中广泛使用的编程语言。

什么是编译型、解释型语言？为什么说 Java 语言“编译与解释并存”？

编译型语言与解释型语言

编译型语言是指在程序执行之前，源代码需要经过编译器的处理，将其转换为机器语言（或中间代码）文件。这种文件可以直接在目标机器上运行。编译的过程通常是一次性的，且在执行时不需要再次编译，例如C、C++和Go等语言。编译型语言的优点包括执行速度快、优化机会多，但缺点是编译过程较长，对于调试和修改不够灵活。

解释型语言则是指源代码在执行时直接由解释器逐行解释和执行，而无需事先编译成机器代码。Python、Ruby和JavaScript都是典型的解释型语言。解释型语言的优点在于灵活性高、开发和调试过程迅速，但缺点是执行速度相对较慢，因为每次运行都需要进行解释。

Java语言“编译与解释并存”的原因

Java语言被称为“编译与解释并存”，主要是因为它采用了两种技术的结合：

编译过程：Java源代码（.java文件）首先通过Java编译器（javac）编译成字节码（.class文件）。这个字节码并不是特定于某一平台的机器代码，而是中间代码，具有平台无关性。
解释过程：生成的字节码在Java虚拟机（JVM）中执行，JVM可以将字节码解释为特定平台的机器语言，也可以在运行时使用即时编译（JIT）技术，将字节码动态编译为本地机器代码，以提高执行效率。

这种“编译与解释并存”的机制使得Java程序能够在不同的操作系统上高效运行，同时保留了良好的性能和跨平台特性。通过先编译为字节码，再由JVM执行，Java实现了灵活的开发过程和较高的运行效率，这是Java语言的一大特色。

Java有哪些数据类型

Java中的数据类型主要分为两大类：基本数据类型（Primitive Types）和引用数据类型（Reference Types）。

基本数据类型

Java有八种基本数据类型，它们分别是：

数据类型	大小	默认值	说明
`byte`	8位	0	范围：-128 到 127
`short`	16位	0	范围：-32,768 到 32,767
`int`	32位	0	范围：-2,147,483,648 到 2,147,483,647
`long`	64位	0L	范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
`float`	32位	0.0f	单精度浮点数
`double`	64位	0.0	双精度浮点数
`char`	16位	‘\u0000’	单个16位Unicode字符
`boolean`	1位（逻辑上）	false	只有两个值：`true` 或 `false`

引用数据类型

引用数据类型用于表示更复杂的数据结构，它们的值是对实际数据的引用（地址），而不是直接存储数据本身。常见的引用数据类型包括：

类（Class）：用户定义的类的实例。
接口（Interface）：用户定义的接口的实例。
数组（Array）：存储一组相同类型的数据，数组本身是一个对象。
字符串（String）：虽然字符串在Java中被视为引用类型，但它是一个特殊的类，不可变的字符序列。

java的三大特性

封装（Encapsulation）

封装是Java面向对象编程的基本特性之一。它指的是将对象的状态（属性）和行为（方法）结合在一起，并通过访问修饰符来限制外部对对象内部状态的直接访问。通过使用private、protected和public等关键字，我们可以有效地控制属性和方法的访问权限。

封装的主要优点在于提高了代码的安全性和灵活性。通过对内部实现的隐藏，外部使用者只能通过公开的方法与对象交互，确保了数据的完整性。此外，封装还使得对象的内部实现可以独立于外部使用者，从而更容易进行维护和修改。

继承（Inheritance）

继承是指一个类可以从另一个类获取属性和方法的能力。在Java中，使用关键字extends来实现继承。被继承的类称为父类（或超类），继承的类称为子类（或派生类）。通过继承，子类可以直接使用父类的资源，从而实现代码的复用。

继承的主要优点在于代码复用和增强的可维护性。子类可以重用父类中已有的代码，减少了重复代码的编写。这种结构使得对父类的修改可以自动反映在所有子类中，进一步提升了代码的维护性和可扩展性。

多态（Polymorphism）

多态是指同一操作作用于不同的对象时，可以产生不同的行为。在Java中，多态主要通过方法的重载和重写来实现。方法重载是指同一方法名，但参数不同；方法重写则是子类对父类方法的重新实现。多态的关键在于父类引用指向子类对象，使得程序在运行时能够根据实际对象的类型执行相应的行为。

多态的优点在于提高了程序的灵活性和可扩展性。通过父类引用来操作子类对象，程序能够处理不同类型的对象，从而使得代码更加简洁和易于扩展。这种特性使得开发者可以在不修改现有代码的情况下，添加新的子类，增强了系统的灵活性。

重载和重写的区别

在Java中，重载和重写是两个非常重要的概念。虽然它们都与方法相关，但在实现和使用上有显著的不同。

重载（Overloading）是指在同一个类中定义多个同名方法，这些方法的参数列表（包括类型、个数或顺序）必须不同。重载的主要目的是提高方法的灵活性和可读性。例如，我可以创建多个add方法，分别处理两个整型参数、两个浮点型参数或三个整型参数。这种设计使得我们能够在不同的上下文中调用相同的方法名，从而使代码更易于理解和使用。

重写（Overriding）是指子类对父类中已存在的方法进行重新定义。重写的方法必须与被重写的方法拥有相同的方法名、参数列表和返回类型，且访问权限不能低于父类的方法。重写的主要目的在于实现多态性，使得子类能够提供特定的实现。例如，如果我有一个Animal类，它有一个sound方法，子类Dog可以重写这个方法，实现特定的狗叫声。这种机制允许我们在运行时根据对象的实际类型选择调用哪个方法，从而增强了程序的灵活性。

重载方法的签名必须不同，而重写方法的签名必须完全相同。此外，重载是在编译时根据参数类型和数量决定调用哪个方法，而重写是在运行时根据对象实际类型决定调用哪个方法。重载提供了方法的多种实现，而重写允许子类对父类的方法进行定制。

访问修饰符

在Java中，访问修饰符用于控制类、方法和变量的可见性和访问权限。这对于实现封装性和保护类的内部状态非常重要。

首先是public，标记为public的类、方法或变量可以被任何其他类访问，不论它们是否在同一个包中。这通常用于对外提供服务或API的类和方法。

其次是private，标记为private的成员只能在其所在的类内部访问。这种修饰符通常用于隐藏实现细节，保护类的内部状态不被外部直接修改，从而实现封装。

接下来是protected，它允许同一包中的类以及不同包中的子类访问标记为protected的方法和变量。这在涉及继承时非常有用，因为它可以让子类访问父类的属性和方法。

最后是默认访问修饰符，若不指定任何访问修饰符，Java将使用包级别的访问权限。这表示只有同一包中的类可以访问这些类、方法或变量，其他包的类无法访问，适用于包内协作的场景。

总的来说，public允许任何地方访问，private只限于本类内部，protected则允许同包和子类访问，而默认访问权限只允许同一包中的类访问。通过合理使用这些访问修饰符，我们可以有效地控制类的可见性和封装性，从而提高代码的安全性和可维护性。

在我之前的项目中，我们在服务类中使用了public方法来提供API接口，确保外部模块可以访问。而对于一些关键的业务逻辑和数据，我们则使用了private修饰符来保护这些信息，确保它们不能被随意修改。这种设计提高了代码的安全性和可维护性。

和equals的区别

在Java中，运算符和equals()方法都是用于比较对象，但它们有着不同的用途和机制。

运算符用于比较两个引用是否指向同一个对象，即它们的内存地址是否相同。当用于基本数据类型时，比较的是它们的值。例如，对于两个String对象，会判断它们是否是同一个实例，而不是比较它们的内容。

equals()方法用于比较对象的内容或逻辑相等性，具体实现取决于类的定义。默认情况下，equals()方法在Object类中实现，比较的是对象的内存地址，但我们通常会重写这个方法，以根据对象的属性比较它们的内容。

总结一下，运算符比较的是引用是否相同，而equals()方法比较的是内容是否相等。对于基本数据类型，==比较的是值。由于equals()可以被重写，所以在自定义类中我们往往会实现根据属性值的比较，而不是仅依赖于内存地址的比较。

在我的项目中，我们有一个用户类，采用了重写的equals()方法来比较用户对象，确保在处理集合时能够正确判断用户的唯一性。比如在使用HashSet时，我们重写了equals()和hashCode()方法，以保证相同用户不会重复进入集合。

重写equals()时也要重写hashCode()确保在使用基于哈希的数据结构（如HashMap、HashSet等）时，可以正确地存储和查找对象。

&和&&

在Java中，我们经常使用&和&&来进行布尔运算，但它们的行为和用途有显著的不同。

&是按位与运算符，它不仅可以用于整数的按位操作，也可以用于布尔运算。相比之下，&&是逻辑与运算符，专门用于连接两个布尔表达式。

最主要的区别在于短路求值。&&运算符具有短路特性：如果第一个条件为false，那么Java不会评估第二个条件，因为结果已经确定为false。而&运算符不具备这种特性，无论第一个条件是什么，第二个条件都会被计算。

我们通常使用&&在条件判断中，例如if语句中，因为它的短路特性可以提高程序的效率。而&运算符则多用于需要逐位操作的场景，或者在我们希望确保两个条件都被评估的情况下。

所以总结一下，&是按位与运算符并不具备短路特性，而&&是逻辑与运算符，具有短路特性。

| 和 || 的区别

在Java中，|和||都是用于进行逻辑运算的运算符，但它们具有不同的特性和应用场景。

首先，|是按位或运算符，它不仅可以用于整数的按位操作，还可以用于布尔运算。在布尔运算中，|会计算两个操作数的布尔值，而不考虑短路特性。相对而言，||是逻辑或运算符，专门用于连接两个布尔表达式，并且具有短路求值特性。

短路求值是这两个运算符之间的关键区别。对于||运算符，如果第一个表达式的结果为true，Java会跳过对第二个表达式的计算，因为整个表达式的结果已经确定为true。而|运算符则会无条件计算两个操作数。

通常，在条件判断中，我们更倾向于使用||，例如在if语句中，因为它能够提高效率，避免不必要的计算。而|运算符则常用于位运算或在我们希望确保两个条件都被评估的情况下。

综上所述，|是按位或运算符，不具备短路求值特性，而||是逻辑或运算符，具备短路求值特性。

String、StringBuffer、StringBuilder的区别

特性	String	StringBuffer	StringBuilder
可变性	不可变（immutable）	可变（mutable）	可变（mutable）
线程安全	不涉及	线程安全（synchronized）	不线程安全
性能	较低（频繁修改时效率不高）	较高（但由于同步，性能略逊于StringBuilder）	性能最佳（适合单线程环境）
内存开销	每次修改都会创建新对象	修改时不创建新对象，减少内存开销	修改时不创建新对象，减少内存开销
使用场景	适合常量字符串操作	适合多线程环境中频繁修改字符串	适合单线程环境中频繁修改字符串
示例代码	`String str = “Hello”; str += " World";`	`StringBuffer sb = new StringBuffer(“Hello”); sb.append(" World");`	`StringBuilder sb = new StringBuilder(“Hello”); sb.append(" World");`

反射

反射是Java提供的一种能够在运行时动态获取类信息并操作类或对象的能力机制。它允许程序在运行时检查类、接口、字段和方法，而不需要在编译时知道这些类的具体信息。

反射机制的核心价值在于它提供了Java程序的动态性，这使得很多高级功能成为可能，比如：

Spring框架的依赖注入和AOP实现
ORM框架的数据库映射
IDE的代码提示功能
动态代理等设计模式的实现（动态代理模式确实依赖了Java的反射机制。在JDK动态代理的实现中，Proxy类会在运行时动态生成代理类的字节码，而所有对代理对象的方法调用都会通过InvocationHandler的invoke方法处理，这个方法正是通过Method.invoke()反射调用目标方法的。这种设计使得我们可以在不修改原始类的情况下，为方法调用添加统一的处理逻辑，比如日志记录、事务管理等。Spring AOP就是基于这种机制实现的。）

从技术实现角度看，反射主要涉及四个核心类：

Class类 - 类的元数据入口
Field类 - 处理成员变量
Method类 - 处理方法调用
Constructor类 - 处理对象构造

获取Class对象的三种典型方式：

类名.class
对象.getClass()
Class.forName()

在我之前的XX项目中，曾使用反射解决过这样的问题：[简要描述一个实际场景]。具体实现是通过反射动态加载类并调用特定方法，这样实现了[具体好处]。

虽然反射很强大，但使用时需要注意，

优点：

极高的灵活性
能实现常规方法无法完成的功能

缺点：

性能开销比直接调用高
会破坏封装性
使代码可读性降低因此我们通常只在框架开发或确实需要动态能力的场景使用反射，常规业务开发中会尽量避免。

反射与以下概念密切相关:

动态代理：反射是实现动态代理的基础
注解处理：很多注解的运行时处理依赖反射
类加载机制：理解反射需要了解类加载过程"

浅拷贝和深拷贝的区别

浅拷贝和深拷贝是对象复制的两种方式，主要区别在于对引用类型字段的处理方式：

浅拷贝只复制对象本身和基本类型字段，对于引用类型字段只复制引用地址，新旧对象会共享这些引用对象；
深拷贝则会递归复制对象及其所有引用对象，创建完全独立的副本。

在Java中实现时：

浅拷贝通常通过实现Cloneable接口并调用Object.clone()方法实现，这是默认行为；
深拷贝则需要我们手动重写clone()方法，对每个引用字段都进行复制，或者通过序列化/反序列化实现完全独立的拷贝。

举个例子，假设有一个Person类包含name(String)和address(Address对象)字段：

浅拷贝后，两个Person对象会共享同一个Address对象；
深拷贝后，每个Person对象都有自己独立的Address副本。

在实际项目中：

浅拷贝适合对象结构简单或引用字段不可变的场景，性能更好；
深拷贝则用于需要完全隔离对象状态的场景，比如在多线程环境下传递数据，或者不希望修改影响原对象的情况。

需要注意：

深拷贝实现更复杂，性能开销更大；
不是所有对象都支持深拷贝，比如包含不可序列化的字段；
某些工具类如Apache Commons Lang的SerializationUtils.clone()可以简化深拷贝实现；
在Java中，数组的clone()方法是浅拷贝，集合类的构造方法(如new ArrayList<>(oldList))也是浅拷贝。

抽象类和接口的区别

在Java中，抽象类和接口都是实现抽象化的重要工具，它们各自有不同的用途和特性。

抽象类是一个不能被实例化的类，可以包含抽象方法（没有实现）和具体方法（有实现）。它可以有构造函数、字段和访问修饰符。

而接口是一个完全抽象的类型，只能定义方法的签名，且方法默认为public，不能包含具体实现（除非是Java 8之后的默认方法）。接口还可以包含常量，但不能有实例变量。

主要区别：

多继承：

抽象类不支持多继承，一个类只能继承一个抽象类。
接口支持多实现，一个类可以实现多个接口。

方法实现：

抽象类可以有抽象方法和具体方法，子类必须实现所有抽象方法。
接口中的方法默认是抽象的（Java 8及后版本可以有默认方法）。

字段（成员变量）：

抽象类可以包含实例变量和静态变量，访问修饰符可以是各种类型。
接口只能包含public static final常量。

抽象类适用于具有相似特征的类的集合，例如，动物类可以作为一个抽象类，提供共享的行为和特征。而接口适用于不相关类之间的行为共享，比如两个不同类可能都实现了Runnable接口，体现出它们都有执行某种任务的能力。

总的来说，抽象类和接口都有助于实现抽象化和多态性，但它们在设计和实现上有显著的区别。

Error和Exception有什么区别

在Java中，Error和Exception都是Throwable类的子类，它们用于处理程序中的错误情况，但它们的用途和特性有所不同。

Exception表示程序中可预料的错误情况，通常是可以处理的。例如，文件未找到或网络连接失败。它可以进一步分为受检异常和非受检异常。

受检异常（Checked Exception）是编译时必须处理的异常，如IOException和SQLException。
非受检异常（Unchecked Exception）是在运行时可能抛出的异常，如NullPointerException和ArrayIndexOutOfBoundsException。

而Error则表示严重的问题，通常由Java虚拟机（JVM）引起，程序无法恢复，例如OutOfMemoryError或StackOverflowError。

我可以使用try-catch块来捕获和处理Exception，使程序能够在发生异常时继续执行。例如，对于IOException，我可以通过捕获来处理文件未找到的情况。而对于Error，我并不推荐捕获，因为它们通常表示程序无法继续运行的严重问题。试图捕获Error可能导致程序的不稳定。

总而言之，Exception用于处理可预见的错误并且可以恢复，而Error通常表示严重问题，程序无法继续运行。

final关键字有哪些用法？

在Java中，final关键字用于声明不可改变的实体，可以用于变量、方法和类。它的主要作用是限制某些特性，以提高代码的可维护性和安全性。

首先是final变量。当一个变量被声明为final时，它的值在被初始化后不能再被修改。这适用于基本数据类型和引用类型。对于基本数据类型，这意味着值不可更改；对于引用类型，这意味着引用不可更改，但对象的状态仍然可以改变。

其次是final方法。一个方法被声明为final时，表示该方法不能被子类重写。这在设计类时很有用，确保某些关键行为不会被改变。

最后是final类。当一个类被声明为final时，表示该类不能被继承。这通常用于防止扩展某些关键功能的类，确保类的设计和实现不被修改。

在多线程环境中，使用final关键字可以帮助确保对象在构造完成后，其引用不会改变，这对线程安全是有帮助的。

总的来说，使用final关键字可以提高代码的清晰度和安全性，确保重要的行为和结构不被意外修改。这对设计API和类库特别重要。

JDK8新特性

lambda表达式

Lambda表达式是Java 8引入的一种新特性，它允许我们以更简洁的方式表示可以传递的行为。简而言之，Lambda表达式是可以实现函数式接口的匿名函数，通常用于简化代码和实现函数式编程。

Lambda表达式的基本语法为(参数) -> 表达式，其中参数部分可以有一个或多个参数，也可以没有参数，而->是Lambda运算符，后面的部分是要执行的具体逻辑。

“Lambda表达式可以与函数式接口结合使用。函数式接口是只有一个抽象方法的接口，可以用@FunctionalInterface注解来明确标识。例如：

使用Lambda表达式可以大大简化代码，减少冗长的匿名内部类实现，提高代码的可读性。此外，Lambda表达式常用于集合操作，如与Stream API结合使用，能够方便地进行过滤、映射和排序等操作。

例如，我们可以使用Lambda表达式处理一个字符串列表，过滤出以‘A’开头的名字：

方法引用

方法引用是Java 8引入的一种语法特性，它允许我们直接引用类或对象中的方法，而不需要使用Lambda表达式的完整语法。它旨在简化代码，使其更加简洁和可读.

方法引用主要有四种类型：

静态方法引用：引用类的静态方法，例如ClassName::methodName。
实例方法引用（特定对象）：引用某个对象的实例方法，例如instance::methodName。
实例方法引用（任意对象）：引用某个类型的实例方法，可以由任意对象调用，例如ClassName::methodName。
构造方法引用：引用类的构造方法，例如ClassName::new。

方法引用常用于Stream API中的操作，如对集合进行处理时。例如，可以使用方法引用来输出每个元素：

总结来说，方法引用是Java 8中的一个非常实用的特性，它使得代码更加简洁、可读，并且与函数式编程理念相结合，为我们提供了更好的代码构建方式。

函数式接口

函数式接口是Java 8引入的一种只包含一个抽象方法的接口。它允许我们使用Lambda表达式来实现该接口，从而使代码更加简洁和易于理解。

虽然使用@FunctionalInterface注解是可选的，但推荐这样做，这样可以让其他开发者清楚地知道这个接口的意图，编译器也会帮助检查是否符合函数式接口的要求。

在Java 8中，有几个常用的内置函数式接口，例如：

Runnable：没有参数且没有返回值的操作。
Consumer<T>：接受一个参数并对其执行某些操作，没有返回值。
Supplier<T>：不接受参数，返回一个结果。
Function<T, R>：接受一个参数并返回一个结果。
Predicate<T>：接受一个参数并返回一个布尔值。

函数式接口的主要优势在于它支持函数式编程，使得代码更简洁且易于维护。使用Lambda表达式可以减少代码的冗余，提高可读性，同时促进更灵活的编程风格。

以上就是我对函数式接口的理解。

Optional类

Optional 类是 Java 8 引入的一种容器对象，旨在表示可能存在的值或缺失的值，主要用于解决空指针异常（NullPointerException）的问题。

我们可以通过几种方式来创建 Optional 对象：

使用 Optional.of(value) 创建一个包含非空值的 Optional 对象。
使用 Optional.ofNullable(value) 创建一个可以容纳 null 的 Optional 对象。
使用 Optional.empty() 创建一个空的 Optional 对象。

Optional 提供了多种方法来处理值的存在性。比如：

isPresent()：检查 Optional 中是否有值。
ifPresent(Consumer)：如果值存在，执行给定的操作。
orElse(T)：如果有值则返回该值，否则返回提供的默认值。
orElseThrow(Supplier)：如果有值则返回该值，否则抛出指定异常。

使用 Optional 的主要优势在于它能够减少空指针异常的发生，增强代码的可读性和可维护性。通过明确表示值的存在性，我们可以更安全地编写代码。

Java和C++的区别

Java 和 C++ 是两种广泛使用的编程语言，各自有其独特的特性和适用场景。Java 是一种面向对象的高级语言，注重跨平台性，而 C++ 是一种多范式的编程语言，结合了面向过程和面向对象的特性。

Java 是一种纯粹的面向对象编程语言，几乎所有的代码都封装在类中。与此不同，C++ 支持多种编程范式，包括面向过程和面向对象，允许更灵活的编程风格。

Java 具有自动垃圾回收机制，开发者无需手动管理内存，这减少了内存泄漏的风险。而 C++ 则需要开发者手动管理内存，使用 new 和 delete 进行内存分配和释放，这可能导致内存泄漏或指针问题。

Java 不支持指针，只有引用，增加了安全性。而 C++ 支持指针，可以直接操作内存，这提供了更大的灵活性，但也带来了更多的复杂性。

Java 程序编译为字节码，通过 Java 虚拟机（JVM）运行，实现了平台无关性。相对而言，C++ 编译为机器码，直接在操作系统上运行，通常具有更高的性能，但不具备平台无关性。

Java 拥有丰富的标准库，提供大量的 API 和框架，特别是在网络编程和图形用户界面方面。而 C++ 的标准库相对较小，但提供了强大的 STL（标准模板库），包含各种算法和数据结构。

Java 内置对多线程的支持，提供了丰富的线程类和同步机制。而 C++ 从 C++11 开始支持多线程，但在此之前，要依赖平台特定的库。

Java 使用 try-catch 进行异常处理，并且支持检查性异常（Checked Exceptions），要求开发者在编译时处理异常。C++ 也支持 try-catch，但不强制检查异常。

总的来说，Java 更适合需要跨平台性和企业级应用的开发，而 C++ 则在系统编程和对性能要求较高的场景中更具优势。选择哪种语言通常取决于项目的具体需求和目标。

Oracle JDK 和 OpenJDK 的对比

Oracle JDK 和 OpenJDK 是 Java 开发和运行环境的两个主要实现，它们在多个方面存在显著的区别。首先，Oracle JDK 是由 Oracle 公司提供的商业版本，包含所有 Java 标准功能及一些额外的商业特性，例如 Java Mission Control 和 Java Flight Recorder，这些工具对于性能分析和监控很有帮助。而 OpenJDK 是 Oracle 开放的开源实现，遵循 GNU 通用公共许可证，允许开发者自由使用、修改和分发，适用于开源项目和学习。

在许可证方面，Oracle JDK 采用的是商业许可证，特别是在商业用途上，用户通常需要购买许可证。自 Java 11 版本开始，Oracle 的更新和支持政策有所变化，而 OpenJDK 则是完全开源的，用户可以自由获取并根据需要构建和分发。功能方面，虽然 OpenJDK 提供了 Java SE 的核心功能，但可能缺少一些 Oracle JDK 的专有工具和特性。

更新和支持也是两者之间的一个重要区别。Oracle JDK 提供长期支持（LTS）版本，如 Java 8、Java 11 和 Java 17，并定期进行安全更新。相对而言，OpenJDK 的更新由社区支持，用户可以根据需求自行构建和更新。

在使用场景上，Oracle JDK 适合需要商业支持的企业和生产环境，而 OpenJDK 更适合开源项目、个人开发和学习等不需要商业支持的场合。总体而言，选择 Oracle JDK 还是 OpenJDK 取决于具体的需求。如果您需要稳定的商业支持和额外的工具，Oracle JDK 将是更好的选择；如果希望使用灵活的开源解决方案，OpenJDK 则是理想的选择。

final、finally、finalize区别

首先，final 是一个关键字，用于声明不可更改的特性。当一个变量被声明为 final 时，它的值就不能再被修改，通常被用于定义常量;当一个方法被声明为 final 时，它不能被子类重写;如果一个类被声明为 final，则该类不能被继承;

其次，finally 是用于异常处理的关键字。在一个 try-catch 块中，finally 代码块中的内容无论异常是否被捕获都会执行。这通常用于确保资源的释放，例如在文件操作或数据库连接中，确保相关资源能够被正确关闭。

最后，finalize 是 java.lang.Object 类中的一个方法，用于在对象被垃圾回收之前进行清理活动。可以在自定义类中重写 finalize 方法，以便在对象回收之前执行一些清理操作，如释放资源。然而，finalize 方法在 Java 9 之后已被标记为过时，因此不再推荐使用，开发者更应该利用 try-with-resources 来管理资源。

总的来说，final 用于定义不可变的属性，finally 确保代码在异常处理后执行，而 finalize 是一个清理资源的方法，虽然在现代 Java 编程中不再推荐使用。

this关键字的用法

区分成员变量和参数：使用 this 区分同名的成员变量和参数。
调用当前对象的方法：显式调用当前对象的其他方法。
在构造函数中调用另一个构造函数：使用 this 调用同一类的另一个构造函数。
返回当前对象：实现链式调用的能力。

super关键字的用法

访问父类的成员变量：解决子类和父类成员变量同名的问题。
调用父类的方法：在子类中调用父类的方法，尤其是在重写时。
调用父类的构造函数：在子类构造函数中初始化父类的属性。
访问父类构造函数的重载版本：通过 super 调用父类构造函数的不同版本。

break ,continue ,return 的区别及作用

break：用于终止循环或 switch 语句，跳出当前循环体。
continue：用于跳过当前循环的剩余部分，直接进入下一次循环的迭代。
return：用于从方法返回一个值或提前终止方法的执行。

在 Java 中，如何跳出当前的多重嵌套循环

使用标签（Label）和 break 语句：使用标签配合 break 语句直接跳出外层循环。标签是一个标识符，后跟冒号，可以用于标识循环体。
使用标志变量：使用布尔型标志变量来指示何时应该退出外层循环。这种方法避免了使用标签，增加了代码的可读性。
抛出异常（不推荐，特殊场景）

面向对象五大基本原则是什么

单一职责原则：一个类应该只有一个职责。这意味着一个类应该专注于完成特定的功能，避免承担过多的责任。当一个类有多个职责时，修改某一职责可能会影响其他职责，从而导致系统的不可预测性和复杂性。
开放封闭原则：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着我们应该可以通过扩展现有的代码来添加新功能，而不必修改已有的代码。这可以通过使用抽象类和接口，以及设计模式（如策略模式、工厂模式）来实现，减少对现有代码的改动。
里氏替换原则：子类型必须能够替换掉它们的父类型而不影响程序的正确性。这意味着当我们使用基类的引用时，不应该因为使用了子类而出现错误。子类应该完全符合父类的行为规范。
接口隔离原则：不应该强迫一个客户端依赖于它不使用的接口。这意味着我们应该将大接口拆分为多个小接口，以便实现类只需依赖于它们所需要的接口。这样可以减少实现类的复杂性，提高灵活性和可维护性。
依赖倒置原则：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

JVM运行时数据区有哪些

方法区：存储类信息、常量池等。
堆：存放对象实例和数组。
虚拟机栈：存储方法调用信息和局部变量。
本地方法栈：存储本地方法调用的信息。
程序计数器：指向当前执行的字节码指令。

静态变量和实例变量区别

静态变量和实例变量是Java中两种重要的成员变量类型，它们的主要区别可以从以下几个方面来分析：

(1) 所属关系

“首先从所属关系来看：

静态变量属于类本身，也称为类变量
实例变量属于类的实例(对象)”

(2) 内存分配与生命周期

“其次在内存分配方面：

静态变量在类加载时初始化，存储在堆内存的静态区，生命周期与类相同
实例变量在对象实例化时创建，存储在堆内存，生命周期与对象实例相同”

(3) 访问方式

“访问方式上：

静态变量可以通过类名直接访问(推荐)，也可以通过对象访问(不推荐)
实例变量必须通过对象实例访问”

(4) 典型应用

静态变量：工具类的常量、全局计数器、共享配置
实例变量：对象属性（如Person类的name/age）

(5)注意

静态变量的线程安全问题（如用AtomicInteger代替int）
静态变量可能导致内存泄漏（特别是持有大对象时）
实例变量与继承体系的关系（子类会继承但可能隐藏父类变量）

什么是内部类

内部类是定义在另一个类内部的类，是Java语言的一个重要特性。它主要有四种类型：成员内部类、静态内部类、方法内部类和匿名内部类。

(1) 成员内部类

“成员内部类是最常见的类型：

定义在外部类的成员位置
可以访问外部类的所有成员，包括private成员
不能包含静态成员（除了static final常量）
编译后会生成独立的.class文件”

(2) 静态内部类

“静态内部类使用static修饰：

不能直接访问外部类的非静态成员
可以包含静态和非静态成员
不持有外部类的引用
常用于工具类实现”

(3) 方法内部类

“方法内部类定义在方法内部：

只能访问方法中的final或effectively final局部变量
作用域仅限于定义它的方法
适合在方法内封装特定逻辑”

(4) 匿名内部类

“匿名内部类没有类名：

通常用于实现接口或继承类
只能使用一次
常用于事件监听器和回调机制”

实际应用场景

“在实际开发中：

成员内部类适合紧密关联但需要独立封装的逻辑
静态内部类适合与外部类相关但不依赖实例的工具类
匿名内部类广泛用于Swing/AWT事件处理和Java 8之前的函数式编程
方法内部类适合临时使用的辅助类”

补充注意事项（加分项）

“还需要注意：

内部类会持有外部类的引用（静态内部类除外），可能导致内存泄漏
序列化内部类时要特别小心
过度使用内部类可能使代码难以维护
在Lambda表达式出现后，很多匿名内部类场景可以被替代”

IO流

java中的IO流分为几种

Java IO流按数据流向分为输入流和输出流，按数据类型分为分字节流和字符流，字节流操作二进制数据，字符流处理文本。在实际开发中比如读配置文件用 BufferedReader，读图片用 FileInputStream。我会优先用处理流（如缓冲流）提升性能，并通过 try-with-resources 确保流关闭。高并发场景下，NIO可能更合适。

BIO、NIO、AIO有什么区别

BIO是同步阻塞模型，每个连接独占线程，适合低并发场景；NIO通过多路复用实现单线程管理多连接，适合高并发；AIO是异步回调模型，理论上性能最高，但编程复杂且Linux支持有限。实际开发中，NIO（如Netty）是主流选择，例如微服务网关（如Spring Cloud Gateway）底层用Netty，就是因为NIO的高并发能力。

File的常用方法有哪些

File 类常用于检查文件是否存在（exists()）、创建文件（createNewFile()）、遍历目录（listFiles()）等。需要注意 mkdirs() 可自动创建父目录，而 delete() 只能删除空目录。

1. 文件/目录基本信息

方法	说明	示例
`exists()`	判断文件/目录是否存在	`file.exists()`
`isFile()`	判断是否为文件	`file.isFile()`
`isDirectory()`	判断是否为目录	`file.isDirectory()`
`getName()`	获取文件名或目录名	`file.getName()`
`getPath()`	获取相对路径	`file.getPath()`
`getAbsolutePath()`	获取绝对路径	`file.getAbsolutePath()`
`length()`	获取文件大小（字节数）	`file.length()`
`lastModified()`	获取最后修改时间（毫秒时间戳）	`file.lastModified()`

2. 文件/目录操作

方法	说明	示例
`createNewFile()`	创建新文件（需父目录存在）	`file.createNewFile()`
`mkdir()`	创建单层目录	`file.mkdir()`
`mkdirs()`	创建多层目录	`file.mkdirs()`
`delete()`	删除文件或空目录	`file.delete()`
`renameTo(File dest)`	重命名或移动文件	`file.renameTo(new File(“new.txt”))`

3. 目录内容查询

方法	说明	示例
`list()`	返回目录下的文件名数组（String[]）	`dir.list()`
`listFiles()`	返回目录下的文件对象数组（File[]）	`dir.listFiles()`
`list(FilenameFilter filter)`	过滤文件名	`dir.list((dir, name) -> name.endsWith(“.txt”))`

4. 路径相关

方法	说明	示例
`getParent()`	获取父目录路径	`file.getParent()`
`getParentFile()`	获取父目录的File对象	`file.getParentFile()`
`separator`	系统路径分隔符（静态常量）	`File.separator`

5. 其他实用方法

方法	说明	示例
`canRead()` / `canWrite()`	检查读写权限	`file.canRead()`
`setReadable(boolean)`	设置读权限	`file.setReadable(true)`
`setWritable(boolean)`	设置写权限	`file.setWritable(false)`

在使用HashMap的时候，用String做key有什么好处

String 是 HashMap 最常用的 key 类型，主要因为它的不可变性、高效的哈希计算、天然线程安全，以及良好的哈希分布特性。

不可变性：String 是 final 类，内容不可变，作为 key 能保证一致性，如果 key 被修改（如 StringBuilder），会导致哈希值变化，HashMap 无法正确检索；
哈希码缓存：String 在首次计算 hashCode() 后会缓存结果（内部 hash 字段），后续调用直接返回缓存值，避免重复计算，提升性能（尤其在频繁操作 HashMap 时）；
哈希分布均匀性：String 的哈希算法（s[0]*31^(n-1) + s[1]*31^(n-2) + …）使用质数 31 作为乘数，能有效减少冲突，分布均匀性降低 HashMap 链表转红黑树的概率，保证 O(1) 时间复杂度；
线程安全与 null 支持：不可变性天然线程安全，多线程环境下无需同步，允许 null 作为 key（某些场景如配置默认值需要）。