2025年 Java 面试八股文

原创

已于 2025-02-17 18:21:31 修改 · 1.3k 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#java #面试 #开发语言 #java八股文 #springboot #spring cloud

于 2025-02-14 16:16:14 首次发布

第一章-Java基础篇

1. Java中的基本数据类型有哪些？⭐

Java中有8种基本数据类型（Primitive Types），分别是：

byte：8位，-128 ~ 127
short：16位，-32,768 ~ 32,767
int：32位，-2^31 ~ 2^31-1
long：64位，-2^63 ~ 2^63-1
float：32位，单精度浮点数
double：64位，双精度浮点数
char：16位，表示单一字符，范围0~65535（Unicode字符）
boolean：只有两个值，true或false

2. 什么是Java中的多态？⭐

多态是面向对象编程中的一个重要概念，它允许方法有多种表现形式。在Java中，多态主要通过**方法重载（Overloading）和方法重写（Overriding）**来实现。

方法重载：在同一个类中，方法名相同，但参数不同。方法重载是在编译时发生的，属于编译时多态。
方法重写：子类重写父类的方法，方法签名必须相同。方法重写是在运行时发生的，属于运行时多态。

3. Java中的内存模型及垃圾回收（GC）机制⭐

JVM内存模型：JVM内存分为堆（Heap）和栈（Stack）。堆用于存储对象实例，栈用于存储局部变量和方法调用。
垃圾回收机制：垃圾回收（GC）是JVM自动管理内存的过程，它会回收不再使用的对象。GC采用分代收集的策略，将内存划分为年轻代、老年代和永久代（Metaspace），使用不同的回收算法（如标记-清除、复制算法）回收不同代的对象。

4. 什么是`final`、`finally`和`finalize`？⭐

final：用于修饰类、方法和变量：
- final类不能被继承。
- final方法不能被重写。
- final变量的值不能改变。
finally：用于异常处理中的代码块，无论是否发生异常，finally块中的代码都会执行。通常用于资源的释放。
finalize：是Object类中的一个方法，用于在对象被垃圾回收前进行清理。这个方法并不常用，且并不是立即调用，因此不推荐使用。

5. 什么是线程安全？⭐

线程安全是指多个线程同时访问某个类或对象时，不会出现数据不一致的情况。在Java中，可以通过以下方式实现线程安全：

使用同步（synchronized）：通过synchronized关键字对方法或代码块加锁，确保同一时间只有一个线程能够执行被同步的代码。
使用显式锁（Lock）：如ReentrantLock，提供比synchronized更灵活的锁机制。
使用线程安全的集合类：如Vector、ConcurrentHashMap等。
使用volatile关键字：确保共享变量的可见性。

6. Java中的异常处理机制（Checked Exception与Unchecked Exception）⭐

Checked Exception：继承自Exception类，但不继承RuntimeException类，必须通过try-catch块处理或通过throws声明抛出。
- 例：IOException、SQLException。
Unchecked Exception：继承自RuntimeException类，通常是程序中的逻辑错误，不需要强制捕获。
- 例：NullPointerException、ArrayIndexOutOfBoundsException。

7. `HashMap`和`ConcurrentHashMap`的区别⭐

HashMap：非线程安全的集合类，允许null键和值，通常用于单线程环境或需要手动同步的多线程环境。
ConcurrentHashMap：线程安全的集合类，通过分段锁技术实现高效的并发访问，适用于多线程环境。它允许并发读取，同时保证写操作的线程安全。

8. Java中的深拷贝与浅拷贝⭐

浅拷贝（Shallow Copy）：复制对象时，只复制对象的引用类型的成员变量的引用，而不是引用对象本身。常用Object.clone()方法进行浅拷贝。
深拷贝（Deep Copy）：复制对象时，不仅复制对象本身，还会递归地复制引用对象，确保对象完全独立。

9. 什么是`volatile`关键字？⭐

volatile是一个Java关键字，用于标记一个变量为易变的，确保线程对该变量的写入操作对其他线程可见。volatile的使用可以确保变量在多个线程之间的同步。

volatile保证了变量的可见性，即当一个线程修改了该变量的值，其他线程立即能看到这个改变。
volatile不保证原子性，多个线程对volatile变量进行操作时仍需考虑线程安全问题。

10. 线程池的作用和常见实现类⭐

线程池通过复用已有的线程来避免频繁创建和销毁线程，提高程序的性能和资源的利用率。常用的线程池类有：

ExecutorService：接口，提供执行任务的方法。
ThreadPoolExecutor：ExecutorService的实现类，提供了更加详细的配置参数，适用于大多数场景。
ScheduledThreadPoolExecutor：用于定时执行任务。

11. `synchronized`与`ReentrantLock`的区别⭐

synchronized：
- 内置锁，语法简洁。
- 自动释放锁。
- 不支持尝试锁（tryLock()）和定时锁。
ReentrantLock：
- 显式锁，功能更强大，支持尝试锁、定时锁等高级功能。
- 需要手动释放锁。
- 适用于需要更细粒度控制的场景。

12、你是怎样理解OOP面向对象难度系数：⭐
面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征：

1、继承：继承是从已有类得到继承信息创建新类的过程
2、封装：封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口
3、多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应

13、重载与重写区别难度系数：⭐

重载发生在本类，重写发生在父类与子类之间
重载的方法名必须相同，重写的方法名相同且返回值类型必须相同
重载的参数列表不同，重写的参数列表必须相同
重写的访问权限不能比父类中被重写的方法的访问权限更低
构造方法不能被重写

14、接口与抽象类的区别难度系数：⭐

抽象类要被子类继承，接口要被类实现
接口可多继承接口，但类只能单继承
抽象类可以有构造器、接口不能有构造器
抽象类：除了不能实例化抽象类之外，它和普通Java类没有任何区别
抽象类：抽象方法可以有public、protected和default这些修饰符、接口：只能是public
抽象类：可以有成员变量；接口：只能声明常量

15、sleep和wait区别难度系数：⭐

sleep方法
属于Thread类中的方法
释放cpu给其它线程不释放锁资源
sleep(1000) 等待超过1s被唤醒
wait方法
属于Object类中的方法
释放cpu给其它线程，同时释放锁资源
wait(1000) 等待超过1s被唤醒
wait() 一直等待需要通过notify或者notifyAll进行唤醒
wait 方法必须配合 synchronized 一起使用，不然在运行时就会抛出IllegalMonitorStateException异常

#### 锁释放时机代码演示
public static void main(String[] args) {
    Object o = new Object();
    Thread thread = new Thread(() -> {
        synchronized (o) {
            System.out.println("新线程获取锁时间：" + LocalDateTime.now() + " 新线程名称：" + Thread.currentThread().getName());
            try {
 
                //wait 释放cpu同时释放锁
                o.wait(1000);
 
                //sleep 释放cpu不释放锁
                //Thread.sleep(1000);
                System.out.println("新线程获取释放锁锁时间：" + LocalDateTime.now() + " 新线程名称：" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
 
    thread.start();
 
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
 
    System.out.println("主线程获取锁时间：" + LocalDateTime.now() + " 主线程名称：" + Thread.currentThread().getName());
 
    synchronized (o){
        System.out.println("主线程获取释放锁锁时间：" + LocalDateTime.now() + " 主线程名称：" + Thread.currentThread().getName());
    }
}

16、什么是自动拆装箱 int和Integer有什么区别难度系数：⭐

基本数据类型，如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法。

装箱：将基本类型转换成包装类对象
拆箱：将包装类对象转换成基本类型的值

java为什么要引入自动装箱和拆箱的功能？主要是用于java集合中，List<Inteter> list=new ArrayList<Integer>();

list集合如果要放整数的话，只能放对象，不能放基本类型，因此需要将整数自动装箱成对象。

实现原理：javac编译器的语法糖，底层是通过Integer.valueOf()和Integer.intValue()方法实现。

区别：

Integer是int的包装类，int则是java的一种基本数据类型
Integer变量必须实例化后才能使用，而int变量不需要
Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
Integer的默认值是null，int的默认值是0

17、==和equals区别难度系数：⭐

如果比较的是基本数据类型，那么比较的是变量的值

如果比较的是引用数据类型，那么比较的是地址值（两个对象是否指向同一块内存）

equals

如果没重写equals方法比较的是两个对象的地址值

如果重写了equals方法后我们往往比较的是对象中的属性的内容

equals方法是从Object类中继承的，默认的实现就是使用==

18、String能被继承吗为什么用final修饰难度系数：⭐

不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。
String 类是最常用的类之一，为了效率，禁止被继承和重写。
为了安全。String 类中有native关键字修饰的调用系统级别的本地方法，调用了操作系统的 API，如果方法可以重写，可能被植入恶意代码，破坏程序。Java 的安全性也体现在这里。

19、String buffer和String builder区别难度系数：⭐

StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，
只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。
在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低

20、Object中有哪些方法难度系数：⭐

protected Object clone()--->创建并返回此对象的一个副本。
boolean equals(Object obj)--->指示某个其他对象是否与此对象“相等
protected void finalize()--->当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
Class<? extendsObject> getClass()--->返回一个对象的运行时类。
int hashCode()--->返回该对象的哈希码值。
void notify()--->唤醒在此对象监视器上等待的单个线程。
void notifyAll()--->唤醒在此对象监视器上等待的所有线程。
String toString()--->返回该对象的字符串表示。
void wait()--->导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。

void wait(long timeout)--->导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll()方法，或者超过指定的时间量。
void wait(long timeout, int nanos)--->导致当前的线程等待，直到其他线程调用此对象的 notify()

21、说一下集合体系难度系数：⭐

22、ArrarList和LinkedList区别难度系数：⭐

ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
对于随机访问get和set，ArrayList效率优于LinkedList，因为LinkedList要移动指针。
对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

23、HashMap底层是数组+链表+红黑树，为什么要用这几类结构难度系数：⭐⭐

数组 Node<K,V>[] table ,哈希表，根据对象的key的hash值进行在数组里面是哪个节点
链表的作用是解决hash冲突，将hash值取模之后的对象存在一个链表放在hash值对应的槽位
红黑树 JDK8使用红黑树来替代超过8个节点的链表，主要是查询性能的提升，从原来的O(n)到O(logn),
通过hash碰撞，让HashMap不断产生碰撞，那么相同的key的位置的链表就会不断增长，当对这个Hashmap的相应位置进行查询的时候，就会循环遍历这个超级大的链表，性能就会下降，所以改用红黑树

24、什么是JVM，JRE，JDK？⭐

JVM（Java Virtual Machine）：Java虚拟机，是Java程序运行时的解释执行环境。JVM负责加载、解释和执行Java字节码。
JRE（Java Runtime Environment）：Java运行时环境，是JVM与类库的结合。JRE包含了JVM以及Java程序运行所需的库和文件，但不包含编译工具。
JDK（Java Development Kit）：Java开发工具包，包含了JRE和开发Java程序所需的工具，如编译器（javac）、调试器（jdb）、文档工具（javadoc）等。

25、HashMap和HashTable区别难度系数：⭐

线程安全性不同
HashMap是线程不安全的，HashTable是线程安全的，其中的方法是Synchronized，在多线程并发的情况下，可以直接使用HashTable，但是使用HashMap时必须自己增加同步处理。
是否提供contains方法
HashMap只有containsValue和containsKey方法；HashTable有contains、containsKey和containsValue三个方法，其中contains和containsValue方法功能相同。
key和value是否允许null值
Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
数组初始化和扩容机制
HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。

26、线程的创建方式难度系数：⭐

继承Thread类创建线程
实现Runnable接口创建线程
使用Callable和Future创建线程有返回值
使用线程池创建线程

# 代码演示
import java.util.concurrent.*;
public class threadTest{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //继承thread
        ThreadClass thread = new ThreadClass();
        thread.start();
        Thread.sleep(100);
        System.out.println("#####################");
 
        //实现runnable
        RunnableClass runnable = new RunnableClass();
        new Thread(runnable).start();
        Thread.sleep(100);
        System.out.println("#####################");
 
        //实现callable
        FutureTask futureTask = new FutureTask(new CallableClass());
        futureTask.run();
        System.out.println("callable返回值：" + futureTask.get());
        Thread.sleep(100);
        System.out.println("#####################");
 
        //线程池
        ThreadPoolExecutor threadPoolExecutor = new T