2023年 Java 面试八股文（20w字）

第一章-Java基础篇 1、你是怎样理解OOP面向对象 难度系数：⭐ 面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征：

继承：继承是从已有类得到继承信息创建新类的过程 封装：封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应 2、重载与重写区别 难度系数：⭐ 重载发生在本类，重写发生在父类与子类之间 重载的方法名必须相同，重写的方法名相同且返回值类型必须相同 重载的参数列表不同，重写的参数列表必须相同 重写的访问权限不能比父类中被重写的方法的访问权限更低 构造方法不能被重写 3、接口与抽象类的区别 难度系数：⭐ 抽象类要被子类继承，接口要被类实现 接口可多继承接口，但类只能单继承 抽象类可以有构造器、接口不能有构造器 抽象类：除了不能实例化抽象类之外，它和普通Java类没有任何区别 抽象类：抽象方法可以有public、protected和default这些修饰符、接口：只能是public 抽象类：可以有成员变量；接口：只能声明常量 4、深拷贝与浅拷贝的理解 难度系数：⭐ 深拷贝和浅拷贝就是指对象的拷贝，一个对象中存在两种类型的属性，一种是基本数据类型，一种是实例对象的引用。

浅拷贝是指，只会拷贝基本数据类型的值，以及实例对象的引用地址，并不会复制一份引用地址所指向的对象，也就是浅拷贝出来的对象，内部的类属性指向的是同一个对象 深拷贝是指，既会拷贝基本数据类型的值，也会针对实例对象的引用地址所指向的对象进行复制，深拷贝出来的对象，内部的类执行指向的不是同一个对象 5、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(2000);

            //sleep 释放cpu不释放锁
            //Thread.sleep(2000);
            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());
}

}

Java

6、什么是自动拆装箱 int和Integer有什么区别 难度系数：⭐ 基本数据类型，如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法。

装箱：将基本类型转换成包装类对象 拆箱：将包装类对象转换成基本类型的值 java为什么要引入自动装箱和拆箱的功能？主要是用于java集合中，List();

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

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

区别：

Integer是int的包装类，int则是java的一种基本数据类型 Integer变量必须实例化后才能使用，而int变量不需要 Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 Integer的默认值是null，int的默认值是0 7、==和equals区别 难度系数：⭐ == 如果比较的是基本数据类型，那么比较的是变量的值

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

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

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

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

8、String能被继承吗 为什么用final修饰 难度系数：⭐ 不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。 String 类是最常用的类之一，为了效率，禁止被继承和重写。 为了安全。String 类中有native关键字修饰的调用系统级别的本地方法，调用了操作系统的 API，如果方法可以重写，可能被植入恶意代码，破坏程序。Java 的安全性也体现在这里。 9、String buffer和String builder区别 难度系数：⭐ StringBuffer 与 StringBuilder 中的方法和功能完全是等价的， 只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。 在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低 10、final、finally、finalize 难度系数：⭐ final：修饰符（关键字）有三种用法：修饰类、变量和方法。修饰类时，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。修饰变量时，该变量使用中不被改变，必须在声明时给定初值，在引用中只能读取不可修改，即为常量。修饰方法时，也同样只能使用，不能在子类中被重写。 finally：通常放在try…catch的后面构造最终执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。 finalize：Object类中定义的方法，Java中允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize() 方法可以整理系统资源或者执行其他清理工作。 11、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() 12、说一下集合体系 难度系数：⭐

13、ArrarList和LinkedList区别 难度系数：⭐
ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 对于随机访问get和set，ArrayList效率优于LinkedList，因为LinkedList要移动指针。 对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。 14、HashMap底层是 数组+链表+红黑树，为什么要用这几类结构 难度系数：⭐⭐ 数组 Node<K,V>[] table ,哈希表，根据对象的key的hash值进行在数组里面是哪个节点 链表的作用是解决hash冲突，将hash值取模之后的对象存在一个链表放在hash值对应的槽位 红黑树 JDK8使用红黑树来替代超过8个节点的链表，主要是查询性能的提升，从原来的O(n)到O(logn), 通过hash碰撞，让HashMap不断产生碰撞，那么相同的key的位置的链表就会不断增长，当对这个Hashmap的相应位置进行查询的时候，就会循环遍历这个超级大的链表，性能就会下降，所以改用红黑树 15、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倍。

16、线程的创建方式 难度系数：⭐ 继承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 ThreadPoolExecutor(1, 1, 2, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
    threadPoolExecutor.execute(thread);
    threadPoolExecutor.shutdown();
    Thread.sleep(100);
    System.out.println("#####################");

    //使用并发包Executors
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    executorService.execute(thread);
    executorService.shutdown();
}

}

class ThreadClass extends Thread{ @Override public void run() { System.out.println("我是继承thread形式：" + Thread.currentThread().getName()); } }

class RunnableClass implements Runnable{ @Override public void run(){ System.out.println("我是实现runnable接口：" + Thread.currentThread().getName()); } }

class CallableClass implements Callable { @Override public String call(){ System.out.println("我是实现callable接口："); return "我是返回值，可以通过get方法获取"; } }

Java

17、线程的状态转换有什么（生命周期） 难度系数：⭐

新建状态(New) ：线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。 运行状态(Running)：线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。 阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种： 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join(）等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。 死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。 18、Java中有几种类型的流 难度系数：⭐

19、请写出你最常见的5个RuntimeException 难度系数：⭐ java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象。

java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误；通常都是程序试图通过字符串来加载某个类时可能引发异常。

java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符。

java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生。

java.lang.IllegalArgumentException 方法传递参数错误。

java.lang.ClassCastException 数据类型转换异常。