最新的Java常见面试题和答案合集介绍

2021年11月29日02:58:32 发表评论 761 次浏览
最新的Java常见面试题和答案合集介绍

毫无疑问，Java 是获得丰厚工作的主要编程选择之一。毕竟，基于类的、通用的、面向对象的编程语言是世界上使用最广泛的编程语言之一。

凭借 众多强大的功能，该编程语言不仅受到经验丰富的专家的青睐，而且也受到编程世界的新手的追捧。因此，这里是有关 Java 的热门面试问题和答案，它们将帮助你完成 Java 工作，或者至少提高你的学习水平。建议初学者和专业人士以及软件开发人员和 Android 应用程序开发人员使用 Java 面试问题。 

热门的Java常见面试题和答案合集

我们还建议你在开始准备 Java 面试之前使用此Java Cheat Sheet来提高你的 Java 技能。本文仅与 Core Java 面试相关。 

文章已分为不同的部分和类别，以便你有组织地准备面试，分为以下几类：

基本的 Java 面试问题

问题：什么是Java？

答： Java 是一种面向对象的高级通用编程语言，最初由 James Gosling 设计，并由 Oracle 公司进一步开发。它是世界上最流行的编程语言之一。要了解有关什么是 Java 的更多信息，请单击此处了解 Java、功能和组件的所有详细信息。

问题：解释一下Java虚拟机？ 

答： JVM 是一个程序，它解释中间 Java 字节码并生成所需的输出。正是由于字节码和 JVM，用 Java 编写的程序具有高度的可移植性。 

最新的Java常见面试题和答案合集介绍

问：Java 有什么特点？

答：以下是 Java 编程语言的各种特性：

  • 高性能——使用 JIT（Just-In-Time）编译器可以在 Java 中实现高性能。JIT 编译器将 Java 字节码转换为机器语言代码，然后由 JVM 执行。
  • 多线程——一个线程是一个执行流。JVM 创建一个线程，称为主线程。Java 允许使用扩展线程类或实现 Runnable 接口来创建多个线程。
  • OOPS 概念——Java 遵循各种 OOPS 概念，即抽象、封装、继承、面向对象和多态
  • 平台独立性——Java 利用 Java 虚拟机或 JVM，它允许单个 Java 程序在多个平台上运行而无需任何修改。

你可能想在 此处详细查看 Java 功能。 

Java常见面试题有哪些：Java 如何实现高性能？

答：在即时编译中，所需的代码在运行时执行。通常，它涉及将字节码转换为机器代码，然后直接执行。为了实现高性能，Java 可以利用即时编译。JIT 编译器在 Java 中默认启用，并在调用方法后立即激活。然后它将 Java 方法的字节码编译为本机机器码。之后，JVM 直接调用编译后的代码，而不是解释它。这可以提高性能。

问题：JVM、JRE、JDK的区别

回答： 

参数 JVMJREJDK
完整形式Java虚拟机Java运行时环境Java 开发工具包
目的它提供了一个运行时环境来执行 Java 字节码。 它是一组用于开发 Java 应用程序的软件工具。 它是用于开发 Java 应用程序的软件开发环境。 
存在 它是我们运行 Java 类时创建的运行时实例。 它是物理存在的。它是物理存在的。
执行它的实现被称为 JRE 它是JVM的实现 它是 Oracle Corporation 发布的以下任一给定 Java 平台的实现：标准版 Java 平台企业版 Java 平台微型版Java平台

问题：什么是 JIT 编译器？

Java面试题解析： JIT 编译器在程序执行后运行，将代码编译成更快的形式，托管 CPU 的原生指令集。JIT 可以访问动态运行时信息，而标准编译器不能访问并且可以进行更好的优化，例如内联经常使用的函数。 

问题：要使用哪个 Java IDE，为什么？

答：Java IDE 是一种软件，它允许 Java 开发人员轻松编写和调试 Java 程序。它基本上是各种编程工具的集合，可通过单个界面访问，以及一些有用的功能，例如代码完成和语法突出显示。Codenvy、Eclipse 和 NetBeans 是一些最流行的 Java IDE。

问题：Java 是一种独立于平台的语言。为什么？

答： Java 编程语言不依赖于任何特定的硬件或软件，因为它由编译器编译，然后转换为字节码。字节码与平台无关，可以在多个系统上运行。唯一的要求是Java 需要一个运行时环境，即JRE，它是一组用于开发Java 应用程序的工具。

问题：解释类型转换

答：将一种数据类型的变量赋值给另一种数据类型的变量的概念。布尔数据类型是不可能的。

它有两种类型：

  • 隐式
  • 显式

问题：解释不同类型的类型转换？

回答：

不同类型的类型转换是：

  • 隐式：将值从较小的数据类型存储到较大的数据类型。它由编译器自动完成。
  • 显式：将较大数据类型的值存储到较小数据类型中。这导致信息丢失：
最新的Java常见面试题和答案合集介绍
  • 截断：将值从较大的数据类型转换为较小的数据类型时，额外的数据将被截断。让我们看看代码示例： 
  float f = 3.14f; 
   int i  = (int) f;

执行后，我将只包含 3 个，并在我们从浮点数变为整数时截断其余部分。 

  • 超出范围：类型转换不允许分配超过其范围的值；如果发生这种情况，那么在这种情况下数据就会丢失。 

让我们明白这一点： 

long l = 123456789; 
byte b = (byte) l;      // byte 和 long 的范围不同，所以会有数据丢失。

问题：解释 Java 中的访问修饰符。

答：访问修饰符是 Java 中预定义的关键字，用于限制对另一个类中的类、方法、构造函数和数据成员的访问。

Java 支持四种访问修饰符：

  • Default
  • Private
  • Protected
  • Public
修饰符DefaultPrivateProtectedPublic
同一个类yesyesyesyes
相同的包子类yesnoyesyes
同包非子类yesnoyesyes
同包非子类nonoyesyes
不同的包非子类nononoyes

问题：局部变量的默认值是什么？

答：局部变量没有初始化为任何默认值，原语和对象引用都没有。

Java常见面试题有哪些：OOPS Java 面试题

问题：什么是面向对象编程？ 

答：OOP 是一种以对象而非函数为中心的编程范式。它不是一种工具或编程语言，而是一种旨在克服过程式编程缺陷的范式。有许多语言遵循 OOP 概念，一些流行的语言是 Java、Python、Ruby 等。一些框架也遵循 OOPs 的概念，Angular 就是这样一种框架。

问题：你能解释一下 Oops 的概念吗？

答：以下是各种 OOPS 概念：

  • 抽象——代表基本特征而不需要给出背景细节。该技术用于为某些特定应用程序创建新的合适的数据类型
  • 聚合——所有对象都有其独立的生命周期，但存在所有权。除了父对象之外，任何子对象都不能属于其他对象
  • 关联——两个对象之间的关系，其中每个对象都有自己的生命周期。没有所有权
  • 类——一组相似的实体
  • 组合——也称为死亡关系，是一种特殊的聚合形式。子对象没有生命周期。因此，如果关联的父对象被删除，它们会自动被删除
  • 封装——指将数据和代码封装到一个实体中。允许一个类的变量只能被父类访问，其他类不能访问
  • 继承——当一个对象获得其他对象的属性时，称为继承。它导致在所涉及的类之间形成亲子关系。提供组织和构建软件的强大而自然的机制
  • 对象——表示一个类的实例。任何类都可以有多个实例。一个对象包含数据以及对数据进行操作的方法
  • 多态性——指方法、对象或变量具有多种形式的能力

决策 Java 面试问题

问题：break 和 continue 的区别

回答：

breakcontinue
与 loop 和 switch 语句一起使用仅用于循环语句。
它终止循环或开关块。它不会终止，而是跳到下一次迭代。

类、对象和方法 Java 面试题

问题：什么是对象？

答： Java 类的实例称为对象。Java 对象的两个重要属性是行为和状态。一旦 JVM 遇到 new 关键字，就会创建一个对象。

问题：在 Java 中定义类 

答：类是相似数据类型的对象的集合。类是用户定义的数据类型，其行为类似于编程语言的内置类型。 

类的语法： 

class Sample{
member variables
methods() 
}

类示例：

public class Shape
   {
      String Shape name;
      void area()
        {
        }
      void volume ()
        {
        }
      void num_sides()
        {
        }
   }

问题：解释一下什么是静态方法和变量？

答：一个类有两个部分，一个声明变量，另一个声明方法，分别称为实例变量和实例方法。之所以这样称呼它们，是因为每次实例化一个类时，都会创建它们的一个新副本。 

可以创建所有对象通用的变量和方法，并通过将它们声明为静态来访问，而无需使用特定对象。其他类和方法也可以使用静态成员。 

问题：构造函数是什么意思？

答：构造函数是一种方法，它的名称与其所属的类的名称相同。一旦创建了新对象，就会调用对应于该类的构造函数。尽管用户可以显式地创建一个构造函数，但一旦创建了一个类，它就会自行创建。这称为默认构造函数。构造函数可以重载。

注意： - 如果显式创建的构造函数有参数，则需要创建另一个没有参数的构造函数。

问题：请解释Java中的局部变量和实例变量。

答：只能被声明它们的方法或代码块访问的变量称为局部变量。另一方面，实例变量可被类中的所有方法访问。局部变量是在方法或代码块内声明的，而实例变量是在类内但在方法外声明的。即使未分配，实例变量的值也可以为 null、0、0.0 或 false。对于需要赋值的局部变量，情况并非如此，如果不赋值会产生错误。局部变量在方法被调用时自动创建，方法一退出就销毁。要创建实例变量，必须使用new关键字。

问题：请解释Java中的方法覆盖？

答：Java 中的方法覆盖允许子类提供已由其父类或超类提供的方法的特定实现。如果子类方法和超类方法具有：

  • 同名
  • 同样的论点
  • 相同的返回类型

问题：重载是什么意思？

答：重载是两个或多个不同的方法（方法重载）或运算符（运算符重载）具有相同表示的现象。例如，+ 运算符将两个整数值相加，但连接了两个字符串。同样，名为 Add 的重载函数可用于两个目的

  1. 两个整数相加
  2. 连接两个字符串

与方法覆盖不同，方法重载需要两个重载的方法具有相同的名称但不同的参数。重载的函数可能有也可能没有不同的返回类型。

Java常见面试题和答案合集：final 关键字在 Java 中扮演什么角色？它对变量、方法和类有什么影响？

答：Java 中的 final 关键字是一个非访问修饰符，仅适用于类、方法或变量。它根据使用的上下文有不同的用途。

  • 一个类

当一个类被声明为 final 时，它就不能被子类化，即没有类可以扩展 final 类。

  • 一个方法

任何伴随 final 关键字的方法都被限制被子类覆盖。

  • 变量

后跟 final 关键字的变量不能更改它在程序执行期间保存的值。所以，它的行为就像一个常数。

数组、字符串和向量 Java 面试题

问题：你能比较一下 Array 和 ArrayList 吗？

答：数组需要在声明时给出大小，而数组列表不一定需要大小，因为它会动态更改大小。要将对象放入数组，需要指定索引。但是，对于数组列表没有这样的要求。虽然数组列表已参数化，但数组未参数化。

问题：请解释 String、String Builder 和 String Buffer 之间的区别。

答：字符串变量存储在常量字符串池中。随着字符串引用的变化，删除旧值变得不可能。例如，如果字符串存储了值“Old”，则添加新值“New”不会删除旧值。然而，它仍然会在那里，处于休眠状态。在字符串缓冲区中，值存储在堆栈中。随着字符串引用的更改，新值将替换旧值。String Buffer 是同步的（因此是线程安全的），并且提供的性能比 String Builder 慢，后者也是 String Buffer 但不是同步的。因此，String Builder 的性能比 String Buffer 快。

问题：Java 中的字符串池是什么？

答：堆内存中存放的字符串集合指的是String池。每当创建新对象时，都会检查它是否已经存在于字符串池中。如果它已经存在，则返回对变量的相同引用，否则在字符串池中创建新对象，并返回相应的引用。

高级Java 面试问题

接口和抽象类 Java 面试题

问题：你对 Java 中的接口了解多少？

答：Java 接口是一个模板，它只有方法声明，没有方法实现。这是在 Java 中实现多重继承的一种变通方法。关于 Java 接口的一些值得记住的要点是：

  • 实现接口的类必须为接口中声明的所有方法提供实现
  • 接口中的所有方法在内部都是 public abstract void
  • 接口中的所有变量在内部都是 public static final
  • 类不扩展而是实现接口

问题：抽象类与接口有何不同？

答：Java中的抽象类和接口有几个区别，总结如下：

  • 成分–抽象类包含实例变量，而接口只能包含常量。
  • 构造函数和实例化——虽然接口既没有构造函数也不能实例化，抽象类可以有一个默认的构造函数，每当具体子类被实例化时就会调用它。
  • 方法的实现——实现接口的所有类都需要为其包含的所有方法提供一个实现。但是，扩展抽象类的类不需要实现其中包含的所有方法。在具体的子类中只需要实现抽象方法。
  • 方法类型——任何抽象类都有抽象方法和非抽象方法。另一方面，接口只有一个抽象方法。

问题：请解释抽象类和抽象方法是什么意思？

答：Java 中的抽象类是无法实例化的类。这样的类通常用于为子类提供基础以进行扩展以及实现抽象方法并覆盖或使用抽象类中定义的已实现方法。要创建一个抽象类，它后面需要跟abstract 关键字。任何抽象类都可以同时具有抽象和非抽象方法。Java 中只有声明没有实现的方法被称为抽象方法。此外，抽象方法名称后跟抽象关键字。任何扩展抽象类的具体子类都必须提供抽象方法的实现。

问题：什么是多重继承？Java 是否支持多重继承？如果没有，如何实现？

答：如果一个子类或子类有两个父类，那就意味着它继承了两个基类的属性，就是多重继承。Java 没有多重继承，因为如果父类具有相同的方法名称，那么在运行时就会变得不明确，编译器无法决定从子类执行哪个方法。

包 Java 面试问题

问题：Java 中有哪些包？说明 Java 中包的一些优点？

答：包是 Java 将各种类和/或接口组合在一起的方式。对象的功能决定了它们的分组方式。包装器充当类的“容器”。

下面列出了 Packages 的优点：

  1. 其他程序的类可以重用。
  2. 两个相同的类可以存在于两个不同的包中。
  3. 包可以隐藏类，从而拒绝访问某些仅供内部使用的程序和类。
  4. 他们还将设计与编码分开。

多线程 Java 面试题

问题：如何在 Java 中创建线程？举例说明。

Java面试题解析：要在 Java 中创建线程，有两种选择：

  • 扩展线程类 ——线程在 java.lang.Thread 类中可用。要创建线程，你需要扩展线程类并覆盖 run 方法。例如，
public class Addition extends Thread {
public void run() {
}
}

使用线程类的一个缺点是无法扩展任何其他类。

尽管如此，还是可以在类中重载 run() 方法

  • 实现可运行接口——另一种在 Java 中创建线程的方法是实现可运行接口。为此，需要为 run() 方法提供实现，该方法定义在
interface. For example,
public class Addition implements Runnable {
public void run() {
}
}

问题：我们为什么要使用 yield() 方法？

答：yield() 方法属于线程类。它将当前运行的线程转移到可运行状态，并允许其他线程执行。换句话说，它为同等优先级的线程提供了运行的机会。因为 yield() 是一个静态方法，它不会释放任何锁。

问题：你能解释一下 Java 中的线程生命周期吗？

答：线程生命周期具有以下状态，并遵循以下顺序：

  • New –在线程生命周期的第一个状态中，创建了线程实例，并且尚未调用 start() 方法。该线程现在被认为是活动的。
  • Runnable –在调用 start() 方法之后，但在调用 run() 方法之前，线程处于可运行状态。线程也可以从等待或休眠状态返回到可运行状态。
  • 运行 -线程在调用 run() 方法后进入运行状态。这是线程开始执行的时间。
  • Non-Runnable –尽管线程处于活动状态，但它无法运行。通常，它会在一段时间后返回到可运行状态。
  • 已终止 -一旦 run() 方法完成其执行，线程将进入终止状态。现在已经没有生命了。
最新的Java常见面试题和答案合集介绍

问题：Runnable 接口何时优先于线程类，反之亦然？

答：在 Java 中，只能扩展一个类。因此，只有在不需要扩展其他类时才扩展线程类。如果一个类需要扩展线程类以外的其他类，那么我们需要使用 Runnable 接口。

问题：请比较 notify() 和 notifyAll() 方法。

答：notify()方法用于发送信号以唤醒等待池中的单个线程。相反，notifyAll()方法用于发送信号以唤醒等待池中的所有线程。

Java常见面试题有哪些：如何区分进程和线程？

答：进程和线程之间有几个根本区别，如下所述：

  • 定义 -进程是程序的执行实例，而线程是进程的子集。
  • 更改 –对父进程所做的更改不会影响子进程。但是，主线程中的更改可能会导致同一进程的其他线程的行为发生更改。
  • 通信——虽然进程需要进程间通信来与兄弟进程通信，但线程可以直接与属于同一进程的其他线程通信。
  • 控制 –进程由操作系统控制并且只能控制子进程。相反，线程由程序员控制并且能够对它们所属的同一进程的线程进行控制。
  • 依赖——进程是独立的实体，而线程是依赖的实体
  • 内存——线程在共享内存空间中运行，但进程在单独的内存空间中运行。

问题：join() 方法是什么？举个例子。

答：我们使用 join() 方法将一个线程与当前正在运行的线程的末尾连接起来。它是一个非静态方法并且有一个重载版本。考虑下面的例子：

public static void main (String[] args) {
Thread t = new Thread();
t.start();
t.join();
}

主线程在上面提到的例子中开始执行。一旦执行到达代码 t.start()，线程 t 就会开始执行它的堆栈。JVM 在主线程和那里的线程之间切换。一旦执行到达 t.join()，则线程 t 将单独执行并允许完成其任务。之后，主线程恢复执行。

问题：如何在 Java 中停止线程？

答：Java 中有三种方法可以停止线程的执行：

  • 阻塞 -此方法用于将线程置于阻塞状态。一旦满足阻塞条件，执行就会恢复。例如，ServerSocket.accept() 是一种阻塞方法，它侦听传入的套接字连接并仅在建立连接时恢复被阻塞的线程。
  • Sleeping –此方法用于将线程的执行延迟一段时间。使用 sleep() 方法的线程被称为进入睡眠状态。它一醒来就进入可运行状态，即睡眠状态结束。sleep() 方法的大括号内提到了线程需要进入睡眠状态的时间。它是一种静态方法。
  • 等待——尽管可以在任何 Java 对象上调用它，但只能从同步块中调用 wait() 方法。

异常处理 Java 面试题

问题：你能解释一下 Java 中的各种类型的异常吗？另外，请告诉我们处理它们的不同方法。

答：Java 提供了两种类型的异常：

  • 检查异常——除了运行时异常和错误之外，扩展 Throwable 类的类称为检查异常。编译器会在编译时检查此类异常。这些类型的异常必须具有适当的 try/catch 块或使用 throws 关键字声明。ClassNotFoundException 是一个检查异常。
  • Unchecked Exceptions –编译器在编译期间不会检查此类异常。因此，编译器不需要处理未经检查的异常。算术异常和 ArrayIndexOutOfBounds 异常是未经检查的异常。

Java 中的异常有两种处理方式：

声明 throws 关键字——我们可以在方法末尾使用 throws 关键字声明异常。例如：

class ExceptionCheck{
public static void main(String[] args){
add();
}
public void add() throws Exception{
addition();
}
}

使用 try/catch –任何预计会产生异常的代码段都被 try 块包围。发生异常时，它会被 try 块后面的 catch 块捕获。例如，

class ExceptionCheck{
public static void main (String[] args) {
add();
}
public void add(){
try{
addition();
}
catch(Exception e)
{
e.printStacktrace();
}
}
}

问题：你能画出 Java 异常层次结构吗？

回答：  

最新的Java常见面试题和答案合集介绍

问题：是否可以在单个 try 块下编写多个 catch 块？

答：是的，可以在一个 try 块下编写多个 catch 块。但是，该方法需要从特定到通用。以下示例演示了相同的内容：

public class Example {
public static void main(String args[]) {
try {
int a[]= new int[10];
a[10]= 10/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic exception in first catch block");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out of bounds in second catch block");
}
catch(Exception e)
{
System.out.println("Any exception in third catch block");
}
}

问题：throw 关键字与 throws 关键字有何不同？

答： throws 关键字允许声明异常，而 throw 关键字用于显式抛出异常。检查的异常不能只用 throw 传播，但 throw 允许这样做而不需要任何其他东西。throws 关键字后跟一个类，而 throw 关键字后跟一个实例。throw 关键字在方法中使用，但 throws 关键字与方法签名一起使用。此外，不可能抛出多个异常，但可以声明多个异常。

问题：解释Java中的各种异常处理关键字？

回答：

Java中有两个关键的异常处理关键字，其次是第三个关键字final，处理异常后可能会使用也可能不会使用。

try：

如果代码段有机会出现异常或错误，则将其放置在 try 块中。当引发异常时，它会被 catch 块处理和捕获。

Try 块后面必须有一个 catch() 或一个 final() 或两个块。

catch：

当在 try 块中引发异常时，它会在 catch 块中处理。

finally：

无论异常如何，都会执行该块。它可以放在 try{} 或 catch {} 块之后。

问题：解释异常传播？

答：栈顶的方法如果没有被捕获就会抛出异常。它移动到下一个方法并继续这样直到被捕获。

例子：

public class Sum()
{
public static void main(String args[])
{
addition()
}
public void addition()
{
add();
}
}

上面代码的栈是：

add()
addition()
main()

如果在 add() 方法中发生的异常没有被捕获，则它移动到方法 add() 中。然后它被移动到 main() 方法，在那里执行流程停止。它被称为异常传播。

文件处理 Java 面试问题

问题：带有 .java 扩展名的空文件名是有效的文件名吗？

答：是的，Java 只允许用 .java 保存我们的 java 文件。它由 javac .java 编译并通过 java 类名运行。

我们举一个简单的例子：

public class Any()
{
public static void main(String args[])
{
System.out.println("Hello Java File here!");
}
}

编译：javac.java

运行：Java Any

集合 Java 面试问题

问题：Java 中的集合是什么意思？Java中集合的组成部分是什么？

答：Java 中的一组对象称为集合。Java.util 包包含日期和时间设施、国际化、遗留集合类等，用于收集的各种类和接口。或者，可以将集合视为用于存储对象和操作存储对象的设计的框架。你可以使用集合对对象执行以下操作：

  • 删除
  • 插入
  • 操纵
  • 搜索
  • 排序

以下是集合框架的各个组成部分：

  • 类 –数组列表、链接列表、列表和向量
  • 接口 –集合、列表、映射、队列、集合、排序映射和排序集合
  • Map – HashMap、HashTable、LinkedHashMap 和 TreeMap
  • 队列 -优先队列
  • 集合 –散列集、链接散列集和树集

问题：你将如何区分 HashMap 和 HashTable？

答：Java 中的 HashMap 是一个基于 Map 的集合类，用于存储键值对。表示为 HashMap<Key, Value> 或 HashMap<K, V> HashTable 是一个列表的数组，其中每个列表称为一个桶。HashTable 中包含的值是唯一的并且取决于键。方法在 HashMap 中不同步，关键方法在 HashTable 中同步。但是，HashMap 不具有线程安全性，而 HashTable 具有相同的线程安全性。对于迭代值，HashMap 使用迭代器，HashTable 使用枚举器。HashTable 不允许任何为 null，而 HashMap 允许一个 null 键和多个 null 值。在性能方面，HashTable 比较慢。相比之下，HashMap 速度更快。

问题：请解释 Map 及其在 Java 中的类型。

答：Java Map 是一个将键映射到值的对象。它不能包含重复的键，并且每个键只能映射到一个值。为了确定两个键是相同还是不同，Map 使用了 equals() 方法。Java中有4种类型的Map，描述如下：

  • HashMap -它是一个无序和未排序的映射，因此在不强调顺序的情况下是一个不错的选择。HashMap 允许一个空键和多个空值，并且不维护任何插入顺序。
  • HashTable –不允许任何空值并且具有同步的方法。由于它允许线程安全，因此性能很慢。
  • LinkedHashMap –比 HashMap 慢，但保持插入顺序并具有更快的迭代。
  • TreeMap –一种排序映射，支持使用构造函数构建排序顺序。

问题：Java 中的优先队列是什么意思？

回答： 优先级队列与常规队列一样，是一种抽象数据类型，只是具有与其包含的每个元素相关联的优先级。在优先级队列中，具有高优先级的元素在具有低优先级的元素之前被服务。优先级队列中的元素根据比较器或自然排序。优先级队列中元素的顺序代表它们的相对优先级。

问题：Java 中的 Set 是什么？另外，在 Java Collections 中解释它的类型。

答：在 Java 中，Set 是唯一对象的集合。它使用equals()方法来确定两个对象是否相同。Java 集合中的各种类型的 Set 是：

  1. Hash Set——一个无序和未排序的集合，它使用对象的哈希码来添加值。当集合的顺序不重要时使用
  2. Linked Hash Set——这是哈希集的有序版本，它维护所有元素的双向链表。在强制迭代顺序时使用。插入顺序与如何将元素添加到 Set 的顺序相同。
  3. Tree Set - Java 中的两个排序集合之一，它使用 Read-Black 树结构并确保元素以升序出现。

问题：关于集合，什么是有序和排序的？

回答：

  1. 有序

这意味着值以特定顺序存储在集合中，但顺序与值无关。例如List。

  1. 排序

这意味着集合的顺序取决于元素的值。例如SortedSet。

Java常见面试题和答案合集：杂项 Java 面试问题 

问题：请解释一下Java中的各种垃圾收集器？

答：Java 编程语言有四种类型的垃圾收集器：

  1. 串行垃圾收集器——仅使用一个线程进行垃圾收集，串行垃圾收集器通过保存所有应用程序线程来工作。它专为单线程环境而设计。由于串行垃圾收集器在执行垃圾收集时会冻结所有应用程序线程，因此最适合仅用于命令行程序。要使用串行垃圾收集器，需要打开 -XX:+UseSerialGC JVM 参数。
  2. Parallel Garbage Collector –也称为吞吐量收集器，并行垃圾收集器是 JVM 的默认垃圾收集器。它使用多个线程进行垃圾收集，就像串行垃圾收集器在垃圾收集期间冻结所有应用程序线程一样。
  3. CMS Garbage Collector – Concurrent Mark Sweep 的缩写，CMS 垃圾收集器使用多个线程来扫描堆内存以标记要驱逐的实例，然后扫描标记的实例。当 CMS 垃圾收集器持有所有应用程序线程时，只有两种情况：
    1. 标记年老代空间中引用的对象时
    2. 如果在执行垃圾收集时堆内存有一些变化，CMS 垃圾收集器通过使用更多的 CPU 来确保比并行垃圾收集器更好的应用程序吞吐量。要使用 CMS 垃圾收集器，需要打开 XX:+USeParNewGC JVM 参数。
  4. G1 垃圾收集器——用于大堆内存区域，G1 垃圾收集器的工作原理是将堆内存分成多个区域，然后在其中并行执行垃圾收集。与 CMS 垃圾收集器在STW（停止世界）情况下压缩内存不同，G1 垃圾收集器在回收内存后立即压缩空闲堆空间。此外，G1 垃圾收集器会优先处理垃圾最多的区域。使用 G1 垃圾收集器需要打开 –XX:+UseG1GC JVM 参数。

问题：Java 中的同步是什么意思？它最大的缺点是什么？

回答：如果多个线程尝试访问单个代码块，那么产生不准确结果的可能性就会增加。同步用于防止这种情况。使用同步关键字使线程需要一个密钥来访问同步代码。简单地说，同步一次只允许一个线程访问一个代码块。每个Java对象都有一把锁，而每把锁只有一把钥匙。一个线程只有在可以获得对象锁的密钥时才能访问同步方法。以下示例演示了同步：

public class ExampleThread implements Runnable {
public static void main (String[] args){
Thread t = new Thread();
t.start();
}
public void run(){
synchronized(object){
{
}
}

注意：建议避免对所有方法实现同步。这是因为当只有一个线程可以访问同步代码时，下一个线程需要等待。因此，它会导致程序性能下降。

问题：你能说出 execute()、executeQuery() 和 executeUpdate() 之间的区别吗？

Java面试题解析：

  • execute() –用于执行 SQL 查询。如果结果是 ResultSet（例如运行 Select 查询），则返回 TRUE；如果结果不是 ResultSet（例如运行 Insert 或 Update 查询），则返回 FALSE。
  • executeQuery() –用于执行 Select 查询。它返回非空的 ResultSet，即使没有记录与查询匹配。执行选择查询时必须使用 executeQuery() 方法，以便在有人尝试执行插入或更新语句时抛出带有“executeQuery 方法不能用于更新”消息的 java.sql.SQLException。
  • executeUpdate() –用于执行删除/插入/更新语句或不返回任何内容的 DDL 语句。根据语句是数据操作语言 (DML) 语句还是数据定义语言 (DDL) 语句，输出会有所不同。输出是一个整数，等于前一种情况的总行数，后一种情况为 0。

注意：execute() 方法只需要在语句类型不确定的场景中使用。在所有其他情况下，使用 executeQuery() 或 executeUpdate() 方法。

问题：提供一个Hibernate架构的例子：

回答：最新的Java常见面试题和答案合集介绍

答：以下代码演示了在 JSP 中删除 cookie：

Cookie mycook = new Cookie("name1","value1");
response.addCookie(mycook1);
Cookie killmycook = new Cookie("mycook1","value1");
killmycook . set MaxAge ( 0 );
killmycook . set Path ("/");
killmycook . addCookie ( killmycook 1 );

问题：编写合适的代码示例来演示 final、final 和 finalize 的用法。

答案：Final：  final 关键字用于限制类、方法和变量。final 类不能被继承，final 方法被禁止重写，final 变量变成一个常量，即它的值不能改变。

class FinalVarExample {
public static void main( String args[])
{
final int a=10;
a=50; /* Will result in an error as the value can’t be changed now*/
}

最后：无论是否处理异常，都将执行最终块中的任何代码。

class FinallyExample {
public static void main(String args[]){
try {
int x=100;
}
catch(Exception e) {
System.out.println(e);
}
finally {
System.out.println("finally block is executing");}
}
}
}

Finalize： finalize 方法在对象被垃圾收集之前执行清理。

class FinalizeExample {
public void finalize() {
System.out.println("Finalize is called");
}
public static void main(String args[])
{
FinalizeExample f1=new FinalizeExample();
FinalizeExample f2=new FinalizeExample();
f1= NULL;
f2=NULL;
System.gc();
}
}

问题：Java 中的 Volatile 变量有什么用途？

答： volatile 变量中存储的值不是从线程的缓存中读取，而是从主内存中读取。易失性变量主要在同步期间使用。

问题：请比较 Java 中的序列化和反序列化。

答：序列化是将Java 对象转换为字节流的过程。反序列化与从字节流中检索 Java 对象的序列化过程完全相反。Java 对象通过将其写入 ObjectOutputStream 进行序列化，并通过从 ObjectInputStream 读取它进行反序列化。

问题：Java 中的 OutOfMemoryError 是什么意思？

答：通常，当JVM由于内存不足而无法分配对象时，会抛出OutOfMemoryError异常。在这种情况下，垃圾收集器无法回收任何内存。可能有多种原因导致 OutOfMemoryError 异常，其中最值得注意的是：

  • 拿东西太久
  • 试图同时处理太多数据
  • 使用缓存字符串的第三方库
  • 使用部署后不执行内存清理的应用程序服务器
  • 当本机分配无法满足时

这完成了顶级 Java 面试问题列表。你如何看待我们编制的清单？在下面的专用窗口中留下你的评论，让我们知道。此外，请查看这些最佳 Java 教程以进一步完善你的 Java 技能集。

问题：解释Java中的public static void main(String args[])

答：执行Java程序以public static void main(String args[])开始，也称为main()方法。

  • public：它是一个访问修饰符，定义了类或方法的可访问性。任何类都可以访问程序中公共定义的 main() 方法。
  • static：关键字表示变量，或者方法是类方法。方法 main() 是静态的，这样就可以在不创建类的实例的情况下访问它。当方法 main() 未设为静态时，编译器会抛出错误，因为 JVM 在创建任何对象之前调用了 main()，并且只能通过类直接调用静态方法。
  • void：它是方法的返回类型。void 定义了该方法不返回任何类型的值。
  • main： JVM 在开始执行任何程序时搜索此方法，仅使用特定签名。
  • String args[]：传递给main方法的参数。

问题：Java 中的包装类是什么？

答：包装类负责将 Java 原语转换为引用类型（对象）。一个类专用于每种原始数据类型。它们被称为包装类，因为它们将原始数据类型包装到该类的对象中。它存在于 Java.lang 包中。下表显示了不同的原始类型、包装器类。

简单类型包装类型
booleanBoolean
charCharacter
doubleDouble
floatFloat
intInteger
longLong

问题：解释装箱、拆箱、自动装箱和自动拆箱的概念。

回答：

  • 装箱：将原始值放入对象的概念称为装箱。
  • 拆箱：从对象中获取原始值。
  • 自动装箱：直接为整数对象赋值。
  • 自动拆箱：将原始值直接放入整数对象中。
public class BoxUnbox
{
public static void main(String args[])
{
int i = 5;
Integer ii = new Integer(i);            /*Boxing*/
Integer jj = i; /*Unboxing*/
int j = jj.intValue();      /*Unboxing*/
int k = jj; /*AutoUnboxing*/
}
}

问题：在 Java 中定义 Singleton 类。如何使一个类成为单例？

答案：单例类只允许创建类的一个实例。

可以通过以下步骤使类成为单例：

  1. 使用类创建类的静态实例。
  2. 不允许用户通过定义私有构造函数来创建具有默认构造函数的实例。
  3. 创建一个静态方法来返回 A 实例的对象。
public class Singleton
{
public static void main(String args[])
{
Single obj1 = Single.getInstance();  /* both would point to one and same instance of the class */
Single obj2 = Single.getInstance();
}
}
class Single
{
static Single obj = new Single(); /* step a*/
private Single() /* step b*/
{
}
public static Single getInstance()
{
return obj; /* step c*/
}
}

问题：如果将public static void替换为static public void，程序还会运行吗？

回答：是的，由于说明符的顺序无关紧要，因此程序可以编译并运行而不会出现任何错误。

问题： == 和 equals() 的区别？

回答：

equals()==
它是 String 类的一个方法它是一个运算符。
内容对比地址对比
class Operator {
public static void main(String[] args)
{
/* integer-type*/
System.out.println(10 == 20);
/* char-type*/
System.out.println('a' == 'b');
/* char and double type*/
System.out.println('a' == 97.0);
/* boolean type*/
System.out.println(true == true);
}
}		public class Equals{
public static void main(String[] args)
{
String s1 = new String("HELLO");
String s2 = new String("HELLO");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}

问题：我们为什么不在 Java 中使用指针？

答：指针被认为是不安全的，并且增加了程序的复杂性，添加

指针的概念可能是矛盾的。此外，JVM 负责隐式内存分配；因此，为了避免用户直接访问内存，Java 中不鼓励使用指针。

问题：区分 this() 和 super()

回答：

this()super()
表示类的当前实例。表示父类/基类的当前实例。
用于调用同一个类的默认构造函数它用于调用父/基类的默认构造函数。
访问当前类的方法访问基类的方法
点当前类实例指向超类实例。
必须是块的第一行它必须是块的第一行。

Java 编程面试问题 

除了对 Java 编程概念有很好的了解之外，你还需要测试你在 Java 编程语言中编码的技能。下面给出的是与新生相关的 Java 编码面试问题，并且在 Java 编程面试中非常流行。

问题：看看下面的两个代码片段：

i.

class Adder {
Static int add(int a, int b)
{
return a+b;
}
Static double add( double a, double b)
{
return a+b;
}
public static void main(String args[])
{
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}

ii.

class Car {
void run(){
System.out.println(“car is running”);
}
Class Audi extends Car{
void run()
{
System.out.prinltn(“Audi is running safely with 100km”);
}
public static void main( String args[])
{
Car b=new Audi();
b.run();
}
}

两者之间的重要区别是什么？

答案：代码片段i。是方法重载的示例，而代码片段ii。演示方法覆盖。

Java常见面试题和答案合集：不使用内置函数的字符串反转程序

回答：

public class Reversal
{
public static void main(String args[])
{
String input = "Java Interview";
System.out.println("Given String -> " + "Java Interview");
char charArray[] = input.toCharArray();
System.out.println("Reversed String -> ");
for(int i = charArray.length-1;i>=0; i--)
{
System.out.print(charArray[i]);
}
System.out.println();
}
}

问题：从数组中删除重复项的程序

回答：

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
class RemoveDuplicates
{
public static void main(String args[])
{
/*create ArrayList with duplicate elements*/
ArrayList duplicate = new ArrayList();
duplicate.add(5);
duplicate.add(7);
duplicate.add(1);
duplicate.add(4);
duplicate.add(1);
duplicate.add(7);
System.out.println("Given array: "+ duplicate);
Set <Integer> withoutDuplicates = new LinkedHashSet<Integer>(duplicate)
duplicate.clear();
duplicate.addAll(withoutDuplicates);
System.out.println("Array without duplicates: "+ duplicate);
}
}

问题：反转数字的程序

回答：

import java.util.Scanner;
public class NumberReversal
{
public static void main(String args[])
{
System.out.println("Please enter the number to be reversed");
Scanner sc = new Scanner (System.in);
int number = sc.nextInt();
int reverse = reverse(number);
System.out.println("Reverse of number: " + number + " is " + reverse(number));
}
public static int reverse(int number){
int reverse = 0;
int remainder = 0;
do{
remainder = number%10;
reverse = reverse*10 + remainder;
number = number/10;
}while(number > 0);
   return reverse;
}
}

Java面试题解析和答案：

import java.util.Scanner;
import java.util.Arrays;
public class Binary {
public static void main(String[] args) {
System.out.println("Enter total number of elements : ");
Scanner s = new Scanner (System.in);
int length = s.nextInt();
int[] input = new int[length];
System.out.printf("Enter %d integers", length);
for (int i = 0; i < length; i++) {
input[i] = s.nextInt();
}
/* binary search requires the input array to be sorted so we must sort the array first*/
Arrays.sort(input);
System.out.print("the sorted array is: ");
for(int i= 0; i<= length-1;i++)
{
System.out.println(input[i] + " ,");
}
System.out.println("Please enter number to be searched in sorted array");
int key = s.nextInt();
int index = BSearch(input, key);
if (index == -1) {
System.out.printf("Sorry, %d is not found in array %n", key);
} else {
System.out.printf("%d is found in array at index %d %n", key,
index);
}
}
public static int BSearch(int[] input, int number) {
int low = 0;
int high = input.length - 1;
while (high >= low) {
int middle = (low + high) / 2;
if (input[middle] == number) {
return middle;
} else if (input[middle] < number) {
low = middle + 1;
} else if (input[middle] > number) {
high = middle - 1;
}
}
return -1;
}
}

Java常见面试题有哪些：检查一个数是否为素数的程序。

回答：

import java.util.Scanner;
public class Prime
{
public static void main(String args[])
{
System.out.println("Enter the number to check: ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
boolean isPrime = false;
  if(num!=0)
  {
  isPrime = checkPrime(num);
  }else
  {
  System.out.println("Enter valid number");
  }
  if(isPrime == false)
  {
  System.out.println(" NOT PRIME!!");
  }
  else
  {
  System.out.println("PRIME!!");
  }
}
public static boolean checkPrime(int number)
{
int sqrt = (int) Math.sqrt(number) + 1;
for(int i = 2; i<sqrt; i++)
{
if(number % i== 0)
{
return false;
}
}
return true;
}
}

问题：打印斐波那契数列的程序

回答：

import java.util.Scanner;
public class Fibo
{
public static void main(String args[])
{
System.out.println("Enter the number upto which Fibonacci series should be printed ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
System.out.println("Fibonacci Series upto %d is" + num);
for(int i=1; i<=num; i++)
{
System.out.print(fib(i) + " ");
}
}
public static int fib(int n)
{
if(n ==1 || n==2)
{
return 1;
}
return fib(n-1) + fib(n-2);
}
}

问题：检查给定字符串是否为回文的程序。

回答：

import java.util.Scanner;
public class PalinDrome
{
public static void main(String args[])
{
System.out.println("Enter the string to check");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
boolean isPalindrome;
isPalindrome = checkPalindrome(str);
if(str.equals(" "))
{
System.out.println("Enter valid string");
}
else
{
if(isPalindrome)
{
System.out.println("PALINDROME!!");
}
else
{
System.out.println("NOT A PALINDROME!!");
}
}
}
public static boolean checkPalindrome(String input)
{
int str_length = input.length();
int i=0, j= str_length-1;
while(i<j)
{
if(input.charAt(i) != input.charAt(j))
return false;
i++;
j--;
}
return true;
}
}

问题：图案印刷

*
* *
* * *
* * * *
* * * * * *

回答：

public class Pattern
{
public static void main(String args[])
{
 for(int i=5; i>=0; i--)
 {
 System.out.println();
 for(int j=i; j<5;j++)
 {
 System.out.print(" * ");
 }
 }
 System.out.println();
}
}

问题：交换两个数字的程序

回答：

import java.util.Scanner;
public class Swap
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int a = s.nextInt();
System.out.println("Enter second number: ");
int b = s.nextInt();
System.out.println("Value of a and b before swapping: " + "a = " +a  + " b = " + b);
swap(a,b);
}
public static void swap(int a , int b)
{
int swap_variable;
swap_variable = a;
a = b;
b = swap_variable;
System.out.println("Value of a and b after swapping: " + "a = " +a  + " b = " + b);
}
}

Java常见面试题和答案合集：用于检查给定数字是否为阿姆斯壮数字的程序。

回答：

import java.util.Scanner;
public class Armstrong
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int number = s.nextInt();
int a=number, sum = 0, num=0;
  while(a%10 !=0)
  {
  num = a%10;
  sum = sum + (num*num*num);
a = a/10;
  }
  if(sum == number)
  {
  System.out.println("Armstrong Number!");
  }
  else
  {
  System.out.println("Not an Armstrong Number!");
  }
}
}

我们还为你提供了一份 PDF 文件供你准备，以便你随时随地下载学习和准备。下载 Java 面试题 PDF

概括

前面提到的核心 Java 面试问题和 Java 编程面试问题是为你准备面试的最佳集合，因为每个概念都得到了详细的解释。内部参考，还提供了链接供你进一步阅读。 

木子山

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: