我将从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)方法。

资源地址：
https://pan.quark.cn/s/14fcf913bae6