Java基础常见面试题整理

Java基本数据类型

• 字节型：byte （1字节），范围-128~127
• 短整型：short（2字节），范围-32768~32767
• 整形：int（4字节），范围-2147483648~2147483647
• 长整形：long（8字节）， 范围-9223372036854775808L~9223372036854775807L
• 单精度浮点型：float（4字节），范围+/-3.4E+38F（6~7 个有效位）
• 双精度浮点型：double（8字节），范围+/-1.8E+308 (15 个有效位）
• 字符串：char（2字节）
• 布尔型：boolean（1字节）

Java8新特性

• Lambda表达式，允许把函数作为一个方法的参数
• 方法引用(:: 域操作符)，与Lambda配合使用，使代码更优雅
• 接口增添了默认方法(Defaulable)和静态方法
• Stream API，把真正的函数式编程风格引入到Java中
• 使用@Repeatable注解定义重复注解，允许在同一个地方多次使用同一个注解
• Java 8编译器在类型推断方面有很大的提升，从而使得代码更为简洁
• ……

接口和抽象类的区别是什么

• 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
• 接口中除了 static、final 变量，不能有其他变量，而抽象类中则不一定。
• 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口。
• 接口方法默认修饰符是 public，抽象方法可以有 public、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰）。
• 实现接口需要重写其所有方法，而继承抽象类可以只重写某些方法。
• 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

final关键字

• final修饰成员变量表示常量，只能被赋值一次，赋值后值不再改变。
• final修饰的方法不能被重写，但可以被继承。
• final修饰类不能被继承。

String,StringBuilder,StringBuffer的区别是什么

• String是字符串常量（内部private final char value[]），所以字符内容是不可改变的。
• 当+操作符操作已存在的变量时，其本质是创建了StringBuilder对象调用append方法。
• StringBuffer是线程安全的，而StringBuilder是非线程安全的。因此在效率上StringBuilder>StringBuffer。
• 相同之处：都是final类，都不允许被继承。

请说说ArrayList、Vector和LinkedList的区别

• ArrayList和Vector底层都是数组实现，这样的实现注定查找快、增删慢。
• ArrayList和Vector的区别在于线程安全问题，Vector支持线程同步，是线程访问安全的，而ArrayList线程不安全
• LinkedList底层是链表结构，查找元素慢、增删元素速度快，线程不安全。
• 相同点：都是单列集合Collection下List集合的实现类，所以他们的共同点，元素有序，允许重复元素。
• 线程安全的List：CopyOnWriteArrayList

HashMap

• HashMap底层将key-value作为一个整体（Node对象）来进行处理，本质上就是Node的数组，存储值时使用key的hash值寻址存储，读取时根据key的hash值寻址读取，默认容量为16，负载因子0.75，到达16*0.75进行扩容，每次扩容为当前的两倍。
• HashMap线程不安全，如需要保证线程安全可使用ConcurrentHashMap、HashTable、Collections.SynchronizedMap。
• 为什么从头插入改成尾插入，更多面试题。

    

有没有有顺序的Map实现类，如果有，他们是怎么保证有序的

• TreeMap和LinkedHashMap是有序的。
• TreeMap基于红黑树实现，每个key-value都作为一个红黑树的节点，同时实现了SortedMap接口以保障元素顺序存取(默认key升序，可自定义)。
• LinkedHashMap是基于链表来实现数据插入有序的，在HashMap的基础上将每个Node使用链表相连。

ConcurrentHashMap

• 其引用了内部的 Segment ( ReentrantLock ，默认16)  分段锁，保证在操作不同段 map 的时候， 可以并发执行， 操作同段 map 的时候，进行锁的竞争和等待，从而达到线程安全， 且效率大于 synchronized。
• Java8为什么放弃了分段锁：1.减少内存开销。2.生产环境中， map 在放入时竞争同一个锁的概率非常小，分段锁反而会造成更新等操作的长时间等待。3.为了提高 GC 的效率。
• 新同步方案：CAS 机制 + synchronized 来保证并发安全性。

HashSet、TreeSet的实现原理和底层数据结构

• HashSet底层使用HashMap实现(public HashSet() { map = new HashMap<>(); })。
• HashSet底层结构为哈希表结构（数组加链表结构），线程不安全。
• TreeSet基于TreeMap实现(public TreeSet() { this(new TreeMap<E,Object>()); })。
• TreeSet底层结构为红黑树，线程不安全。
• 线程安全的Set：CopyOnWriteArraySet。

说说== 、equals()的区别

• == 判断基本类型对象时，判断其值是否相等；判断引用对象时，判断其地址是否相等。
• equals()由Object类提供，默认实现判断两个对象的地址是否相同，String，Integer等类重写了equals()，判断其值是否相同。
• 重写equals()需要遵守的准则：1.自反性、2.对称性、3.传递性、4.一致性、5.非空性
• 当重写 equals() 方法的时候，最好也要重写 hashCode() 方法。

说说equals()和hashCode() 的关系

• hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。
• 理解：equals()和hashCode()的关系体现在当我们需要将对象存进HashMap等相关类时，HashMap会先判断其hashcode值，如果相等，继续调用equals()来确定该对象是否已存在。
• 结论：equals 相等的 hashcode一定相等，反之不一定。

深拷贝和浅拷贝实现

• 浅拷贝：实现Cloneable接口，重写clone()方法，直接调用super().clone()。
• 深拷贝：实现浅拷贝，再调用需要深拷贝对象的.clone()方法。

序列化与反序列化

• 序列化：把对象转换为字节序列的过程称为对象的序列化。
• 反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
• 为什么序列化：数据需要序列化以后才能在网络间传输。
• 怎么序列化：构造ObjectOutputStream(对象流)对象，使用其writeObject()方法。
• 什么情况下会用到序列化：1.当你想把内存中的对象写入到硬盘时、2.当你想用套接字在网络上传输对象时、3.当你想通过RMI调用对象时。
• 哪些字段不会被序列化：transient关键字修饰的字段、静态字段。
• 反序列化会遇到什么问题：如果反序列化对象的类被改动，会出现反序列化失败；解决：为类生成serialVersionUID。

异常

• 异常模型：

    

• Error：一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
• Exception：表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
• RuntimeException(运行时异常)：不需要显式捕获。
• 常见运行时异常：NullPointerException(空指针引用异常)、IndexOutOfBoundsException(下标越界异常)、ClassCastException(类型强制转换异常)、ArithmeticException(算术运算异常)、IllegalArgumentException(传递非法参数异常)、NumberFormatException(数字格式异常)。

泛型

• 概念：提供了编译时类型的安全检查机制，本质是参数化类型。
• 类型擦除：在编码阶段采用泛型时加上的类型参数，在编译阶段会被擦除。

注解

• 概念：设置程序中元素的关联信息和元数据，可以通过反射获取指定的注解对象。
• 标准元注解：
• @Target：注解所修饰对象的范围(TYPE、FIELD、METHOD、PARAMENTER……)。
• @Retention：注解被保留的级别(SOURCE、CLASS、RUNTIME)。
• @Document：表示注解应该被javadoc工具记录。
• @Inherited：表示某个被标注的类型是被继承的。

反射机制

• 概念：在程序运行中，可以动态获取任一个类的所有信息。
• 相关类：Class(获取类属性、方法等)、Field(获取和设置属性)、Method(获取或执行方法)、Constructor(类构造)。
• Class.forName和ClassLoader区别：前者除了将类的.class文件加载到JVM中之外，还会对类进行解释，执行类中的static块；而classLoader就是将.class文件加载到JVM中，不会执行static块中的内容，只有在newInstance才会去执行static块。
• 性能影响：反射是一种解释操作，我们需告诉JVM怎么做，比直接写代码会慢一点。

IO常见概念

• 同步：当一个同步调用发出后，需要等待返回消息（用户线程不断去询问），才能继续进行。
• 异步：当一个异步调用发出后，调用者不用等待返回消息；完成后会通过状态、通知和回调来通知调用者。
• 阻塞：当前线程会被挂起，直到结果返回。
• 非阻塞：指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回（会导致线程切换的增加）。

讲讲IO模型，BIO、NIO、AIO)的区别是啥，谈谈reactor模型

• IO模型：阻塞I/O模型、非阻塞I/O模型、多路复用I/O模型、信号驱动I/O模型。
• BIO (Blocking I/O): 同步阻塞 I/O 模式，就是平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机 1000）的情况下，这种模型是比较不错的。
• NIO (Non-blocking/New I/O): NIO 是一种同步非阻塞的 I/O 模型，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。在 Java 1.4 中引入了 NIO 框架，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞 I/O 来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发。

     

• AIO (Asynchronous I/O): AIO 也叫 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的 IO 模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
• Reactor模型：Reactor模型与Proactor模型。

简述TCP和UPD的区别？

• TCP：是面向连接的流传输控制协议，具有高可靠性，确保传输数据的正确性，有验证重发机制，因此不会出现丢失或乱序。
• UDP：是无连接的数据报服务，无法保证数据准确性，数据传输快，UDP段结构比TCP的段结构简单，因此网络开销也小。

TCP三次握手

• 第一次：客户端发送SYN报文给服务端，进入SYN_SEND状态。
• 第二次：服务端收到SYN报文后，回应一个SYN和ACK报文，进入SYN_REVC状态。
• 第三次：客户端收到服务端的SYN报文，回应一个ACK报文，进入Established状态。
• 如果只有两次握手：若客户端未发消息给服务端，服务端就会一直在等待客户端，造成资源浪费。

TCP四次挥手

• 第一次：客户端应用程序断开连接请求，向服务端发送一个消息。
• 第二次：服务受返回一个消息给客户端，表示接收到客户端的请求。
• 第三次：服务端发送消息给客户端，表示服务端需要向客户端发送的消息已经发送完毕。
• 第四次：客户端收到最终消息后，发送一个消息给服务端，表示收到请求并断开链路。

说一下 TCP 粘包是怎么产生的？

• TCP 粘包可能发生在发送端或者接收端，分别来看两端各种产生粘包的原因：
• 发送端粘包：发送端需要等缓冲区满才发送出去，造成粘包。
• 接收方粘包：接收方不及时接收缓冲区的包，造成多个包接收。

HTTP的传输流程和HTTPS的加密流程

HTTP：地址解析 -> 封装HTTP数据包 -> 封装TCP包 -> 建立TCP连接 -> 客户端发送请求 -> 服务器响应 -> 服务器关闭TCP链接。

HTTPS：发送请求 -> 证书返回 -> 证书验证 -> 秘钥交换 -> 数据传输。

什么是HTTP长连接和短连接

• （HTTP 1.0 默认）短连接：客户端和服务器每进行一次操作都会建立一次连接，结束就会关闭。
• （HTTP 1.1 默认）长连接：客户端和服务器进行一次操作后不会关闭连接，如果客户端再次访问这个网页，会继续之前的连接。
• （会在响应头加入Connection：keep-alive），长连接有一定是保持时间在服务器软件中能设置这个时间。
• 各自的优缺点：长连接可以省去较多的tcp连接和关闭操作，较少浪费，节省时间。 但是容易受到恶意攻击，所以设置过期时间。
• 短连接对于服务器的管理较为简单存在的连接都是有用的。 但是如果客户端用户操作频繁，在tcp的建立和关闭上浪费时间和带宽。

说说进程,线程,协程之间的区别

• 进程：进程是系统运行程序和资源分配的基本单位，一个程序至少有一个进程；在执行过程中拥有独立的内存单元。
• 线程：线程是cpu调度的基本单位，一个进程至少有一个线程；共享内存资源，减少切换次数从而效率更高。
• 协程：协程是轻量级的线程，一个进程可轻松创建数十万计的协程。协程可以通过yield来调用其它协程，拥有自己的寄存器上下文和栈。

守护线程吗和非守护线程有什么区别

• 用户线程：非守护线程包括常规的用户线程或诸如用于处理GUI事件的事件调度线程，Java虚拟机在它所有非守护线程已经离开后自动离开。
• 守护线程：守护线程则是用来服务用户线程的，比如说典型的GC线程。为用户线程提供公共服务，在没有用户线可服务时会自动离开。

什么是Java内存模型（JMM）？

• 内存模型：为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范。
• 是什么：JMM就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。
• 解决的问题：解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。
• 内存模型解决并发问题主要采用两种方式：限制处理器优化和使用内存屏障。
• Java内存模型和硬件架构之间的桥接：

    

多线程

• 是什么，作用：多线程能够在操作系统多核配置基础上，能够更好利用CPU资源。
• 常见创建方式：1.继承Thread、2.实现Runnable接口、3.基于线程池(Executors框架)。
• 生命周期图：

     

• 各方法对线程状态的影响：

    

sleep方法与wait方法的区别

• sleep方法属于Thread类，wait方法则属于Object类。
• 在调用sleep方法的过程中，线程不会释放对象锁。sleep方法暂停执行指定的时间，让出CPU给其他线程，但其监控状态依然保持，在指定的时间后又自动恢复运行状态。
• 在调用wait方法时，线程会放弃锁对象，进入等待此对象的等待锁池，只有针对此对象的notify方法后，该线程才能进入对象锁池准备获取对象锁，并进入运行状态。

什么是抢占式调度算法，Thread.sleep(0)的作用是什么？

• 抢占式：一个线程用完CPU之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。
• 由于Java采用抢占式的线程调度算法，因此可能会出现某条线程常常获取到CPU控制权的情况，为了让某些优先级比较低的线程也能获取到CPU控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡CPU控制权的一种操作。

什么是阻塞队列？

• 阻塞队列是一个在队列基础上又支持了两个附加操作的队列。
• 2个附加操作：
• 支持阻塞的插入方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。
• 支持阻塞的移除方法：队列空时，获取元素的线程会等待队列变为非空。
• Java中堵塞队列的实现：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。

如何使用阻塞队列来实现生产者-消费者模型？

• 使用通知模式实现，分为消费者堵塞和生产者堵塞。
• 消费者堵塞：在队列为空时，消费者端的线程都会被自动堵塞(挂起)，直到有数据放入队列，消费者线程会被自动唤醒并消费数据。
• 生产者堵塞：在队列已满且没有可用空间时，生产端的线程都会被自动堵塞，直到队列中有空位置出现，线程会被自动唤醒并产生数据。

Java当中有哪几种锁

• 自旋锁: 自旋锁在JDK1.6之后就默认开启了。基于之前的观察，共享数据的锁定状态只会持续很短的时间，为了这一小段时间而去挂起和恢复线程有点浪费，所以这里就做了一个处理，让后面请求锁的那个线程在稍等一会，但是不放弃处理器的执行时间，看看持有锁的线程能否快速释放。为了让线程等待，所以需要让线程执行一个忙循环也就是自旋操作。在jdk6之后，引入了自适应的自旋锁，也就是等待的时间不再固定了，而是由上一次在同一个锁上的自旋时间及锁的拥有者状态来决定
• 偏向锁: 在JDK1.之后引入的一项锁优化，目的是消除数据在无竞争情况下的同步原语。进一步提升程序的运行性能。 偏向锁就是偏心的偏，意思是这个锁会偏向第一个获得他的线程，如果接下来的执行过程中，改锁没有被其他线程获取，则持有偏向锁的线程将永远不需要再进行同步。偏向锁可以提高带有同步但无竞争的程序性能，也就是说他并不一定总是对程序运行有利，如果程序中大多数的锁都是被多个不同的线程访问，那偏向模式就是多余的，在具体问题具体分析的前提下，可以考虑是否使用偏向锁。
• 轻量级锁: 为了减少获得锁和释放锁所带来的性能消耗，引入了“偏向锁”和“轻量级锁”，所以在Java SE1.6里锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态，它会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁

Synchronized的升级顺序

• 无锁-->偏向锁-->轻量级锁-->重量级锁，顺内不可逆。
• 偏向锁-->轻量级锁：当有另外一个线程竞争获取这个锁时，由于该锁已经是偏向锁，当发现对象头中的线程 ID 不是自己的线程 ID，就会进行 CAS 操作获取锁，如果获取成功，直接替换线程 ID 为自己的 ID，该锁会保持偏向锁状态；如果获取锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。
• 轻量级锁-->重量级锁：如果同一时刻内有多个线程访问同一个锁，就会导致轻量级锁膨胀为重量级锁。

什么是乐观锁、悲观锁和自旋锁

• 乐观锁：在每次读取数据时都认为别人不会修改该数据，所以不会上锁，当更新该数据时会判断在此期间别人有没有更新改数据。具体通过比较版本号，一直则更新，不一致则重复进行读、比较、写操作。
• 悲观锁：在每次读取数据时都认为别人会修改数据，所以每次在读写数据时都会上锁。Java中大部分悲观锁基础AQS架构实现。
• 自旋锁：如果持有锁的线程能在很短的时间内释放锁资源，那么那些等待竞争锁的线程就不需要做切换而进入堵塞、挂起状态，只需等一等，避免用户线程在内核状态上切换导致的时间损耗。

什么是CAS、AQS

• CAS(Compare And Swap)，即比较并交换。是解决多线程并行情况下使用锁造成性能损耗的一种机制，CAS操作包含三个操作数——内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS有效地说明了“我认为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要更改该位置，只告诉这个位置现在的值即可。
• CAS自旋等待：由于CPU的切换比CPU指令集的操作更加耗时，所以CAS的自旋操作在性能上有很大提升。
• ABA问题：CAS需要屈从内存中某时刻的数据，然后在下一个时刻进行比较、替换，在这个时间差内数据可能已经发生了变换，导致ABA问题，部分乐观锁是通过添加版本号来解决ABA问题的。
• AQS(Abstract Queued Synchronizer)是一个抽象队列同步器，通过维护一个共享资源状态(Volatile Int State)和一个先进先出的线程等待队列来实现一个多线程访问共享资源的同步框架。

如何实现同步（volatile和锁）

• 使用volatile修饰字段、使用synchronize关键字、使用ReentrantLock实现类。
• synchronize修饰成员方法：锁住的是对象的实例，即this对象。
• synchronize修饰静态的方法：锁住的是Class对象。
• synchronize修饰一个代码块：1.synchronize(this){}等同于修改对象方法、2.synchronize(xx.class){}等同于修饰静态方法。
• 如何进行锁优化：减少锁持有时间、减小锁粒度、锁分离、锁粗化、锁消除。

volatile和synchronize的区别

• volatile只能修饰于变量，而synchronized可以修饰方法、代码块。
• volatile是线程同步的轻量级实现，不会发生阻塞性能比synchronized要好。
• volatile本质是在告诉JVM当前变量在寄存器中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
• volatile能保证数据的可见性，但不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。

synchronized和ReentrantLock的比较

• 相同点：1.都用于控制多线程对共享对象的访问、2.都是可重入锁、3.都保证了可见性和互斥性。
• 不同点：前者隐式获取和释放锁对象，后者显式获取和释放锁对象。
• 实现不同：前者属于JVM级别的是一个关键字，后者属于API级别的是一个类。
• 底层不同：前者是同步阻塞，采用悲观并发策略，后者是同步非阻塞，采用乐观并发策略。
• Lock可以知道有没有成功获取锁；可以定义读写锁提高多个线程读操作效率；可响应中断、可轮回，灵活性较高。

多线程如何共享数据

• 概述：在Java中多线程通信主要通过共享内存实现，共享内存主要关注三点（可见性、有序性、原子性）。JMM解决了可见性和有序性问题，而锁解决了原子性问题。
• 将数据抽象成一个类，并将对这个数据的操作封装在类的方法中
• 将Runnable对象作为一个内部类，将共享数据作为这个类的成员变量。