JAVA基础校招必备

对于 Object 来说，其 equals 方法底层实现就是“==”，都是比较对象的引用是否相同

JDK 中其他类通常会重写 equals 以实现具体的值比较，例如 Integer 中的 equals 和 String 中的 equals等

Integer 会先将 Integer 对象转换成基础类型 int 值来进行比较，所以此时就不再对比两个对象的引用了，而是对比两个对象的值相等

String 和 Integer 一样，是将 Object 中的引用比较重写成值比较

对于 Object 来说，== 和 equals 都是一样的，都是用来比较两个对象的引用是否相同

而其他 Java 类中，通常都会重写 equals 让其变为比较具体的值是否相同，而非引用是否相同

通常会使用 == 来对比两个对象引用是否相同；使用 equals 来对比两个值是否相同

指同一个类中定义多个方法，它们具有相同的名称但参数列表不同

因为返回值不同 JVM 无法分辨到底调用哪个方法

1. JVM 调用方法是通过方法签名来判断到底要调用哪个方法

2. 方法签名 = 方法名称 + 参数类型 + 参数个数组成的唯一值

3. 返回类型不是方法签名的组成部分，所以不同的返回类型也就不算方法重载，因为它不能让 JVM 确定要调用哪个方法

finally 中的代码一定会执行的

1. 程序在 try 块中遇到 System.exit() 方法，会立即终止程序执行

2. 在 try 中遇到 Runtime.getRuntime().halt() 代码，强制终止正在运行的 JVM。与上面方法不同，此方法不会触发 JVM 关闭程序。因此调用halt方法时，都不会执行关闭钩子和终结器

3. 程序在 try 块中遇到无限循环或者死锁等情况

4. 掉电问题（停电）

5. JVM 异常崩溃

是一种由父类提供的空或默认实现的方法，子类可以选择性地重写或扩展该方法

钩子是一段自定义代码，它在特定的事件或操作发生时被调用。通过钩子，程序员可以在不修改现有代码的情况下扩展或改变程序的行为。

在 Java 中，最常见的一种钩子是“关闭钩子”（ShutdownHook），用于在 Java 虚拟机（JVM）关闭时执行一些特定的任务。这些任务可能包括资源释放、临时文件删除、数据保存等清理操作。

System.exit()：Java.lang.System类的一个静态方法，会执行 JVM 关闭钩子或终结器

Runtime.getRuntime().halt()：Runtime 类的一个实例方法，不会执行 JVM 关闭钩子或终结器

多态是面向对象编程中的一个重要概念，它允许通过父类类型的引用变量来引用子类对象，并在运行时根据实际对象的类型来确定调用哪个方法。

一个对象可以根据不同的情况表现出多种形态

多态性 就是指用同样的方式（如调用 makeSound() 方法）对待不同的对象（如 Dog 或 Cat），而它们会表现出各自不同的行为。这使得程序更灵活、更易于扩展。

可替换性: 子类对象可以随时替代父类对象，向上转型。

可扩展性：通过添加新的子类，可以扩展系统的功能。

接口统一性：可以通过父类类型的引用访问子类对象的方法，统一对象的接口。

代码灵活性和可维护性：通过多态，可以将代码编写成通用的、松耦合的形式，提高代码的可维护性。

动态绑定和虚拟方法调用

实现原理综述

Java 中 List 接口的实现类

1. 底层实现不同：ArrayList 是基于动态数组的数据结构，LinkList 是基于链表的数据结构

2. 随机访问性能不同：ArrayList 优于 LinkedList，因为 ArrayList 可以根据下标以O(1) 时间复杂度对元素进行随机访问。
                                  LinkedList 的访问时间复杂度为 O(n)，因为它需要遍历整个链表才能找到指定的元素。

3. 插入和删除性能不同：LinkedList 优于 ArrayList，因为 LinkedList 的插入和删除操作时间复杂度为 O(1)，而 ArrayList 的时间复杂度为 O(n)。

ArrayList 和 Vector 实现了 List 接口，它们都是动态数组的实现，它们也拥有相同的方法，对元素进行添加、删除、查找等操作

1. 线程安全性：Vector 是线程安全的，而 ArrayList 不是。所以在多线程环境下，应该使用 Vector。

2. 性能：由于 Vector 是线程安全的，所以它的性能通常比 ArrayList 差。在单线程环境下，ArrayList 比 Vector 快。

3. 初始容量增长方式：当容量不足时，ArrayList 默认会增加 50% 的容量，而 Vector 会将容量翻倍。ArrayList 需要更频繁地进行扩容操作，而 Vector 则更适合于存储大量数据

普通类是可以直接实例化的类，而抽象类则不能直接实例化。抽象类通常用于定义一些基本的行为和属性，而具体的实现则由其子类来完成。

1. 实例化：普通类可以直接实例化，而抽象类不能直接实例化。

2. 方法：抽象类中既包含抽象方法又可以包含具体的方法，而普通类只能包含普通方法。

3. 实现：普通类实现接口需要重写接口中的方法，而抽象类可以实现接口方法也可以不实现。

1. 在 HashMap 中，key 和 value 值都可以为 null。
2. 在 ConcurrentHashMap 中，key 或者是 value 值都不能为 null。

ConcurrentHashMap 添加元素的第一行源码就可以看出，当 key 或 value 为 null 时，会直接抛出空指针异常

在 Java 中，ConcurrentHashMap 是用于并发环境中执行的线程安全的容器，而 HashMap 是用于单线程环境下执行的非线程安全的容器
而并发环境下的运行更复杂，如果我们允许 ConcurrentHashMap 的 key 或者是 value 为 null 的情况下，就会存在经典的“二义性问题”。

定义

1. 这个值本身设置的是 null，null 在这里表示的是一种具体的“null”值状态。
2. null 还表示“没有”的意思，因为没有设置，所以啥也没有。

可证伪的HashMap

不可证伪的ConcurrentHashMap

它们都不能直接实例化，并且它们都是用来定义一些基本的属性和方法的

1. 定义：定义的关键字不同，抽象类是 abstract，而接口是 interface。

2. 方法：抽象类可以包含抽象方法和具体方法，而接口只能包含方法声明（抽象方法）。

3. 方法访问控制符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public 控制符。

4. 实现：一个类只能继承一个抽象类，但可以实现多个接口。

5. 变量：抽象类可以包含实例变量和静态变量，而接口只能包含常量。

6. 构造函数：抽象类可以有构造函数，而接口不能有构造函数。

HashMap 和 Hashtable 都实现了 Map 接口，都是 Java 中用于存储键值对的数据结构，它们的底层数据结构都是数组加链表的形式（默认情况下）

1. 线程安全：Hashtable 是线程安全的，而 HashMap 是非线程安全的。

2. 性能：性能：因为 Hashtable 使用了 synchronized 给整个方法添加了锁，所以相比于 HashMap 来说，它的性能不如 HashMap。

3. 存储：HashMap 允许 key 和 value 为 null，而 Hashtable 不允许存储 null 键和 null 值。

因为 Hashtable 是给整个方法添加 synchronized 来实现线程安全的，所以它的性能很差。

HashMap 和 HashSet 都是 Java 中的集合类

1. HashSet 实现了 Set 接口，只存储对象；HashMap 实现了 Map 接口，用于存储键值对。
2. HashSet 底层是用 HashMap 存储的，HashSet 封装了一系列 HashMap 的方法，HashSet 将（自己的）值保存到 HashMap 的 Key 里面了。
3. HashSet 不允许集合中有重复的值（如果有重复的值，会插入失败），而 HashMap 键不能重复，值可以重复（如果键重复会覆盖原来的值）。

HashSet 适用于只存储对象的情况，而 HashMap 适用于需要存储键值对的情况，可以根据键快速查找值。
HashSet 底层是用 HashMap 存储的，用它可以存储不重复的值。

它是 HashMap 在进行扩容时的一个阈值，当 HashMap 中的元素个数超过了容量乘以负载因子时，就会进行扩容。

initialCapacity * loadFactor = HashMap 扩容。 其中，initialCapacity 是初始容量，默认值为 16（懒加载机制，只有当第一次 put 的时候才创建）

为了减少哈希冲突，提高 HashMap 性能的。

它提供了空间和时间复杂度之间的良好平衡。

通过数组 + 链表实现的

通过数组 + 链表或红黑树实现的。

链表升级为红黑树

红黑树退化为链表

1. HashMap 使用头插法进行数据插入（JDK 1.8 之前）；
2. 多线程同时添加；
3. 触发了 HashMap 扩容。

头插法是指新来的值会取代原有的值，插入到链表的头部

头插法会导致 HashMap 在进行扩容时，链表的顺序发生反转

因为在 HashMap 扩容时，会先从旧 HashMap 的头节点读取并插入到新 HashMap 节点中，
旧节点的读取顺序是 A -> B -> C，于是插入到新 HashMap 中的顺序就变成了 C -> B -> A，这样就破坏了链表的顺序，导致了链表反转。

1. 死循环是因为并发 HashMap 扩容导致的，并发扩容的第一步，线程 T1 和线程 T2 要对 HashMap 进行扩容操作，此时 T1 和 T2 指向的是链表的头结点元素 A，而 T1 和 T2 的下一个节点，也就是 T1.next 和 T2.next 指向的是 B 节点

2. 死循环的第二步操作是，线程 T2 时间片用完进入休眠状态，而线程 T1 开始执行扩容操作，一直到线程 T1 扩容完成后，线程 T2 才被唤醒

3. 当线程 T1 执行完，而线程 T2 恢复执行时，死循环就建立了，因为 T1 执行完扩容之后 B 节点的下一个节点是 A，而 T2 线程指向的首节点是 A，第二个节点是 B，这个顺序刚好和 T1 扩完容完之后的节点顺序是相反的。T1 执行完之后的顺序是 B 到 A，而 T2 的顺序是 A 到 B，这样 A 节点和 B 节点就形成死循环了

1. 升级到高版本 JDK（JDK 1.8 以上），高版本 JDK 使用的是尾插法插入新元素的，所以不会产生死循环的问题；
2. 使用线程安全容器 ConcurrentHashMap 替代（推荐使用此方案）；
3. 使用线程安全容器 Hashtable 替代（性能低，不建议使用）；
4. 使用 synchronized 或 Lock 加锁 HashMap 之后，再进行操作，相当于多线程排队执行（比较麻烦，也不建议使用）

哈希冲突是指在哈希表中，两个或多个元素被映射到了同一个位置的情况。

1. 链地址法：将哈希表中的每个桶都设置为一个链表，当发生哈希冲突时，将新的元素插入到链表的末尾。这种方法的优点是简单易懂，适用于元素数量较多的情况。缺点是当链表过长时，查询效率会降低。
2. 开放地址法：当发生哈希冲突时，通过一定的探测方法（如线性探测、二次探测、双重哈希等）在哈希表中寻找下一个可用的位置。这种方法的优点是不需要额外的存储空间，适用于元素数量较少的情况。缺点是容易产生聚集现象，即某些桶中的元素过多，而其他桶中的元素很少。
3. 再哈希法：当发生哈希冲突时，使用另一个哈希函数计算出一个新的哈希值，然后将元素插入到对应的桶中。这种方法的优点是简单易懂，适用于元素数量较少的情况。缺点是需要额外的哈希函数，且当哈希函数不够随机时，容易产生聚集现象。

1. 存储结构不同：链地址法规定了存储的结构为链表（每个桶为一个链表），每次将值存储到链表的末尾；
                            开放地址法未规定存储的结构，所以它可以是链表也可以是树结构等。
2. 查找方式不同：链地址法查找时，先通过哈希函数计算出哈希值，然后在哈希表中查找对应的链表，再遍历链表查找对应的值。
                            开放地址法查找时，先通过哈希函数计算出哈希值，然后在哈希表中查找对应的值，如果查找到的值不是要查找的值，就继续查找下一个值，直到查找
                            到为止。
3. 插入方法不同：链地址法插入时，先通过哈希函数计算出哈希值，然后在哈希表中查找对应的链表，再将值插入到链表的末尾。
                            开放地址法插入时，是通过一定的探测方法，如线性探测、二次探测、双重哈希等，在哈希表中寻找下一个可用的位置。所以链地址法插入方法实现非
                            常简单，而开放地址法插入方法实现相对复杂。 

线性探测

二次探测

在 Java 中，HashMap 使用的是链地址法解决哈希冲突的，对于存在冲突的 key，HashMap 会把这些 key 组成一个单向链表，之后使用尾插法把这个 key 保存到链表尾部。

在 Java 中，反射是指在运行时检查和操作类、接口、字段、方法等程序结构的能力。通过反射，可以在运行时获取类的信息，创建类的实例，调用类的方法，访问和修改类的字段等。

先定义一个需要被反射的类对象User

1. 编程开发工具的代码提示，如 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，这就是通过反射实现的。
2. 很多知名的框架如 Spring，为了让程序更简洁、更优雅，以及功能更丰富，也会使用到反射，比如 Spring 中的依赖注入就是通过反射实现的。
3. 数据库连接框架也会使用反射来实现调用不同类型的数据库（驱动）。

优点

缺点

反射在程序运行期间动态获取类和操纵类的一种技术。通过反射机制，可以在运行时动态地创建对象、调用方法、访问和修改属性，以及获取类的信息。

1. 动态代理：反射是动态代理的底层实现，即在运行时动态地创建代理对象，并拦截和增强方法调用。这常用于实现 AOP 功能，如日志记录、事务管理等。
2. Bean 创建：Spring/Spring Boot 项目中，在项目启动时，创建的 Bean 对象就是通过反射来实现的。
3. JDBC 连接：JDBC 中的 DriverManager 类通过反射加载并注册数据库驱动，这是 Java 数据库连接的标准做法。

1. 得到类：Class.forName("类名")
2. 得到所有字段：getDeclaredFields()
3. 得到所有方法：getDeclaredMethods()
4. 得到构造方法：getDeclaredConstructor()
5. 得到实例：newInstance()
6. 调用方法：invoke()

invoke方法执行流程

克隆是指创建一个与原始对象相同的新对象。这个新对象通常具有与原始对象相同的属性和方法，但是它们是两个不同的对象，它们在内存中的位置不同。

克隆出来的新对象与原始对象共享引用类型的属性。也就是说，新对象中的引用类型属性指向的是原始对象中相同的引用类型属性。如果修改了新对象中的引用类型属性，原始对象中的相应属性也会被修改。

定义

实现

从 Java 8 开始，便引入了一种称为“流式 API”的编程风格，它主要是通过设置方法的返回值，让返回值变为对象自身，从而实现连续的方法调用，这种风格就叫做“链式设置”或“链式调用”。

1. 简洁性：链式设置使得代码更加简洁和易读。通过连续的方法调用，可以在一行代码中完成多个操作，减少了代码的冗余和嵌套。
2. 可读性：链式设置可以提供更清晰、更自然的代码流。每个方法调用都可以形成一个语义上的整体，使得代码更易于理解。
3. 可组合性：链式设置可以方便地组合多个操作。每个方法返回的是对象自身或包含对象自身的容器，使得可以连续地进行多个操作，从而实现更复杂的功能。
4. 可扩展性：链式设置使得添加、修改或移除操作更加灵活。由于每个方法都是在对象自身上操作，并返回对象自身或包含对象自身的容器，可以轻松地添加新的操作或修改现有的操作。

Setter 原生方式
Lombok @Accessors 注解方式
Lombok @Builder 注解方式
Hutool GenericBuilder 方式

在于解决多线程环境下并发执行时的内存可见性和一致性问题。

在现代计算机系统中，尤其是多处理器架构下，每个处理器都有自己的高速缓存，而主内存（RAM）是所有处理器共享的数据存储区域。当多个线程同时访问和修改同一块共享数据时，如果没有适当的同步机制，就可能导致以下问题

1. 可见性：一个线程对共享变量所做的修改可能不会立即反映到另一个线程的视角中，因为这些修改可能只存在于本地缓存中，并未刷新回主内存。

2. 有序性：编译器和处理器为了优化性能，可能会对指令进行重排序，这可能导致程序在单线程环境中看似按照源代码顺序执行，但在多线程环境中的实际执行顺序却与预期不同。

3. 原子性：即使是最简单的读取或赋值操作，在硬件层面也不一定保证是原子性的，即在没有同步的情况下，多线程下可能看到操作只执行了一部分的结果。

如果没有 Java 内存模型就会出现以下两大问题：
1. CPU 和 内存一致性问题。
2. 指令重排序问题。

由于主内存与 CPU 处理器的运算能力之间有数量级的差距，所以在传统计算机内存架构中会引入高速缓存（L2）来作为主存和处理器之间的缓冲，CPU 将常用的数据放在高速缓存中，运算结束后 CPU 再讲运算结果同步到主内存中，这样就会导致多个线程在进行操作和同步时，导致 CPU 缓存和主内存数据不一致的问题。

由于有 JIT（Just In Time，即时编译）技术的存在，它可能会对代码进行优化，比如将原本执行顺序为 a -> b -> c 的流程，“优化”成 a -> c -> b 了，但这样优化之后，可能会导致我们的程序在某些场景执行出错，比如单例模式双重效验锁的场景，这就是典型的好心办坏事的事例。

规范了 Java 虚拟机与计算机内存之间是如何协同工作的。

1. 主内存（Main Memory）：所有线程共享的内存区域，包含了对象的字段、方法和运行时常量池等数据。
2. 工作内存（Working Memory）：每个线程拥有自己的工作内存，用于存储主内存中的数据的副本，线程只能直接操作工作内存中的数据。
3. 内存间交互操作：线程通过读取和写入操作与主内存进行交互。读操作将数据从主内存复制到工作内存，写操作将修改后的数据刷新到主内存。
4. 原子性（Atomicity）：JMM 保证基本数据类型（如 int、long）的读写操作具有原子性，即不会被其他线程干扰，保证操作的完整性。
5. 可见性（Visibility）：JMM 确保一个线程对共享变量的修改对其他线程可见。这意味着一个线程在工作内存中修改了数据后，必须将最新的数据刷新到主内存，以便其他线程可以读取到更新后的数据。
6. 有序性（Ordering）：JMM 保证程序的执行顺序按照一定的规则进行，不会出现随机的重排序现象。这包括了编译器重排序、处理器重排序和内存重排序等。

happens-before（先行发生）原则是 Java 内存模型中定义的用于保证多线程环境下操作执行顺序和可见性的一种重要手段。
举个例子来说，例如 A happens-before B，也就是 A 线程早于 B 线程执行，那么 A happens-before B 可以保障以下两项内容：
可见性：B 读取到 A 最新修改的值（通过内存屏障）。
顺序性：编译器优化、处理器重排序等因素不会影响先执行 A 再执行 B 的顺序。

是一种计算机操作系统中用于提高数据传输效率的优化策略。零拷贝技术通过直接共享数据的内存地址，避免了中间的拷贝过程，从而提高了数据传输的效率。

1. 用户态和内核态  
用户态（User Mode） 是指应用程序运行时的执行环境。在用户态下，应用程序只能访问受限资源，如应用程序自身的内存空间、CPU 寄存器等，并且不能直接访问操作系统的底层资源和硬件设备。
内核态（Kernel Mode） 是指操作系统内核运行时的执行环境。在内核态下，操作系统具有更高的权限，可以直接访问系统的硬件和底层资源，如 CPU、内存、设备驱动程序等。

2. DMA
DMA（Direct Memory Access，直接内存访问）技术，绕过 CPU，直接在内存和外设之间进行数据传输。这样可以减少 CPU 的参与，提高数据传输的效率。

零拷贝技术可以利用 Linux 下的 MMap、sendFile 等手段来实现，使得数据能够直接从磁盘映射到内核缓冲区，然后通过 DMA 传输到网卡缓存，整个过程中 CPU 只负责管理和调度，而无需执行实际的数据复制指令。

1. MMap：MMap（Memory Map）是 Linux 操作系统中提供的一种将文件映射到进程地址空间的一种机制，通过 MMap 进程可以像访问内存一样访问文件，而无需显式的复制操作。

2. 在 Linux 操作系统中 sendFile() 是一个系统调用函数，用于高效地将文件数据从内核空间直接传输到网络套接字（Socket）上，从而实现零拷贝技术。这个函数的主要目的是减少 CPU 上下文切换以及内存复制操作，提高文件传输性能。

NIO（New I/O）通道：java.nio.channels.FileChannel 提供了 transferTo() 和 transferFrom() 方法，可以直接将数据从一个通道传输到另一个通道，例如从文件通道直接传输到 Socket 通道，整个过程无需将数据复制到用户空间缓冲区，从而实现了零拷贝。
Socket Direct Buffer：在 JDK 1.4 及更高版本中，Java NIO 支持使用直接缓冲区（DirectBuffer），这类缓冲区是在系统堆外分配的，可以直接由网卡硬件进行 DMA 操作，减少数据在用户态与内核态之间复制次数 ，提高网络数据发送效率。
Apache Kafka 或者 Netty 等高性能框架：这些框架在底层实现上通常会利用 Java NIO 的上述特性来优化数据传输，如 Kafka 生产者和消费者在传输消息时会用到零拷贝技术以提升性能。

ThreadLocal 线程本地变量，每个线程都拥有一份该变量的独立副本，即使是在多线程环境下，每个线程也只能修改和访问自己的那份副本，从而避免了线程安全问题，实现了线程间的隔离。

存在的问题