2025 年一线互联网大厂最新高质量 Java 面试八股文整理及答案汇总

我将从Java基础、集合、多线程等多个重要方面，为你呈现一线互联网大厂最新的高质量Java面试八股文及答案，帮助你高效备考。

一线互联网大厂最新高质量Java面试八股文整理（附答案）

Java基础

1. 面向对象和面向过程的区别？

面向过程：注重解决问题的步骤和过程，按步骤顺序执行方法，将数据和操作分离。例如实现一个简单的计算器功能，面向过程会按照输入数字、选择运算符号、进行运算、输出结果这样的步骤来编写代码。其优点是效率高，无需类加载和对象实例化；缺点是程序耦合度高，维护和扩展困难。

面向对象：注重对象，将数据和操作封装在对象中，通过对象之间的交互来解决问题。还是以计算器为例，会抽象出数字对象、运算符号对象、计算器对象等，每个对象有自己的属性和方法，通过调用对象的方法来完成计算。优点是程序易维护、易复用、易扩展；缺点是相比面向过程效率更低，因为需要类加载和对象实例化。

2. equals与==的区别？

==：比较的是变量（栈）内存中存放的对象的（堆）内存地址，用来判断两个对象是否是同一个对象。对于基本数据类型，比较的是值；对于引用数据类型，比较的是内存地址。例如：

int a = 10;
int b = 10;
System.out.println(a == b); // 输出true，因为基本数据类型比较值
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // 输出false，因为s1和s2是不同的对象，内存地址不同

equals：用来比较两个对象的内容是否相等。所有类都继承自java.lang.Object类，如果没有重写equals方法，调用的是Object类中的equals方法，其内部实现还是使用==来比较内存地址。通常我们会根据业务需求在自定义类中重写equals方法。例如在自定义的User类中，如果我们认为两个User对象只要用户名和密码相同就相等，就可以重写equals方法：

public class User {
    private String username;
    private String password;
    // 省略构造函数、getter和setter方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(username, user.username) &&
                Objects.equals(password, user.password);
    }
}

3. final有哪些用法？

• 修饰类：被final修饰的类不可以被继承。例如String类就是被final修饰的，所以不能有子类继承它。
• 修饰方法：被final修饰的方法不可以被重写。在父类中如果一个方法被final修饰，子类无法对其进行重写。
• 修饰变量：被final修饰的变量不可以被改变。如果修饰基本数据类型变量，值不能改变；如果修饰引用类型变量，引用不能再指向其他对象，但对象内部的属性可以改变。例如：

final int num = 10;
num = 20; // 编译错误，不能修改final修饰的基本数据类型变量
final List<String> list = new ArrayList<>();
list.add("hello"); // 可以，虽然list引用不能改变，但可以操作其内部元素
list = new ArrayList<>(); // 编译错误，不能改变final修饰的引用类型变量的引用

4. static都有哪些用法？

• 静态变量：用static修饰的成员变量称为静态变量，它属于类，而不是类的某个对象。无论创建多少个类的对象，静态变量在内存中只有一份。例如：

public class StaticExample {
    static int staticVar = 10;
    int instanceVar = 20;
    public static void main(String[] args) {
        StaticExample s1 = new StaticExample();
        StaticExample s2 = new StaticExample();
        s1.staticVar = 30;
        System.out.println(s2.staticVar); // 输出30，因为静态变量是共享的
        System.out.println(s1.instanceVar); // 输出20
        System.out.println(s2.instanceVar); // 输出20，实例变量每个对象都有自己的一份
    }
}

• 静态方法：用static修饰的方法称为静态方法，静态方法可以直接通过类名调用，不需要创建对象。静态方法中不能访问非静态成员变量和非静态方法，因为非静态成员属于对象，而静态方法在类加载时就存在，此时可能还没有对象。例如：

public class StaticMethodExample {
    static void staticMethod() {
        System.out.println("这是一个静态方法");
    }
    void instanceMethod() {
        System.out.println("这是一个实例方法");
    }
    public static void main(String[] args) {
        StaticMethodExample.staticMethod(); // 直接通过类名调用静态方法
        StaticMethodExample s = new StaticMethodExample();
        s.instanceMethod(); // 通过对象调用实例方法
    }
}

• 静态代码块：用static修饰的代码块称为静态代码块，在类加载时执行，且只执行一次。通常用于初始化静态变量等操作。例如：

public class StaticBlockExample {
    static int staticVar;
    static {
        staticVar = 100;
        System.out.println("静态代码块执行");
    }
    public static void main(String[] args) {
        System.out.println(StaticBlockExample.staticVar); // 输出100
    }
}

5. try catch finally，try里有return，finally还执行么？

finally块中的代码无论try块中是否发生异常，也无论try块中是否有return语句，都会执行（除了在finally块之前JVM退出的情况）。不过如果try块中有return语句，会先执行return语句中的表达式，将结果暂存，然后执行finally块中的代码，最后再返回之前暂存的结果。例如：

public class TryCatchFinallyExample {
    public static int test() {
        try {
            return 1;
        } finally {
            System.out.println("finally块执行");
        }
    }
    public static void main(String[] args) {
        int result = test();
        System.out.println(result); // 输出：finally块执行 1
    }
}

在上述代码中，try块中的return语句先将1暂存，然后执行finally块中的代码输出“finally块执行”，最后返回暂存的1。

Java集合

1. ArrayList和LinkedList的区别？

• 数据结构：ArrayList底层使用数组存储元素，LinkedList底层使用双向链表存储元素。
• 随机访问性能：ArrayList支持随机访问，通过索引可以快速定位元素，时间复杂度为O(1)。例如获取ArrayList中第5个元素，直接通过array[5]就可以获取。LinkedList不支持高效的随机访问，因为需要从链表头或链表尾开始遍历，时间复杂度为O(n)。如果要获取LinkedList中第5个元素，需要从链表头开始，依次遍历5个节点才能找到。
• 插入和删除性能：在ArrayList的中间位置插入或删除元素时，需要移动大量元素，时间复杂度为O(n)。例如在ArrayList中间位置插入一个元素，后面的元素都需要向后移动一位。而LinkedList在任意位置插入或删除元素，只需要修改相邻节点的指针，时间复杂度为O(1)。例如在LinkedList中间插入一个节点，只需要修改前一个节点的next指针和后一个节点的prev指针。
• 内存占用：ArrayList因为是数组，连续内存空间，如果元素数量较多，可能会浪费一些内存空间。LinkedList每个节点除了存储数据，还需要存储两个指针，所以内存占用相对较大。

2. HashMap的工作原理？

HashMap基于哈希表实现，使用数组和链表（JDK1.8及之后引入红黑树）来存储数据。其工作原理如下：

• 存储：当向HashMap中put一个键值对时，首先计算键的哈希值，通过哈希值与数组长度进行取模运算，得到该键值对在数组中的存储位置（桶的索引）。如果该位置没有元素，则直接将键值对存入该位置；如果该位置已经有元素（发生哈希冲突），则以链表（或红黑树）的形式将新元素插入到该位置。例如：

HashMap<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);

假设“apple”计算出的哈希值对应的数组索引为3，且该位置为空，就将“apple”和1存入数组索引为3的位置。如果“banana”计算出的哈希值也对应数组索引为3，那么就将“banana”和2以链表形式插入到索引为3位置已有的元素后面。

• 获取：当通过键获取值时，同样先计算键的哈希值，通过哈希值与数组长度取模得到存储位置，然后在该位置的链表（或红黑树）中查找与该键相等的节点，找到后返回对应的值。例如：

Integer value = map.get("apple");
System.out.println(value); // 输出1

• 扩容：当HashMap中的元素数量达到负载因子（默认0.75）与数组容量的乘积时，会进行扩容。扩容时会创建一个新的更大的数组，将原数组中的元素重新计算哈希值并放入新数组中，这个过程称为rehash。扩容的目的是减少哈希冲突，提高查找效率。

3. HashMap和Hashtable的区别？

• 继承关系：HashMap继承自AbstractMap类，Hashtable继承自Dictionary类。
• 线程安全性：HashMap是线程不安全的，在多线程并发环境下可能会出现数据不一致等问题，例如在多线程同时进行put操作时可能会导致链表成环。Hashtable是线程安全的，它的每个方法都使用synchronized关键字修饰，因此可以直接在多线程环境中使用，但由于同步带来的开销，性能相对较低。
• 对null的支持：HashMap的键可以为null，且只能有一个键为null的键值对，值可以有多个为null。例如：

HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put(null, 1);
hashMap.put("key", null);

Hashtable的键和值都不能为null，如果尝试插入null键或null值会抛出NullPointerException。

• 初始容量和扩容机制：HashMap的初始容量为16，扩容时新容量为原来的2倍；Hashtable的初始容量为11，扩容时新容量为原来的2倍加1。

4. 集合框架中哪些是线程安全的？

• Vector：与ArrayList类似，但它是线程安全的，方法都使用synchronized修饰。例如在多线程环境下向Vector中添加元素：

Vector<Integer> vector = new Vector<>();
vector.add(1);

多个线程同时调用add方法不会出现数据不一致问题。

• Hashtable：前面已介绍，是线程安全的哈希表。
• ConcurrentHashMap：线程安全的哈希表，相比Hashtable，它采用了更细粒度的锁机制（分段锁，JDK1.8之后采用CAS和synchronized结合的机制），性能更高。例如在多线程环境下进行并发的put和get操作：

ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("key1", 1);
Integer value = concurrentHashMap.get("key1");

可以高效地在多线程环境下工作。

• CopyOnWriteArrayList：写时复制的ArrayList，对其进行读操作时，不需要加锁，因为读操作是基于原数组进行的；写操作时，会先复制一份原数组，在新数组上进行修改，完成后将原数组引用指向新数组，写操作是线程安全的。适用于读多写少的场景。例如：

CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
list.add(1);
int size = list.size();

多个线程同时进行读操作不会受写操作影响。

Java多线程

1. 创建线程有哪几种方式？

• 继承Thread类：定义一个类继承自Thread类，重写run方法，在run方法中编写线程执行的逻辑。然后创建该类的对象，并调用start方法启动线程。例如：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行中：" + Thread.currentThread().getName());
    }
}
public class ThreadCreationExample {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

• 实现Runnable接口：定义一个类实现Runnable接口，实现run方法。然后创建该类的对象，并将其作为参数传递给Thread类的构造函数，最后调用start方法启动线程。例如：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行中：" + Thread.currentThread().getName());
    }
}
public class RunnableCreationExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

• 实现Callable接口：与实现Runnable接口类似，但Callable接口的call方法有返回值且可以抛出异常。需要使用FutureTask类来包装Callable对象，然后将FutureTask对象作为参数传递给Thread类的构造函数来启动线程。例如：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("线程执行中：" + Thread.currentThread().getName());
        return 100;
    }
}
public class CallableCreationExample {
    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer result = futureTask.get();
        System.out.println("线程返回结果：" + result);
    }
}

2. 线程的生命周期有哪些阶段？

• 新建（New）：当创建一个Thread对象时，线程处于新建状态，此时线程还没有开始执行。例如：

Thread thread = new Thread();

• 就绪（Runnable）：调用线程的start方法后，线程进入就绪状态，此时线程已经准备好运行，但还没有获得CPU时间片。例如：

thread.start();

• 运行（Running）：当线程获得CPU时间片开始执行run方法中的代码时，线程处于运行状态。
• 阻塞（Blocked）：线程在运行过程中，可能会因为某些原因进入阻塞状态，例如调用了sleep方法、等待I/O操作完成、等待获取锁等。例如：

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

• 死亡（Dead）：线程的run方法执行完毕或者出现未捕获的异常导致线程终止，线程进入死亡状态，此时线程生命周期结束。

3. 什么是线程上下文切换？

线程上下文切换是指当CPU从一个线程切换到另一个线程执行时，需要保存当前线程的上下文信息（包括寄存器的值、程序计数器的值、栈指针等），并恢复要切换到的线程的上下文信息，以便该线程能够继续正确执行。例如，当一个线程在执行过程中，时间片用完，操作系统会将其上下文信息保存到内存中，然后从就绪队列中选择另一个线程，将该线程的上下文信息从内存中读取出来并恢复到CPU寄存器等硬件中，从而让新的线程开始执行。线程上下文切换会带来一定的开销，频繁的上下文切换会影响系统性能。

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

死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，如果没有外力干涉，这些线程将永远无法继续执行。例如，线程A持有资源1，等待获取资源2，而线程B持有资源2，等待获取资源1，此时两个线程就陷入了死锁。

避免死锁的方法：

• 破坏死锁的四个必要条件：
  • 互斥条件：某些资源在一段时间内只能由一个线程占有，一般无法破坏。
  • 占有并等待条件：可以要求线程一次性获取所有需要的资源，而不是逐步获取，这样就不会出现占有部分资源又等待其他资源的情况。
  • 不可剥夺条件：可以允许线程在获取不到某些资源时，主动释放已经占有的资源。
  • 循环等待条件：可以对资源进行排序，线程按照一定的顺序获取资源，避免形成循环等待。
• 使用定时锁：在获取锁时设置一个超时时间，如果在规定时间内没有获取到锁，则放弃获取，避免无限等待。例如使用ReentrantLock的tryLock(long timeout, TimeUnit unit)方法。
• 死锁检测和恢复：通过一些工具或算法定期检测系统中是否存在死锁，如果检测到死锁，采取相应

---

代码获取方式

（夸克网盘）点击查看

---

关注我获取更多内容