CSDN最强Java面试八股文很详细了！！！

Java八股文

于 2024-08-12 14:42:49 发布

阅读量812

点赞数 23

文章标签： java 面试 python spring boot 职场和发展 jvm spring

本文链接：https://blog.csdn.net/CXY123654654321/article/details/141131056

版权

一、java基础

面向对象有哪些特性？

面向对象有三大特性：封装，继承和多态

封装就是将类信息隐藏在类内部，不允许外部程序直接访问，而是通过调用类的方法去访问，良好的封装能减少耦合，增加安全性。
继承就是从已有的类派生出新的类，新的类继承父类的属性和方法，并扩展新的能力，极大提高了代码的复用行和易维护性。
多态是指同一个行为具有多种形式的表现，具体体现在继承，重写，重载，父类引用指向子类对象等，多态体现出面向对象的灵活性。
另外面向对象还有抽象的特性，指把客观事物用代码抽象出来。

StringBuilder和StringBuffer的区别

它们都继承于abstractStringBuilder，相对于String来说都是可变，StringBuffer添加了syncronized所以是线程安全的，而StringBuilder是线程不安全的

线程安全指，多个线程访问一个对象时，每个线程调用该对象的行为都能获得正确的结果

为什么静态方法不能调用非静态方法和变量？

类在加载的时候，会将所有被static修饰的内容（包括方法和属性）初始化，但此时非静态方法和变量还没有经过初始化，也就是没有内存空间，调用的时候就会出错。

异常，error和exception的区别，运行时异常和非运行时异常（checked）的区别？

JAVA异常的层次结构如图：

Throwable类是java所有异常和错误的顶类，有两个重要的子类

Error：处理JVM的内部严重问题，如资源不足，无法恢复

Exception：可以恢复的异常，分为RuntimeException（unchecked Exception）和其他Exception（checked Exception）

RuntimeException：运行时异常，处理或者不处理都可以（try/catch throw操作）

其他Exception：必须捕获或者声明抛出的异常

java内存模型JMM

JMM是一个抽象的规范，它定义了共享内存中多线程程序读写规范，即变量如何存储在内存中又如何从内存中读取（这里的变量指实例字段，静态变量，构成数组的元素）

JMM将内存分为主内存和工作内存

主内存是线程共享的公共区域，里面存储了共享变量
工作内存是线程私有的工作区域，里面存储了共享变量的副本
线程通常是对工作内存中的共享变量进行修改，然后同步到主内存，然后其他线程从主内存中同步更新自己的变量，也即，线程之间的交互是通过主内存的。

JMM对Java编程提供了原子性，可见性，有序性的保障

原子性：原子性就是说一个操作是不可分割的，不可中断的，要么执行完成，要么不执行，在JMM中通过lock操作实现，它保证了一个变量在同一时刻只能被一个线程访问，不会被其他线程影响而中断操作，对应关键字Syncronized

可见性：可见性指线程对一个变量的操作对其他线程来说是立即可见的，在JMM中通过在修改变量后变量同步到主内存，其他线程读取时刷新变量值来实现，对应关键字volatile,Syncronized

有序性：指本线程的所有操作都是有序的

在多线程中会有指令重排序的问题，通过volatile关键字解决

volatile的底层原理是内存屏障，Memory Barrier（Memory Fence）

常见的集合

Java中的集合主要由Collection（单列集合）和Map（双列集合）这两个接口派生而来

Collection下有子接口List，Queue,Set（无序）

List接口的实现类有ArrayList，vector（线程安全）,stack，LinkedList（双向链表）

Set接口的实现类有hashset（底层是hashMap），sortedSet（接口）、treeSet（底层是treeMap，遍历有序），LinkedHashSet

线程安全的集合：Vector、HashTable、ConcurrentHashMap、Stack（继承Vector）、ArrayBlockingQueue、ConcurrentLinkedQueue

重写与重载的区别

HashMap底层，插入，扩容

前置知识：

二叉树：每个节点至多只有两个子节点的树

搜索二叉树：满足当前节点的左子树上的节点不能大于当前节点，右子树上的节点不能小于当前节点的二叉树

红黑树：一种自平衡的搜索二叉树，能保证遍历，插入，删除的时间复杂度永远是O(logn)

红黑树规则：

红黑：节点只有红黑两种颜色，根节点和叶节点一定是黑色，红节点的子节点一定是黑色

树：叶节点一定是null，任一节点到叶节点的所有路径包含相同数量的黑节点

散列表：又称Hash表，是一种kv存储结构，存储时先计算k经过哈希函数运算后的值，然后根据这个值将v存放在对应的位置

HashMap底层实现是数组+链表/红黑树

添加数据时，根据key的hash值来确定value所在的数组下标

如果数组下标对应的链表/红黑树中有相同的key，就会替换value，否则加入到链表/红黑树中

jdk1.8之前采用的拉链法数组+链表

jdk1.8之后采用的数组+链表+红黑树法，链表长度大于8时，先尝试扩容数组，如果数组长度此时大于64则会从链表转化为红黑树。

插入操作（简化）：

1、判断数组是否为空，如果为空调用resize方法，初始化一个容量16的数组

2、对key进行hash运算，得到数组中的索引，table下标i=(table.length- 1) & ((h = key.hashCode()) ^ (h >>> 16))，如果索引指向的位置为空，则直接插入一个新的node

3、如果不为空，则判断当前key是否存在，如果存在直接进行替换value操作

4、如果不存在，判断当前Node节点是否是红黑树结构，如果是树类型，则按照树的方式去追加节点，否则在链表尾部插入数据

5、最后判断链表长度是否大于8，如果大于8，会先尝试扩容，判断数组长度是否小于64，是就扩容，否则链表转换为红黑树。

6、插入操作结束后，判断如果hashmap的元素个数超过了负载因子*容量的阈值，则需要进行扩容操作

7、扩容操作会将原来数组的元素分配到新的数组中，重新每个元素在数组中的下标

8、扩容操作完成后，再将元素插入到新的数组中

扩容操作：

1、在添加元素或初始化时扩容，执行resize方法，第一次初始化长度为16，以后每次在元素达到容量*负载因子（0.75）时，进行扩容

2、每次扩容操作后，容量都是之前的2倍

3、扩容之后，会创建一个新的数组，然后把老的数组中的元素移动到新的数组中

4、如果是链表，则计算每个链表元素的下标，然后移动到新的数组

5、如果是红黑树，则走红黑树的添加。

对象的创建方式

1、new

2、将类继承Cloneable接口，然后实现clone方法，调用clone方法即可复制对象

3、反射（类派发），Student.class.newInstance()

4、反射（动态加载），Class.forName("entity.Student").newInstance()

5、反射（构造方法），Student.class.getConstructor().newInstance()

6、Spring容器启动时将Bean注入

四种访问修饰符

1）public ：公共权限，可以被任意类访问，不同包不同类依然可以访问，

可修饰：类、成员变量、方法，内部类

2）protected：受保护的权限，可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问

可修饰：成员变量、方法、内部类

3）default：默认的(无)，同包权限，只能被同包的类访问

可修饰：类、成员变量、方法，内部类

4）private：私有权限，只能在本类中访问，同包其他类也不能访问

二、多线程

1、进程与线程的区别

概念：

进程是程序的一次执行结果，是系统运行的基本单位，每个进程都有自己的内存空间和系统资源，进程直接相互独立，但线程之间的运行是可以相互影响的。
线程是比进程更小的单位，一个进程中包含的多个线程，这些多个线程共享进程的内存空间和系统资源，所以线程之间的切换开销比较小。//线程运行在用户态，但是线程切换由操作系统内核完成，需要切换到核心态
协程是一种轻量级的线程，协程在用户态就可以控制，协程的上下文切换更加节省资源。

上下文的切换指的是CPU从当前正在运行的进程或线程中保存状态，然后切换到另一个线程或进程

区别：

进程是正在运行的程序的实例，线程是操作系统运算调度的最小单位，包含在进程当中，一个进程可以有多个线程
进程有自己的内存空间和系统资源，线程之间共享一个进程的内存空间和系统资源
进程之间相互独立，而线程之间是可以相互影响的
线程更加轻量，上下文切换开销比进程低

2、并行与并发的区别

并发是同一时间处理多件事的能力，比如多个线程轮流使用一个CPU

并行是同一时间做多件事的能力，比如4核CPU同时执行4个线程

关键区别在于是否同时执行

3、创建线程的方式有哪几种？Runnable与Callable有什么区别？run方法与start方法有什么区别

继承Tread类 ——直接调用start执行线程
实现Runnable接口——先创建MyRunnable对象，再创建Thread对象（将MyRunnable作为构造器参数），再执行start方法
实现Callable接口——先创建MyCallable对象，再创建futureTask对象，再创建Tread对象，再执行start方法
线程池创建（项目中一般使用方式）——对象要实现Runnable，然后创建线程池对象，调用线程池对象的submit方法

Runnable与Callable的区别：

Runnable接口的run方法没有返回值，而Callable接口的call方法有返回值，可以配合FutureTask获取返回结果
Runnable接口的run方法的异常只能在内部消化，而Callable接口的call方法可以将异常抛出

run方法与start方法区别：

start方法是开启一个线程，然后线程去调用run方法，start方法只能被调用一次
run方法封装了线程要执行的方法，可以调用多次

4、线程包含了几种状态，状态之间是如何转换的

线程包含了六种状态：

新建（New）：创建线程对象时
可执行（Runnable）：调用start方法后，有执行资格
阻塞（Blocked）：进入可执行状态后，无法获得锁
等待（Waiting）：执行时调用Wait方法进入（wait方法会释放锁）
计时等待（Timed_Waiting）：执行时调用Time.sleep进入
死亡（Terminated）：运行结束，线程死亡，变成垃圾

5、假设有t1,t2,t3三个线程，如何保证他们按顺序执行？

第一种方法：调用join方法：它使当前线程进入time_waiting状态，直到调用join方法的线程结束，比如t1.join()，就是在t1结束后才会继续运行。

具体：在t2线程的run方法中调用t1.join,在t3线程的run方法中调用t2.join

第二种方法：使用计数器countdownLatch：它需要先设定一个起始值，然后在线程中调用countdown方法让值-1，当值为0时，会解除wait状态

具体：

6、wait和sleep方法有哪些不同？

wait方法是Object类方法，每个对象都有，而sleep方法是Tread类静态方法

wait方法需要在同步块（synchronized）中执行，并且需要先获取锁，而sleep方法没有这个限制

wait方法执行后会释放锁，而sleep方法在拿到锁的情况下执行不会释放锁

7、为什么wait方法和notify方法要在synchronized关键字中使用？

从程序层面来说：不这样做会报IllegalMonitorStateException错误

从线程安全层面来说：如果不加同步锁，wait() 方法还没有执行完，notify() / notifyAll() 方法已经执行完，这样 notify() / notifyAll() 就进行了一次空唤醒操作，而 wait() 执行完后由于再没有notify() / notifyAll()的唤醒，会导致wait() 所在线程一直阻塞。

从底层代码层面来说：

首先，每个Java对象底层都会关联一个 Monitor 对象，在 Monitor 中维护了两个队列 WaitSet 和 EntryList ，owner 属性。

synchronized( lock ) 被调用后会将当前线程赋值给lock对象所关联的 monitor 对象的 owner 属性，其他线程再想获取 lock 锁对象的话如果发现 lock对象所关联的 monitor 对象的 owner 属性不为空，就会进入 EntryList 进行阻塞，而调用了wait() 后就会将 owner 指向的线程对象放入 WaitSet 中进行等待，并将 owner 置为 null （释放掉锁），直到其他线程获取到 lock 这个对象锁以后通过 notify() / notifyAll() 方法唤醒 WaitSet 中的线程，这时 WaitSet中等待的线程才会进入 EntryList 参与lock 锁的竞争。（ notify() / notifyAll() 并不会释放锁，只有等待 synchronized 执行完才会释放锁）