java面试题带答案2025最新整理

---

java面试题带答案2025最新整理12万字：https://pan.quark.cn/s/6e941688e902

一、java面试题集合框架

1. 请简要介绍 Java 集合框架的体系结构

Java 集合框架主要分为两大分支：Collection 和 Map。

• Collection 接口：它是单列集合的根接口，下面又有三个主要的子接口。
• List 接口：有序、可重复的集合。常见实现类有 ArrayList（基于动态数组实现，查询快，增删慢）、LinkedList（基于双向链表实现，增删快，查询慢）和 Vector（线程安全的动态数组，性能相对较低）。
• Set 接口：无序、不可重复的集合。HashSet 基于哈希表实现，不保证元素顺序；LinkedHashSet 继承自 HashSet，使用链表维护元素插入顺序；TreeSet 基于红黑树实现，可对元素进行自然排序或根据指定的比较器排序。
• Queue 接口：队列，遵循先进先出（FIFO）原则。PriorityQueue 是优先队列，根据元素的自然顺序或指定比较器进行排序；LinkedList 也实现了 Queue 接口。
• Map 接口：双列集合，存储键值对。HashMap 基于哈希表实现，允许键和值为 null，不保证元素顺序；LinkedHashMap 继承自 HashMap，使用链表维护元素插入顺序；TreeMap 基于红黑树实现，根据键的自然顺序或指定比较器对键进行排序；Hashtable 是线程安全的，不允许键和值为 null。

2. ArrayList 和 LinkedList 的区别是什么

• 数据结构：ArrayList 基于动态数组实现，数组在内存中是连续存储的；LinkedList 基于双向链表实现，每个节点包含数据、指向前一个节点的引用和指向后一个节点的引用。
• 性能特点：
• 查询性能：ArrayList 支持随机访问，通过索引可以快速定位元素，时间复杂度为
  O(1)
  ；LinkedList 不支持随机访问，需要从头或尾开始遍历链表，时间复杂度为
  O(n)
  。
• 增删性能：在列表末尾添加元素时，两者性能相近；但在中间或开头插入或删除元素时，ArrayList 需要移动大量元素，时间复杂度为
  O(n)
  ，而 LinkedList 只需要修改节点的引用，时间复杂度为
  O(1)
  。
• 内存占用：ArrayList 的主要内存开销在于数组的预分配空间，可能会有一定的空间浪费；LinkedList 每个节点需要额外的引用空间，整体内存开销相对较大。

3. HashMap 的工作原理是什么，它在 JDK 7 和 JDK 8 中有哪些不同

• 工作原理
  HashMap 基于哈希表实现，通过键的 hashCode() 方法计算哈希值，再根据哈希值确定元素在数组中的存储位置。当发生哈希冲突（不同键的哈希值相同）时，使用链表或红黑树来存储冲突的元素。
• JDK 7 和 JDK 8 的区别
• 数据结构：JDK 7 采用数组 + 链表的结构；JDK 8 采用数组 + 链表 + 红黑树的结构。当链表长度超过 8 且数组长度大于 64 时，链表会转换为红黑树，以提高查找效率。
  插入方式：JDK 7 使用头插法，即新元素插入到链表头部；JDK 8 使用尾插法，新元素插入到链表尾部，避免了多线程环境下的链表成环问题。
• 哈希算法：JDK 8 对哈希算法进行了优化，减少了哈希冲突的概率。
• 扩容机制：JDK 7 在扩容时需要重新计算每个元素的哈希值和位置；JDK 8 在扩容时，根据元素的哈希值与原数组长度的与运算结果，将元素分为低位链表和高位链表，避免了重新计算哈希值。

4. 如何解决 HashMap 的线程安全问题

使用 Hashtable：Hashtable 是线程安全的，它的方法都使用 synchronized 关键字修饰，但性能较低，因为所有操作都进行同步，会影响并发性能。
使用 Collections.synchronizedMap()：可以将一个普通的 HashMap 转换为线程安全的 Map，例如：
java
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class SynchronizedMapExample {
public static void main(String[] args) {
Map<String, String> hashMap = new HashMap<>();
Map<String, String> synchronizedMap = Collections.synchronizedMap(hashMap);
}
}
这种方式也是通过同步机制保证线程安全，性能也有一定的损耗。
使用 ConcurrentHashMap：ConcurrentHashMap 是专门为并发场景设计的线程安全的 Map。在 JDK 7 中，它采用分段锁机制，将整个 Map 分为多个段，每个段都有自己的锁，不同段的操作可以并发进行；在 JDK 8 中，采用 CAS（Compare - And - Swap）和 synchronized 来保证并发操作的安全性，性能更高。

5. TreeSet 是如何保证元素有序的

TreeSet 基于红黑树实现，它可以保证元素按照自然顺序或指定的比较器顺序进行排序。

• 自然排序：如果元素的类实现了 java.lang.Comparable 接口，TreeSet 会根据元素的 compareTo() 方法进行排序。例如：
  java
  import java.util.TreeSet;

class Person implements Comparable {
private int age;

public Person(int age) {this.age = age;
}@Override
public int compareTo(Person other) {return Integer.compare(this.age, other.age);
}@Override
public String toString() {return "Person{age=" + age + "}";
}

}

public class TreeSetNaturalOrderExample {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet<>();
treeSet.add(new Person(20));
treeSet.add(new Person(10));
treeSet.add(new Person(30));
System.out.println(treeSet);
}
}

• 定制排序：可以在创建 TreeSet 时传入一个 Comparator 对象，TreeSet 会根据 Comparator 的 compare() 方法进行排序。例如：
  java
  import java.util.Comparator;
  import java.util.TreeSet;

class Student {
private int score;

public Student(int score) {this.score = score;
}@Override
public String toString() {return "Student{score=" + score + "}";
}

}

public class TreeSetCustomOrderExample {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet<>(Comparator.comparingInt(s -> s.score));
treeSet.add(new Student(80));
treeSet.add(new Student(90));
treeSet.add(new Student(70));
System.out.println(treeSet);
}
}

二、java面试题多线程与并发

1. 什么是线程和进程，它们有什么区别

• 进程：进程是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有自己独立的内存空间、系统资源和执行上下文。例如，打开一个浏览器就是启动了一个进程。
• 线程：线程是进程中的一个执行单元，是 CPU 调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和系统资源，但每个线程有自己独立的栈和程序计数器。例如，在浏览器进程中，可能有负责渲染页面的线程、处理网络请求的线程等。
  区别：
• 资源占用：进程拥有自己独立的资源，而线程共享所在进程的资源，因此创建和销毁进程的开销比线程大。
• 并发程度：进程之间的并发度较低，因为进程之间的通信和同步需要通过操作系统提供的机制（如管道、消息队列等）；线程之间的并发度较高，因为它们共享内存，通信和同步相对简单。
• 调度：进程的调度由操作系统内核完成，开销较大；线程的调度可以由操作系统内核或用户线程库完成，开销相对较小。

2. 创建线程有哪几种方式，各有什么优缺点

• 继承 Thread 类
  java
  class MyThread extends Thread {
  @Override
  public void run() {
  System.out.println(“Thread is running”);
  }
  }

public class ThreadInheritanceExample {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}

• 优点：实现简单，直接继承 Thread 类，重写 run() 方法即可。
• 缺点：Java 是单继承的，继承了 Thread 类后就不能再继承其他类，会限制类的扩展性。
• 实现 Runnable 接口
  java
  class MyRunnable implements Runnable {
  @Override
  public void run() {
  System.out.println(“Runnable is running”);
  }
  }

public class RunnableExample {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
}

• 优点：避免了单继承的局限性，一个类可以在实现 Runnable 接口的同时继承其他类；可以将相同的 Runnable 实例传递给多个线程，实现资源共享。
• 缺点：代码相对复杂，需要创建 Thread 对象并将 Runnable 实例传递给它。
• 实现 Callable 接口并结合 FutureTask
  java
  import java.util.concurrent.*;

class MyCallable implements Callable {
@Override
public Integer call() throws Exception {
return 1 + 2;
}
}

public class CallableExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable callable = new MyCallable();
FutureTask futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
Integer result = futureTask.get();
System.out.println("Result: " + result);
}
}

• 优点：Callable 的 call() 方法可以有返回值，并且可以抛出异常；可以通过 FutureTask 获取线程执行的结果。
• 缺点：代码复杂度较高，需要处理 FutureTask 和异常。

3. 什么是线程安全，如何保证线程安全

• 线程安全的定义
  当多个线程访问某个对象时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要额外的同步或协调，这个对象都能表现出正确的行为，那么就称这个对象是线程安全的。

• 保证线程安全的方法

• 使用 synchronized 关键字：可以修饰方法或代码块，确保同一时刻只有一个线程可以访问被修饰的方法或代码块。例如：
  java
  class Counter {
  private int count = 0;

  public synchronized void increment() {
  count++;
  }

  public synchronized int getCount() {
  return count;
  }
  }

• 使用 Lock 接口及其实现类：如 ReentrantLock，可以更灵活地控制锁的获取和释放。例如：
  java
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;

class CounterWithLock {
private int count = 0;
private Lock lock = new ReentrantLock();

public void increment() {lock.lock();try {count++;} finally {lock.unlock();}
}public int getCount() {lock.lock();try {return count;} finally {lock.unlock();}
}

}

• 使用原子类：如 AtomicInteger、AtomicLong 等，这些类使用 CAS 操作保证操作的原子性。例如：
  java
  import java.util.concurrent.atomic.AtomicInteger;

class CounterWithAtomic {
private AtomicInteger count = new AtomicInteger(0);

public void increment() {count.incrementAndGet();
}public int getCount() {return count.get();
}

}

4. 什么是死锁，如何避免死锁

• 死锁的定义
  死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。例如，线程 A 持有资源 1 并请求资源 2，而线程 B 持有资源 2 并请求资源 1，两个线程就会陷入死锁状态。
• 避免死锁的方法
• 破坏互斥条件：一般来说，互斥条件是资源本身的特性，很难被破坏。
• 破坏占有并等待条件：可以采用一次性分配所有资源的方法，即线程在执行前一次性请求它所需要的所有资源。
• 破坏不剥夺条件：允许线程在持有资源的情况下，当请求其他资源失败时，释放已持有的资源。
• 破坏循环等待条件：对资源进行排序，线程按照资源的顺序依次请求资源，避免形成循环等待。例如，规定线程必须先请求资源 1，再请求资源 2。

5. 请介绍 volatile 关键字的作用
   volatile 关键字主要有两个作用：
   保证可见性：当一个变量被声明为 volatile 时，它会保证对该变量的写操作会立即刷新到主内存中，而读操作会直接从主内存中读取。这样可以保证不同线程对该变量的修改能够及时被其他线程看到。例如：
   java
   class VolatileExample {
   private volatile boolean flag = false;

   public void setFlag() {
   flag = true;
   }

   public boolean getFlag() {
   return flag;
   }
   }

• 禁止指令重排序：在 Java 中，编译器和处理器为了提高性能，可能会对指令进行重排序。volatile 关键字可以禁止指令重排序，保证变量的读写操作按照代码的顺序执行。例如，在单例模式的双重检查锁定中，使用 volatile 关键字可以避免因指令重排序导致的问题：
  java
  public class Singleton {
  private static volatile Singleton instance;

  private Singleton() {}

  public static Singleton getInstance() {
  if (instance == null) {
  synchronized (Singleton.class) {
  if (instance == null) {
  instance = new Singleton();
  }
  }
  }
  return instance;
  }
  }

三、java面试题异常处理

1. Java 中的异常体系是怎样的

Java 中的异常体系以 Throwable 类为根类，它有两个主要的子类：
Error：表示系统级的错误，通常是由系统内部错误或资源耗尽等严重问题引起的，程序无法处理这些错误。例如，OutOfMemoryError 表示内存不足，StackOverflowError 表示栈溢出。
Exception：表示程序可以捕获和处理的异常，它又分为受检查异常（Checked Exception）和非受检查异常（Unchecked Exception）。
受检查异常：必须在方法签名中声明或者在方法内部进行捕获处理。例如，IOException、SQLException 等。
非受检查异常：也称为运行时异常（RuntimeException 及其子类），不需要在方法签名中声明，也可以不进行捕获处理。例如，NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException 等。

2. try-catch-finally 语句的执行顺序是怎样的

首先执行 try 块中的代码。
如果 try 块中没有抛出异常，则执行完 try 块后，接着执行 finally 块中的代码。
如果 try 块中抛出了异常，会依次检查 catch 块，找到匹配的异常类型进行处理。如果找到匹配的 catch 块，执行该 catch 块中的代码，然后执行 finally 块；如果没有找到匹配的 catch 块，会在执行 finally 块后将异常抛给上层调用者。
无论 try 块中是否抛出异常，finally 块中的代码都会执行（除非在 try 或 catch 块中调用了 System.exit() 方法）。例如：
java
public class TryCatchFinallyExample {
public static void main(String[] args) {
try {
int result = 1 / 0;
System.out.println(“This line will not be executed”);
} catch (ArithmeticException e) {
System.out.println("Caught ArithmeticException: " + e.getMessage());
} finally {
System.out.println(“Finally block is executed”);
}
}
}

3. throws 和 throw 的区别是什么

throws：用于方法签名中，用于声明该方法可能会抛出的异常类型。它表示该方法本身不处理这些异常，而是将异常抛给调用者处理。例如：
java
public class ThrowsExample {
public static void readFile() throws java.io.IOException {
java.io.FileInputStream fis = new java.io.FileInputStream(“test.txt”);
}
}
throw：用于方法内部，用于手动抛出一个异常对象。它表示在程序执行过程中，当满足某个条件时，主动抛出一个异常。例如：
java
public class ThrowExample {
public static void checkAge(int age) {
if (age < 0) {
throw new IllegalArgumentException(“Age cannot be negative”);
}
}
}

4. 自定义异常有什么作用，如何自定义异常

自定义异常的作用
可以根据业务需求，创建特定类型的异常，使异常信息更加明确和有针对性，方便程序的调试和维护。
可以将业务逻辑中的错误情况进行封装，提高代码的可读性和可维护性。
自定义异常的步骤
定义一个类，继承自 Exception（受检查异常）或 RuntimeException（非受检查异常）。
提供构造方法，通常包含一个无参构造方法和一个带字符串参数的构造方法，用于传递异常信息。例如：
java
class MyCustomException extends Exception {
public MyCustomException() {
super();
}

public MyCustomException(String message) {super(message);
}

}

public class CustomExceptionExample {
public static void main(String[] args) {
try {
throw new MyCustomException(“This is a custom exception”);
} catch (MyCustomException e) {
System.out.println(e.getMessage());
}
}
}

四、java面试题IO 流

1. 请介绍 Java 中的 IO 流体系

Java 中的 IO 流体系主要分为输入流和输出流，又可以根据处理的数据类型分为字节流和字符流。
字节流：以字节为单位进行数据读写，主要用于处理二进制数据。
输入流：InputStream 是所有字节输入流的抽象基类，常见的实现类有 FileInputStream（用于从文件中读取数据）、BufferedInputStream（带缓冲功能的输入流）等。
输出流：OutputStream 是所有字节输出流的抽象基类，常见的实现类有 FileOutputStream（用于向文件中写入数据）、BufferedOutputStream（带缓冲功能的输出流）等。
字符流：以字符为单位进行数据读写，主要用于处理文本数据。
输入流：Reader 是所有字符输入流的抽象基类，常见的实现类有 FileReader（用于从文件中读取字符数据）、BufferedReader（带缓冲功能的字符输入流）等。
输出流：Writer 是所有字符输出流的抽象基类，常见的实现类有 FileWriter（用于向文件中写入字符数据）、BufferedWriter（带缓冲功能的字符输出流）等。

2. 字节流和字符流有什么区别

处理的数据类型：字节流处理的是二进制数据，适用于处理图像、音频、视频等文件；字符流处理的是文本数据，它会根据字符编码将字节数据转换为字符进行读写。
使用场景：如果处理的是文本文件，使用字符流更方便，因为它可以直接处理字符；如果处理的是二进制文件，必须使用字节流。
缓冲区：字节流通常没有缓冲区，每次读写操作都会直接与数据源或目标进行交互；字符流通常带有缓冲区，这样可以提高读写效率。

3. 什么是缓冲流，使用缓冲流有什么好处

缓冲流是对基本流的包装，它在内存中设置了一个缓冲区，用于暂存数据。常见的缓冲流有 BufferedInputStream、BufferedOutputStream、BufferedReader 和 BufferedWriter。
使用缓冲流的好处主要有：
提高读写效率：由于缓冲流在内存中设置了缓冲区，每次读写操作会先将数据读写到缓冲区中，当缓冲区满或达到一定条件时，再一次性将缓冲区中的数据写入到目标数据源或从数据源读取数据到缓冲区。这样可以减少与磁盘或网络的交互次数，提高读写效率。
简化操作：缓冲流提供了一些方便的方法，如 BufferedReader 的 readLine() 方法可以一次读取一行文本，简化了文本处理的操作。

4. 如何实现文件的复制

可以使用字节流或字符流来实现文件的复制，以下是使用字节流的示例：
java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream(“source.txt”);
FileOutputStream fos = new FileOutputStream(“destination.txt”)) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
System.out.println(“File copied successfully”);
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个示例中，使用 FileInputStream 从源文件中读取数据，使用 FileOutputStream 将数据写入到目标文件中。通过一个缓冲区 buffer 来提高读写效率。使用 try-with-resources 语句可以自动关闭流，避免资源泄漏。

5. 什么是 NIO，它与传统 IO 有什么区别

NIO 的定义
NIO（New IO）是 Java 1.4 引入的新的 IO 库，它提供了一种非阻塞的、基于通道（Channel）和缓冲区（Buffer）的 IO 操作方式。
与传统 IO 的区别
阻塞与非阻塞：传统 IO 是阻塞式的，当进行读写操作时，线程会一直阻塞直到操作完成；NIO 是非阻塞式的，线程可以在等待 IO 操作完成的同时去执行其他任务。
面向流与面向缓冲区：传统 IO 是面向流的，数据是单向流动的，只能顺序读写；NIO 是面向缓冲区的，数据先被读取到缓冲区中，然后可以在缓冲区中进行随机访问和操作。
通道与流：传统 IO 使用流进行数据读写；NIO 使用通道（Channel），通道可以双向读写，并且可以与缓冲区进行交互。
选择器：NIO 引入了选择器（Selector），可以实现单线程管理多个通道，提高了并发性能。例如，一个线程可以通过选择器同时监听多个通道的读写事件。