Java基础

重载和重写的区别是什么?

重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般。

1.定义不同---重载是定义相同的方法名，参数不同；重写是子类重写父类的方法。

2.范围不同---重载是在一个类中，重写是子类与父类之间的。

3.多态不同---重载是编译时的多态性，重写是运行时的多态性。

4.返回不同---重载对返回类型没有要求，而重写要求返回类型，有兼容的返回类型。

5.参数不同---重载的参数个数、参数类型、参数顺序可以不同，而重写父子方法参数必须相同。

6.修饰不同---重载对访问修饰没有特殊要求，重写访问修饰符的限制一定要大于被重写方法的访问修饰符。

什么是方法重载?返回值算重载吗?

在 Java 中，方法重载是指在同一个类中定义多个方法，它们具有相同的名称但参数列表不同。方法重载的定义如下：

java

public void myMethod(int arg1) {
    // 方法体
}

public void myMethod(int arg1, int arg2) {
    // 方法体
}

public void myMethod(String arg1) {
    // 方法体
}

返回值不同不算方法重载

java

public String myMethod(int arg1) {
    // 方法体
}

public int myMethod(int arg1) {
    // 方法体
}

因为不同的返回值类型，JVM 没办法分辨到底要调用哪个方法，比如以下代码：

java

// 方法调用
myMethod(1);

更深层次的原因：JVM 调用方法是通过方法签名来判断到底要调用哪个方法的，而方法签名 = 方法名称 + 参数类型 + 参数个数，组成的一个唯一值，这个唯一值就是方法签名。从方法签名的组成可以看出，返回类型不是方法签名的组成部分，所以不同的返回类型也就不算方法重载了，因为它不能让 JVM 确定要调用的具体方法。

多态的实现原理

多态是面向对象编程中的一个重要特性，它主要是通过方法重写和方法重载来实现的。
但如果你面试的时候，给面试官说多态的实现原理是“方法重写和重载”，那你多半就凉凉了。因为“方法重写和方法重载”是多态的实现方式，但并不是它的实现原理。

什么是多态?

多态是面向对象编程中的一个重要概念，它允许通过父类类型的引用变量来引用子类对象，并在运行时根据实际对象的类型来确定调用哪个方法。换句话说，一个对象可以根据不同的情况表现出多种形态。

通过多态，我们可以利用父类类型的引用变量来指向子类对象，并根据实际对象的类型调用对应的方法。这样可以在不修改现有代码的情况下，动态地切换和扩展对象的行为。

多态有以下几个特点和优势：

可替换性：子类对象可以随时替代父类对象，向上转型。
可扩展性：通过添加新的子类，可以扩展系统的功能。
接口统一性：可以通过父类类型的引用访问子类对象的方法，统一对象的接口。
代码的灵活性和可维护性：通过多态，可以将代码编写成通用的、松耦合的形式，提高代码的可维护性。

实现原理

要了解多态的实现原理，需要先了解两个概念：动态绑定和虚拟方法调用。

动态绑定

动态绑定（Dynamic Binding）：指的是在编译时，Java 编译器只能知道变量的声明类型，而无法确定其实际的对象类型。而在运行时，Java 虚拟机（JVM）会通过动态绑定来解析实际对象的类型。这意味着，编译器会推迟方法的绑定（即方法的具体调用）到运行时。正是这种动态绑定机制，使得多态成为可能。

虚拟方法调用

虚拟方法调用（Virtual Method Invocation）：在 Java 中，所有的非私有、非静态和非 final 方法都是被隐式地指定为虚拟方法。虚拟方法调用是在运行时根据实际对象的类型来确定要调用的方法的机制。当通过父类类型的引用变量调用被子类重写的方法时，虚拟机会根据实际对象的类型来确定要调用的方法版本，而不是根据引用变量的声明类型。

实现原理综述

所以，多态的实现原理主要是依靠“动态绑定”和“虚拟方法调用”，它的实现流程如下：

创建父类类型的引用变量，并将其赋值为子类对象。
在运行时，通过动态绑定确定引用变量所指向的实际对象的类型。
根据实际对象的类型，调用相应的方法版本。

以上就是多态的实现原理

ArrayList和LinkedList有什么区别?

ArrayList 和 LinkedList 都是 Java 中的 List 接口的实现类。

但它们有以下不同：

它们的底层实现不同：ArrayList 是基于动态数组的数据结构，而 LinkedList 是基于链表的数据结构。
随机访问性能不同：ArrayList 优于 LinkedList，因为 ArrayList 可以根据下标以 O(1) 时间复杂度对元素进行随机访问。而 LinkedList 的访问时间复杂度为 O(n)，因为它需要遍历整个链表才能找到指定的元素。
插入和删除性能不同：LinkedList 优于 ArrayList，因为 LinkedList 的插入和删除操作时间复杂度为 O(1)，而 ArrayList 的时间复杂度为 O(n)。

ArrayList 和 LinkedList 都是 List 接口的实现类，但它们的底层实现（结构）不同、随机访问的性能和添加/删除的效率不同。如果是随机访问比较多的业务场景可以选择使用 ArrayList，如果添加和删除比较多的业务场景可以选择使用 LinkedList。

ArrayList和Vector有什么区别?

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

java

import java.util.ArrayList;
import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        Vector<String> vector = new Vector<>();

        // 添加元素
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("C++");

        vector.add("Java");
        vector.add("Python");
        vector.add("C++");

        // 获取元素
        System.out.println(arrayList.get(0));
        System.out.println(vector.get(0));

        // 删除元素
        arrayList.remove(0);
        vector.remove(0);

        // 获取元素个数
        System.out.println(arrayList.size());
        System.out.println(vector.size());
    }
}

但它们有以下区别：

线程安全性：Vector 是线程安全的，而 ArrayList 不是。所以在多线程环境下，应该使用 Vector。
性能：由于 Vector 是线程安全的，所以它的性能通常比 ArrayList 差。在单线程环境下，ArrayList 比 Vector 快。
初始容量增长方式：当容量不足时，ArrayList 默认会增加 50% 的容量，而 Vector 会将容量翻倍。这意味着在添加元素时，ArrayList 需要更频繁地进行扩容操作，而 Vector 则更适合于存储大量数据。

综上所述，如果不需要考虑线程安全问题，并且需要高效的存取操作，则 ArrayList 是更好的选择；如果需要考虑线程安全以及更好的数据存储能力，则应该选择 Vector。

抽象类和普通类的区别?

在 Java 中，普通类和抽象类是两种不同的类类型。普通类是可以直接实例化的类，而抽象类则不能直接实例化。抽象类通常用于定义一些基本的行为和属性，而具体的实现则由其子类来完成。以下是普通类和抽象类的一些区别：

实例化：普通类可以直接实例化，而抽象类不能直接实例化。
方法：抽象类中既包含抽象方法又可以包含具体的方法，而普通类只能包含普通方法。
实现：普通类实现接口需要重写接口中的方法，而抽象类可以实现接口方法也可以不实现。

以下是一个普通类和一个抽象类的示例代码：

java

// 普通类
public class MyClass {
    public void myMethod() {
        System.out.println("我是普通类");
    }
}

// 抽象类
public abstract class MyAbstractClass {
    public abstract void myAbstractMethod();
    public void myMethod() {
        System.out.println("我是抽象类");
    }
}

抽象类和接口有什么区别?

在 Java 中，抽象类和接口是两种不同的类类型。它们都不能直接实例化，并且它们都是用来定义一些基本的属性和方法的，但它们有以下几点不同：

定义：定义的关键字不同，抽象类是 abstract，而接口是 interface。
方法：抽象类可以包含抽象方法和具体方法，而接口只能包含方法声明（抽象方法）。
方法访问控制符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public 控制符。
实现：一个类只能继承一个抽象类，但可以实现多个接口。
变量：抽象类可以包含实例变量和静态变量，而接口只能包含常量。
构造函数：抽象类可以有构造函数，而接口不能有构造函数。

以下是一个抽象类和一个接口的示例代码：

java

// 抽象类
public abstract class MyAbstractClass {
    public abstract void myAbstractMethod();
    private void myMethod() {
        System.out.println("This is a method in an abstract class.");
    }
    public int myVariable = 0;
    public static int myStaticVariable = 0;
    public MyAbstractClass() {
        System.out.println("This is a constructor in an abstract class.");
    }
}

// 接口
public interface MyInterface {
    void myAbstractMethod();
    int MY_CONSTANT = 0;
}

HashMap和Hashtable有什么区别?

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

线程安全：Hashtable 是线程安全的，而 HashMap 是非线程安全的。
性能：因为 Hashtable 使用了 synchronized 给整个方法添加了锁，所以相比于 HashMap 来说，它的性能不如 HashMap。
存储：HashMap 允许 key 和 value 为 null，而 Hashtable 不允许存储 null 键和 null 值。

Hashtable 不能存储 null 键和 null 值是因为，它的 key 值要进行哈希计算，如果为 null 的话，无法调用该方法，还是会抛出空指针异常。而 value 值为 null 的话，Hashtable 源码中会主动抛出空指针异常。

HashMap 允许 key 和 value 为 null 的原因是因为在 HashMap 中对 null 值进行了特殊处理，如果为 null 时会把它赋值为 0，如下源码所示：

HashMap和Hashtable基本使用

java

import java.util.HashMap;
import java.util.Hashtable;

public class HashtableDemo {
    public static void main(String[] args) {
        Hashtable<String, String> table = new Hashtable<>();
        table.put("A", "Apple");
        table.put("B", "Ball");
        table.forEach((k, v) -> System.out.println(k + " " + v));

        HashMap<String, String> map = new HashMap<>();
        map.put("A", "Apple");
        map.put("B", "Ball");
        map.forEach((k, v) -> System.out.println(k + " " + v));
    }
}

Hashtable不推荐使用

虽然 Hashtable 是线程安全的，但在多线程环境下官方也不推荐使用 Hashtable，因为 Hashtable 是给整个方法添加 synchronized 来实现线程安全的，所以它的性能很差。官方推荐在多线程环境下，使用线程安全的 ConcurrentHashMap 来完成数据存储。

ConcurrentHashMap 锁粒度更细，在多线程环境下的性能表现更好。

HashMap和HashSet有什么区别?

HashMap 和 HashSet 都是 Java 中的集合类，但它们有以下几点区别：

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

HashMap基础使用

java

Map<String, String> map = new HashMap<>();
map.put("A", "Apple");
map.put("B", "Ball");
map.put("C", "Cat");
map.forEach((k, v) -> System.out.println(k + " " + v));

HashSet基础使用

java

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
set.forEach(System.out::println);

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

HashMap底层是如何实现的?

HashMap 在不同的 JDK 版本下的实现是不同的，在 JDK 1.7 时，HashMap 底层是通过数组 + 链表实现的；而在 JDK 1.8 时，HashMap 底层是通过数组 + 链表或红黑树实现的。

具体来说，HashMap 内部维护了一个数组，每个数组元素又是一个链表或者红黑树，每个链表或者红黑树节点存储了一个键值对。当需要存储新的键值对时，HashMap 会根据键的哈希值确定其在数组中的位置，如果该位置已经有了其他键值对，则通过链表或红黑树解决冲突，将新的键值对添加到链表或红黑树的末尾。当链表或红黑树长度达到一定程度后，HashMap 会自动将链表转换为红黑树，以提高查找效率。

如下图所示，HashMap 在 JDK 1.7 中的实现如下图所示：

在 JDK 1.8 时，HashMap 如下图所示：

链表和红黑树互转流程

链表升级成红黑树

在 JDK 1.8 之后，HashMap 默认是先使用数组 + 链表存储数据，但当满足以下两个条件时：

链表的数量大于阈值（默认是 8）
并且数组长度大于 64 时

为了（查询）的性能考虑会将链表升级为红黑树进行存储，具体执行流程如下：

创建新的红黑树对象，并将链表内所有的键值对全部添加到红黑树中。
将原来的链表引用指向新创建的红黑树。

红黑树退化为链表

当进行了删除操作，导致红黑树的节点小于等于 6 时，会发生退化，将红黑树转换为链表。这是因为当节点数量较少时，红黑树对性能的提升并不明显，反而占用了更多的内存空间。具体执行流程如下：

从红黑树的根节点开始，按照中序遍历的顺序将所有节点加入到一个新的链表中。
将原来的红黑树引用指向新创建的链表。

HashMap 在 JDK 1.7 时，是通过数组 + 链表实现的，而在 JDK 1.8 时，HashMap 是通过数组 + 链表或红黑树实现的。在 JDK 1.8 之后，如果链表的数量大于阈值（默认为 8），并且数组长度大于 64 时，为了查询效率会将链表升级为红黑树，但当红黑树的节点小于等于 6 时，为了节省内存空间会将红黑树退化为链表。

为什么HashMap会死循环?

HashMap 死循环发生在 JDK 1.8 之前的版本中，它是指在并发环境下，因为多个线程同时进行 put 操作，导致链表形成环形数据结构，一旦形成环形数据结构，在 get(key) 的时候就会产生死循环。如下图所示：

死循环原因

HashMap 导致死循环的原因是由以下条件共同导致的：

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

什么是头插法?

头插法是指新来的值会取代原有的值，插入到链表的头部，如下图所示。原链表如下图所示：

此时使用头插入插入一个元素 Z，如下图所示：

头插法会导致 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 才被唤醒，扩容之后的场景如下图所示：

从上图可知线程 T1 执行之后，因为是头插法，所以 HashMap 的顺序已经发生了改变，但线程 T2 对于发生的一切是不可知的，所以它的指向元素依然没变，如上图展示的那样，T2 指向的是 A 元素，T2.next 指向的节点是 B 元素。

死循环执行步骤3

当线程 T1 执行完，而线程 T2 恢复执行时，死循环就建立了，如下图所示：

因为 T1 执行完扩容之后 B 节点的下一个节点是 A，而 T2 线程指向的首节点是 A，第二个节点是 B，这个顺序刚好和 T1 扩完容完之后的节点顺序是相反的。T1 执行完之后的顺序是 B 到 A，而 T2 的顺序是 A 到 B，这样 A 节点和 B 节点就形成死循环了，这就是 HashMap 死循环导致的原因。

解决方案

HashMap 死循环的常用解决方案有以下几个：

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

哈希冲突的解决方案有哪些?

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

java

String str1 = "3C";
String str2 = "2b";
int hashCode1 = str1.hashCode();
int hashCode2 = str2.hashCode();
System.out.println("字符串: " + str1 + ", hashCode: " + hashCode1);
System.out.println("字符串: " + str2 + ", hashCode: " + hashCode2);

程序的运行结果如下：

不同的字符串，却拥有了相同的 hashCode 这就是哈希冲突。因为元素的位置是根据 hashCode 的值进行定位的，此时它们的 hashCode 相同，但一个位置只能存储一个值，这就是哈希冲突。

解决哈希冲突

在 Java 中，解决哈希冲突的常用方法有以下三种：链地址法、开放地址法和再哈希法。

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

链地址法与开放地址法

链地址法和开放地址法个人觉得以下几点不同：

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

线性探测与二次探测

线性探测是发生哈希冲突时，线性探测会在哈希表中寻找下一个可用的位置，具体来说，它会检查哈希表中下一个位置是否为空，如果为空，则将元素插入该位置；如果不为空，则继续检查下一个位置，直到找到一个空闲的位置为止。

二次探测是发生哈希冲突时，二次探测会使用一个二次探测序列来寻找下一个可用的位置，具体来说，它会计算出一个二次探测序列，然后依次检查哈希表中的每个位置，直到找到一个空闲的位置为止。二次探测的优点是相对于线性探测来说，它更加均匀地分布元素，缺点是当哈希表的大小改变时，需要重新计算二次探测序列。

具体来说，二次探测序列是一个二次函数，它的形式如下：

f(i) = i^2

其中，i 表示探测的步数，f(i) 表示探测的位置。

例如，当发生哈希冲突时，如果哈希表中的第 k 个位置已经被占用，那么二次探测会依次检查第 k+1^2、第 k-1^2、第 k+2^2、第 k-2^2、第 k+3^2、第 k-3^2……等位置，直到找到一个空闲的位置为止。

二次探测的优点是相对于线性探测来说，它更加均匀地分布元素，但缺点是容易产生二次探测聚集现象，即某些桶中的元素过多，而其他桶中的元素很少。

HashMap如何解决哈希冲突

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

浅克隆和深克隆有什么区别?

什么是克隆?

在编程中，克隆是指创建一个与原始对象相同的新对象。这个新对象通常具有与原始对象相同的属性和方法，但是它们是两个不同的对象，它们在内存中的位置不同。在 Java 中，可以通过实现 Cloneable 接口和重写 clone() 方法来实现对象的克隆。

什么是浅克隆和深克隆?

在 Java 中，克隆可以分为深克隆和浅克隆两种。它们的区别在于克隆出来的新对象是否与原始对象共享引用类型的属性。具体来说：

浅克隆：克隆出来的新对象与原始对象共享引用类型的属性。也就是说，新对象中的引用类型属性指向的是原始对象中相同的引用类型属性。如果修改了新对象中的引用类型属性，原始对象中的相应属性也会被修改。在 Java 中，可以通过实现 Cloneable 接口和重写 clone() 方法来实现浅克隆。
深克隆：克隆出来的新对象与原始对象不共享引用类型的属性。也就是说，新对象中的引用类型属性指向的是新的对象，而不是原始对象中相同的引用类型属性。如果修改了新对象中的引用类型属性，原始对象中的相应属性不会被修改。

浅克隆实现

java

public class CloneDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("张三");
        p1.setAge(18);
        Address address = new Address();
        address.setCity("北京");
        p1.setAddress(address);
        // 克隆 p1 对象
        Person p2 = p1.clone();
        System.out.println(p1 == p2); // false
        System.out.println(p1.getAddress() == p2.getAddress()); // true
    }
}
class Person implements Cloneable {
    private String name;
    private int age;
    private Address address; // 引用类型
    @Override
    public Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
    // 忽略 getter 和 setter 方法
}

class Address {
    private String city;

    // 忽略 getter 和 setter 方法
}

深克隆实现

深克隆的实现方法有很多，比如以下几个：

所有引用属性都实现克隆，整个对象就变成了深克隆。
使用 JDK 自带的字节流序列化和反序列化对象实现深克隆。
使用第三方工具实现深克隆，比如 Apache Commons Lang。
使用 JSON 工具，如 GSON、FastJSON、Jackson 序列化和反序列化对象实现深克隆。

比较常用的深克隆实现是，第一种让所有引用类型的属性实现克隆，和第四种使用 JSON 工具实现深克隆。

在 Java 中，序列化是指将对象转换为字节流的过程，以便可以将其存储在文件中、通过网络发送或在进程之间传递。反序列化是指将字节流转换回对象的过程。

深克隆实现一: 引用属性实现克隆

java

import lombok.Getter;
import lombok.Setter;

public class CloneDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("张三");
        p1.setAge(18);
        // 引用类型
        Address address = new Address();
        address.setCity("北京");
        p1.setAddress(address);
        // 克隆 p1 对象
        Person p2 = p1.clone();
        // 对比引用类型的地址值是否相同
        System.out.println(p1.getAddress() == p2.getAddress()); // false
    }
}

@Getter
@Setter
class Person implements Cloneable {
    private String name;
    private int age;
    private Address address; // 引用类型

    @Override
    public Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
            // 克隆引用类型
            person.setAddress(person.getAddress().clone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
}

@Getter
@Setter
class Address implements Cloneable {
    private String city;

    @Override
    public Address clone() {
        Address address = null;
        try {
            address = (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return address;
    }
}

深克隆实现二: 使用JSON工具

使用 Google 的 GSON（JSON）工具类来实现：

java

import com.google.gson.Gson;
import lombok.Getter;
import lombok.Setter;

public class CloneDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("张三");
        p1.setAge(18);
        // 引用类型
        Address address = new Address();
        address.setCity("北京");
        p1.setAddress(address);
        // JSON 工具类
        Gson gson = new Gson();
        // 序列化
        String json = gson.toJson(p1);
        // 克隆 p1 对象 | 反序列化
        Person p2 = gson.fromJson(json, Person.class);
        // 对比引用类型的地址值是否相同
        System.out.println(p1.getAddress() == p2.getAddress()); //false
    }
}

@Getter
@Setter
class Person implements Cloneable {
    private String name;
    private int age;
    private Address address; // 引用类型

    @Override
    public Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
}

@Getter
@Setter
class Address {
    private String city;
}

==克隆是指创建一个与原始对象相同的新对象。克隆可以分为深克隆和浅克隆两种。它们的区别在于克隆出来的新对象是否与原始对象共享引用类型的属性。==

如何实现链式调用?

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

例如，以下代码：

java

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
    .setPort(3306)
    .setHost("127.0.0.1")
    .setDatabase("mydb")
    .setUser("root")
    .setPassword("root");

其属性的设置就称为链式调用或链式设置。

链式调用优点

使用链式调用主要有以下几个优点：

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

总的来说，链式设置提高了代码的可读性和可组合性，使得代码更加简洁、灵活和易于维护。

链式调用实现

链式调用的主要实现方式，总共有以下 4 种：

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

具体实现如下:

Setter原生方式

Setter 原生方式的实现比较简单，只需要设置 Setter 方法，并且每个 Setter 方法都返回自身对象即可，如下代码所示：

java

public class Student {
    private String name;
    private int age;

    public Student name(String name) {
        this.name = name;
        return this;
    }

    public Student age(int age) {
        this.age = age;
        return this;
    }
}

链式调用代码如下：

java

Student stu = new Student()
        .name("磊哥")
        .age(18);

Lombok @Accessors 注解方式

Lombok 是一个 Java 库，它通过注解来简化 Java 代码的编写。其中，@Accessors 注解可以开启链式调用风格。

具体实现代码如下：

java

@Getter
@Setter
@Accessors(chain = true)
public class Student {
    private String name;
    private int age;
}

在上面的示例中，使用了 @Accessors(chain = true) 注解来开启链式调用风格。这样就可以通过以下方式进行链式设置：

java

Student stu = new Student()
	.setName("John")
	.setAge(30);

Lombok @Builder注解方式

使用 @Builder 注解，会自动生成一个 Builder 类，通过该 Builder 类可以链式地设置类的属性并创建对象。这种方式在构建复杂对象时非常方便。

具体实现代码如下：

java

import lombok.Builder;

@Builder
public class Student {
    private String name;
    private int age;
}

链式调用代码如下:

Student stu = Student.builder()
    .name("磊哥")
    .age(18)
    .build();

Hutool GenericBuilder 方式

Hutool 是一个小而全的 Java 工具类库，通过静态方法封装，降低相关 API 的学习成本，提高工作效率，使 Java 拥有函数式语言般的优雅，让 Java 语言也可以“甜甜的”。其中，Hutool 提供了 GenericBuilder 类，可以实现链式调用，具体实现代码如下：

java

Student stu = GenericBuilder.of(Student::new)
                .with(Student::setName, "磊哥")
                .with(Student::setAge, 18)
                .build();

说一下零拷贝的实现原理?

零拷贝（Zero-copy）技术是一种计算机操作系统中用于提高数据传输效率的优化策略。在传统的数据传输过程中，需要将数据从一个缓冲区拷贝到另一个缓冲区，然后再传输给目标。这涉及到多次的 CPU 和内存之间的数据拷贝操作，会消耗 CPU 的时间和内存带宽。而零拷贝技术通过直接共享数据的内存地址，避免了中间的拷贝过程，从而提高了数据传输的效率。

传统IO执行流程

用户态和内核态

操作系统有用户态和内核态之分，这是因为计算机体系结构中的操作系统设计了两个不同的执行环境，以提供不同的功能和特权级别。

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

DMA

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

零拷贝技术实现

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

MMap

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

使用 MMap 可以把 IO 执行流程优化成以下执行步骤：

传统的 IO 需要四次拷贝和四次上下文（用户态和内核态）切换，而 MMap 只需要三次拷贝和四次上下文切换，从而能够提升程序整体的执行效率，并且节省了程序的内存空间。

sendFile方法

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

使用 sendFile() 可以把 IO 执行流程优化成以下执行步骤：

哪些地方用到了零拷贝

在 Java 中，以下几个地方使用了零拷贝技术：

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 生产者和消费者在传输消息时会用到零拷贝技术以提升性能。

使用零拷贝技术可以减少 CPU 拷贝，及减少了上下文的切换带来的性能开销，提高了程序的整体执行效率，它们的区别对比如下表格所示：

	CPU 拷贝（次数）	DMA 拷贝（次数）	上下文切换（次数）
传统 IO	2	2	4
MMap	1	2	4
sendFile()	1	2	2

Java高级

当数据表中数据量过大时，应该如何优化查询速度?

所谓的“大表”指的是一张表中有大量的数据，而通常情况下数据量越多，那么也就意味着查询速度越慢。这是因为当数据量增多时，那么查询一个数据需要匹配和检索的内容也就越多，而检索的项目越多，那么查询速度也就越慢。

创建适当的索引

通过创建适当的索引，可以加速查询操作。索引可以提高查询语句的执行效率，尤其是对于常用的查询条件和排序字段进行索引，可以显著减少查询的扫描范围和 IO 开销。

优化查询语句

优化查询语句本身，避免全表扫描和大数据量的关联查询。可以优化查询条件，使用合适的索引、合理的查询策略，减少不必要的字段和数据返回。

缓存查询结果

对于一些相对稳定的查询结果，可以将其缓存在内存中，避免重复查询数据库，提高查询速度。

缓存的查询速度一定比直接查询数据库的效率高，这是因为缓存具备以下特征：

内存访问速度快：缓存通常将数据存储在内存中，而数据库将数据存储在磁盘上。相比于磁盘访问，内存访问速度更快，可以达到纳秒级别的读取速度，远远快于数据库的毫秒级别的读取速度。

IO 操作次数少：数据库通常需要进行磁盘 IO 操作，包括读取和写入磁盘数据。而缓存将数据存储在内存中，避免了磁盘 IO 的开销。内存访问不需要进行磁盘寻址和机械运动，相对来说速度更快。

特殊的数据结构：缓存的数据结构通常为 key-value 形式的，也就是说缓存可以做到任何数据量级下的查询数据复杂度为 O(1)，所以它的查询效率是非常高的；而数据库采用的是传统数据结构设计，可能需要查询二叉树、或全文搜索、或回表查询等操作，所以其查询性能是远低于缓存系统的。

提升硬件配置

对于大数据量的表，可以考虑采用更高性能的硬件设备，如更快的存储介质（如固态硬盘），更大的内存容量等，以提升查询的 IO 性能。

数据归档和分离

对于历史数据或不经常访问的数据，可以进行归档和分离，将这些数据从主表中独立出来，减少主表的数据量，提高查询速度。

数据库分片

当单个数据库无法满足查询性能需求时，可以考虑使用数据库分片技术，将数据分散到多个数据库中，每个数据库只处理部分数据，从而提高查询的并发度和整体性能。

数据库分片技术的具体实现是分库分表。

分库分表

首先来说，分库分表是一组技术，而不是一个单一的技术，分库分表可以分为以下几种情况：

只分库：将一个大数据库分为 N 个小数据库。例如将一个电商数据库，分为多个数据库，如：用户数据库、仓库数据库、订单数据库、商品数据库等。
只分表
：在一个数据库中，将一张表拆分成多张表，而分表又有以下两种实现：
1. 横向拆分：不修改原有的表结构，将原本一张表中的数据，分成 N 个表来存储数据。
2. 纵向拆分：修改原有的表结构，将常用的字段放到主表中，将不常用的和查询效率低的字段放到扩展表中。
既分库又分表：它的实现最复杂，顾名思义，它是将一个数据库拆分成多个数据库，并将一个数据库的一张表，同时有拆分为多张表。

分库分表实现

目前市面上分库分表的主要实现技术有以下几个：

ShardingSphere：ShardingSphere 是一个功能丰富的开源分布式数据库中间件，提供了完整的分库分表解决方案。它支持主流关系型数据库（如 MySQL、Oracle、SQL Server 等），提供了分片、分布式事务、读写分离、数据治理等功能。ShardingSphere 具有灵活的配置和扩展性，支持多种分片策略，使用简单方便，项目地址：shardingsphere.apache.org
MyCAT：MyCAT（MySQL Clustering and Advancement Toolkit）是一个开源的分布式数据库中间件，特别适合于大规模的分库分表应用。它支持 MySQ L和 MycatSQL，提供了分片、读写分离、分布式事务等功能。MyCAT 具有高性能、高可用性、可扩展性和易用性的特点，广泛应用于各种大型互联网和电商平台，项目地址：github.com/MyCATApache…
TDDL：TDDL（Taobao Distributed Data Layer）是阿里巴巴开源的分库分表中间件。它为开发者提供了透明的分库分表解决方案，可以将数据按照指定的规则分布到不同的数据库和表中。TDDL 支持 MyISAM 和 InnoDB 引擎，提供了读写分离、动态扩容、数据迁移等功能，项目地址：github.com/alibaba/tb_…
Vitess：Vitess 是一个由 YouTube 开发和维护的分布式数据库集群中间件，支持 MySQL 作为后端存储系统。Vitess 提供了水平拆分、弹性缩放、负载均衡、故障恢复等功能，可以在大规模的数据集和高并发访问场景下提供高性能和可扩展性

Java基础 ​

重载和重写的区别是什么? ​

什么是方法 重载?返回值算重载吗? ​

多态的实现原理 ​

ArrayList和LinkedList有什么区别? ​

ArrayList和Vector有什么区别? ​

抽象类和普通类的区别? ​

抽象类和接口有什么区别? ​

HashMap和Hashtable有什么区别? ​

HashMap和HashSet有什么区别? ​

HashMap底层是如何实现的? ​

为什么HashMap会死循环? ​

哈希冲突的解决方案有哪些? ​

浅克隆和深克隆有什么区别? ​

如何实现链式调用? ​

说一下零拷贝的实现原理? ​

Java高级 ​

当数据表中数据量过大时，应该如何优化查询速度? ​

Java基础

重载和重写的区别是什么?

什么是方法重载?返回值算重载吗?

多态的实现原理

ArrayList和LinkedList有什么区别?

ArrayList和Vector有什么区别?

抽象类和普通类的区别?

抽象类和接口有什么区别?

HashMap和Hashtable有什么区别?

HashMap和HashSet有什么区别?

HashMap底层是如何实现的?

为什么HashMap会死循环?

哈希冲突的解决方案有哪些?

浅克隆和深克隆有什么区别?

如何实现链式调用?

说一下零拷贝的实现原理?

Java高级

当数据表中数据量过大时，应该如何优化查询速度?