Java高频面试题汇总（2022）

矫情吗；* 2023-09-29 16:30 77阅读 0赞

**Java**

**1. ArrayList和LinkedList的区别**

Array(数组)是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。 Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据。 缺点: 数组初始化必须指定初始化的长度, 否则报错。 List—是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式，它继承Collection。List有两个重要的实现类:ArrayList和LinkedList ArrayList: 可以看作是能够自动增长容量的数组 ArrayList的toArray方法返回一个数组 ArrayList的asList方法返回一个列表 ArrayList底层的实现是Array, 数组扩容实现， LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于 ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。

**2. HashMap和HashTable的区别**

**父类不同** HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都同时实现 了map、Cloneable(可复制)、Serializable(可序列化)这三个接口。 **对外提供的接口不同** Hashtable比HashMap多提供了elments() 和contains() 两个方法。 elements() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的 value的枚举。contains()方法判断该Hashtable是否包含传入的value。它的作用与containsValue()一致。事实上， contansValue() 就只是调用了一下contains() 方法。 **对null支持不同** Hashtable:key和value都不能为null。 HashMap:key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性;可以有多个key 值对应的value为null。 **安全性不同** HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己 处理多线程的安全问题。 Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。 虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的 使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。 ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为 ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。 **初始容量大小和每次扩充容量大小不同** **计算hash值的方法不同**

**3. List,Set,Map三者的区别**

**List**(对付顺序的好帮手): List接口存储一组不唯一(可以有多个元素引用相同的对象)，有序的对象。 **Set**(注重独一无二的性质):不允许重复的集合。不会有多个元素引用相同的对象。 **Map**(用Key来搜索的专): 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。

**4. 是否可以继承 String 类?**

String 类是 final 类，不可以被继承，继承 String 本身就是一个错误的行为，对 String 类型最好的重用方式是关联关系(Has-A)和依赖关系(Use-A)而不是继承关系(Is-A)。

**5. ==和Equals区别**

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

**equals** 如果没重写equals方法比较的是两个对象的地址值 如果重写了equals方法后我们往往比较的是对象中的属性的内容 equals()方法最初在Object类中定义的，默认的实现就是使用==

**6. String、StringBuffer、StringBuilder**

String是final修饰的，不可变，每次操作都会产生新的String对象 StringBuffer和StringBuilder都是在原对象上操作 StringBuffer是线程安全的，StringBuilder线程不安全的 StringBuffer方法都是synchronized修饰的 **性能:** StringBuilder > StringBuffer > String **场景:** 经常需要改变字符串内容时优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

**7. 重载和重写的区别**

**重载:** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 **重写:** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

**8. BIO、NIO、AIO的区别**

**BIO (同步阻塞I/O模式)**

数据的读取写入必须阻塞在一个线程内等待其完成。 这里使用那个经典的烧开水例子，这里假设一个烧开水的场景，有一排水壶在烧开水，BIO的工作模式就是， 叫一个线程停留在一个水壶那，直到这个水壶烧开，才去处理下一个水壶。但是实际上线程在等待水壶烧开的时间段什么都没有做。

**NIO（同步非阻塞）** 同时支持阻塞与非阻塞模式，但这里我们以其同步非阻塞I/O模式来说明，那么什么叫做同步非阻塞？如果还拿烧开水来说，NIO的做法是叫一个线程不断的轮询每个水壶的状态，看看是否有水壶的状态发生了改变，从而进行下一步的操作。

**AIO （异步非阻塞I/O模型）** 异步非阻塞与同步非阻塞的区别在哪里？异步非阻塞无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理。对应到烧开水中就是，为每个水壶上面装了一个开关，水烧开之后，水壶会自动通知我水烧开了。

<table> 
 <thead> 
  <tr> 
   <th>IO</th> 
   <th>NIO</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>面向流(Stream Oriented)</td> 
   <td>面向缓冲区(Buffer Oriented)</td> 
  </tr> 
  <tr> 
   <td>阻塞IO(Blocking IO)</td> 
   <td>非阻塞IO(Non Blocking IO)</td> 
  </tr> 
  <tr> 
   <td>无</td> 
   <td>选择器(Selectors)</td> 
  </tr> 
 </tbody> 
</table>

**9. 常用io类有那些**

File
    FileInputSteam，FileOutputStream 
    BufferInputStream，BufferedOutputSream 
    PrintWrite
    FileReader，FileWriter
    BufferReader，BufferedWriter 
    ObjectInputStream，ObjectOutputSream

**10. HashMap（数组+链表+红黑树）**

HashMap 根据键的 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快 的访问速度，但遍历顺序却是不确定的。 HashMap 最多只允许一条记录的键为 null，允许多条记 录的值为 null。 HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导 致数据的不一致。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力，或者使用 ConcurrentHashMap。大方向上， HashMap 里面是一个数组，然后数组中每个元素是一个单向链表。上图中，每个绿色 的实体是嵌套类 Entry 的实例， Entry 包含四个属性： key, value, hash 值和用于单向链表的 next。

*  capacity：当前数组容量，始终保持 2^n，可以扩容，扩容后数组大小为当前的 2 倍。
 *  loadFactor：负载因子，默认为 0.75。
 *  threshold：扩容的阈值，等于 capacity \* loadFactor。 Java8 对 HashMap 进行了一些修改， 最大的不同就是利用了红黑树，所以其由 数组+链表+红黑 树组成。 根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决 于链表的长度，为 O(n)。为了降低这部分的开销，在 Java8 中，当链表中的元素超过了 8 个以后，会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为 O(logN)。
    
    (1)JDK8对hash函数做了优化，JDK8还有别的优化吗？讲讲为什么要做这几点优化？
 *  数组+链表改成了数组+链表或红黑树;
 *  链表的插入方式从头插法改成了尾插法，简单说就是插入时，如果数组位置上已经有元素，1.7将新元素放到数组中，原始节点作为新节点的 后继节点，1.8遍历链表，将元素放置到链表的最后;
 *  扩容的时候1.7需要对原数组中的元素进行重新hash定位在新数组的位置，1.8采用更简单的判断逻辑，位置不变或索引+旧容量大小;
 *  在插入时，1.7先判断是否需要扩容，再插入，1.8先进行插入，插入完成再判断是否需要扩容;  
    **原因：**
 *  防止发生hash冲突，链表长度过长，将时间复杂度由O(n)降为O(logn);
 *  因为1.7头插法扩容时，头插法会使链表发生反转，多线程环境下会产生环；
 *  A线程在插入节点B，B线程也在插入，遇到容量不够开始扩容，重新hash，放置元素，采用头插法，后遍历到的B节点放入了头部，这样形成了环。
 *  扩容的时候为什么1.8不用重新hash就可以直接定位原节点在新数据的位置呢?
    
     *  这是由于扩容是扩大为原数组大小的2倍，用于计算数组位置的掩码仅仅只是高位多了一个1，怎么理解呢？扩容前长度为16，用于计算(n-1) & hash 的二进制n-1为0000 1111，扩容为32后的二进制就高位多了1，为0001 1111。

**11. 说说ConcurrentHashMap**

**Segment段** ConcurrentHashMap 和 HashMap 思路是差不多的，但是因为它支持并发操作，所以要复杂一 些。整个 ConcurrentHashMap 由一个个 Segment 组成， Segment 代表”部分“或”一段“的 意思，所以很多地方都会将其描述为分段锁。注意，行文中，我很多地方用了“槽”来代表一个 segment。 **线程安全（Segment 继承 ReentrantLock 加锁）** 简单理解就是， ConcurrentHashMap 是一个 Segment 数组， Segment 通过继承ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全 **并行度（默认 16）** concurrencyLevel：并行级别、并发数、 Segment 数，怎么翻译不重要，理解它。默认是 16，也就是说 ConcurrentHashMap 有 16 个 Segments，所以理论上， 这个时候，最多可以同时支持 16 个线程并发写，只要它们的操作分别分布在不同的 Segment 上。这个值可以在初始化的时候设置为其他值，但是一旦初始化以后，它是不可以扩容的。再具体到每个 Segment 内部，其实每个 Segment 很像之前介绍的 HashMap，不过它要保证线程安全，所以处理起来要麻烦些。 **Java8 实现(引入了红黑树)** Java8 对 ConcurrentHashMap 进行了比较大的改动,Java8 也引入了红黑树。

**12. try catch ﬁnally，try里有return，ﬁnally还执行么？**

执行，并且ﬁnally的执行早于try里面的return结论：

*  不管有木有出现异常，ﬁnally块中代码都会执行；
 *  当try和catch中有return时，ﬁnally仍然会执行；
 *  ﬁnally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管ﬁnally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在ﬁnally执行前确定的；
 *  ﬁnally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

**13. &和&&的区别**

*  &
    
     *  按位运算符
     *  逻辑运算符 作为逻辑运算符时，&左右两端条件式有一个为假就会不成立，但是两端都会运行。
 *  && &&也叫做短路运算符，因为只要左端条件式为假直接不成立，不会去判断右端条件式。

## **JVM** ##

**1. 三色标记法**

三色标记法将对象的颜色分为了黑、灰、白，三种颜色。 白色：该对象没有被标记过。（对象垃圾） 灰色：该对象已经被标记过了，但该对象下的属性没有全被标记完。（GC需要从此对象中去寻找垃圾） 黑色：该对象已经被标记过了，且该对象下的属性也全部都被标记过了。（程序所需要的对象）

**三色标记存在问题**

*  浮动垃圾：并发标记的过程中，若一个已经被标记成黑色或者灰色的对象，突然变成了垃圾，由于不会再对黑色标记过的对象重新扫描,所以不会被发现，那么这个对象不是白色的但是不会被清除，重新标记也不能从GC Root中去找到，所以成为了浮动垃圾，浮动垃圾对系统的影响不大，留给下一次GC进行处理即可。
 *  对象漏标问题（需要的对象被回收）：并发标记的过程中，一个业务线程将一个未被扫描过的白色对象断开引用成为垃圾（删除引用），同时黑色对象引用了该对象（增加引用）（这两部可以不分先后顺序）；因为黑色对象的含义为其属性都已经被标记过了，重新标记也不会从黑色对象中去找，导致该对象被程序所需要，却又要被GC回收，此问题会导致系统出现问题，而CMS与G1，两种回收器在使用三色标记法时，都采取了一些措施来应对这些问题，CMS对增加引用环节进行处理（Increment Update），G1则对删除引用环节进行处理(SATB)。

**2. CMS收集器和G1收集器的区别**

**使用范围不一样** CMS收集器是老年代的收集器，可以配合新生代的Serial和ParNew收集器一起使用G1收集器收集范围是老年代和新生代。不需要结合其他收集器使用**STW的时间** CMS收集器以最小的停顿时间为目标的收集器。G1收集器可预测垃圾回收的停顿时间（建立可预测的停顿时间模型）**垃圾碎片** CMS收集器是使用“标记-清除”算法进行的垃圾回收，容易产生内存碎片G1收集器使用的是“标记-整理”算法，进行了空间整合，降低了内存空间碎片**垃圾回收的过程不一样** CMS收集器：初始标记-并发标记-重新标记-并发清理G1收集器：初始标记-并发标记-最终标记-筛选回收

> CMS的总结和优缺点 CMS采用 标记-清理 的算法，标记出垃圾对象，清除垃圾对象。算法是基于老年代执行的，因为新生代产生无法接受该算法产生的碎片垃圾。 **优点：** 并发收集，低停顿 **不足：** 无法处理浮动垃圾，并发收集会造成内存碎片过多 由于并发标记和并发清理阶段都是并发执行，所以会额外消耗CPU资源 G1回收器的特点 **控制回收垃圾的时间：** 这个是G1的优势，可以控制回收垃圾的时间，还可以建立停顿的时间模型，选择一组合适的Regions作为回收目标，达到实时收集的目的 **空间整理：** 和CMS一样采用标记-清理的算法，但是G1不会产生空间碎片，这样就有效的使用了连续空间，不会导致连续空间不足提前造成GC的触发

**3. 类加载机制**

JVM 类加载机制分为五个部分：加载，验证，准备，解析，初始化，使用，卸载

**4. 双亲委派机制**

当一个类收到了类加载请求，他首先不会尝试自己去加载这个类，而是把这个请求委派给父类去完成，每一个层次类加载器都是如此，因此所有的加载请求都应该传送到启动类加载其中，只有当父类加载器反馈自己无法完成这个请求的时候（在它的加载路径下没有找到所需加载的Class）， 子类加载器才会尝试自己去加载。**好处:**

*  主要是为了安全性，避免用户自己编写的类动态替换 Java的一些核心类，比如 String。
 *  同时也避免了类的重复加载，因为 JVM中区分不同类，不仅仅是根据类名，相同的 class文件被不 同的 Clas