Java基础与面试-每日必看（5）-优快云博客

本文链接：https://blog.youkuaiyun.com/LB22csdn/article/details/145528201

前言

Java不秃，面试不慌！
欢迎来到这片 Java修炼场！这里没有枯燥的教科书，只有每日一更的硬核知识+幽默吐槽，让你在欢笑中掌握 Java基础、算法、面试套路，摆脱“写代码如写诗、看代码如看天书”的困境。
记住：代码会背叛你，但知识不会！坚持积累，总有一天，HR会为你的八股文落泪，面试官会因你的算法沉默。
让我们一起卷出天际，优雅不秃！ 🚀

浅拷贝与深拷贝

假设你有一个对象，里面有两种内容：一部分是基本类型数据（比如 int、boolean），另一部分是引用类型（比如 Person 这个类的实例）。当你想复制这个对象时，Java 提供了两种方式：浅拷贝和深拷贝。

浅拷贝：只“搬运”地址，不深究细节

浅拷贝是懒得深究的“复制达人”。它只会复制你对象中的基本数据类型（像 int、char 等），而对于引用类型（即对象实例），它只会复制对象的“地址”，而不是复制对象本身。也就是说，原始对象和浅拷贝出来的对象，它们共享同一块“外部资料”——同一个引用对象。

class Person {
    String name;
    
    public Person(String name) {
        this.name = name;
    }
}

class Team {
    String teamName;
    Person member;

    public Team(String teamName, Person member) {
        this.teamName = teamName;
        this.member = member;
    }

    // 浅拷贝方法
    public Team shallowCopy() {
        return new Team(this.teamName, this.member); // 只拷贝地址
    }
}

public class ShallowCopyExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice");
        Team team1 = new Team("Dev Team", person1);
        
        // 浅拷贝
        Team team2 = team1.shallowCopy();
        
        // 修改原始成员的名字
        person1.name = "Bob";
        
        System.out.println(team1.member.name); // 输出 Bob
        System.out.println(team2.member.name); // 输出 Bob
    }
}

解释：
这里 team1 和 team2 的 member 都指向同一个 Person 对象。也就是说，修改 person1 的名字，会影响到 team2 中的 member，因为它们共享同一个对象地址。

深拷贝：不光拷贝地址，还搬走整个对象

深拷贝是一个认真负责的“复制专家”。它不仅会拷贝基本数据类型，还会对引用类型的对象进行递归拷贝，确保每个对象都是独立的。所以，修改深拷贝出来的对象，不会影响原始对象。

class Person {
    String name;
    
    public Person(String name) {
        this.name = name;
    }

    // 深拷贝方法
    public Person deepCopy() {
        return new Person(this.name); // 创建一个新的 Person 对象
    }
}

class Team {
    String teamName;
    Person member;

    public Team(String teamName, Person member) {
        this.teamName = teamName;
        this.member = member;
    }

    // 深拷贝方法
    public Team deepCopy() {
        return new Team(this.teamName, this.member.deepCopy()); // 递归拷贝 Person 对象
    }
}

public class DeepCopyExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice");
        Team team1 = new Team("Dev Team", person1);
        
        // 深拷贝
        Team team2 = team1.deepCopy();
        
        // 修改原始成员的名字
        person1.name = "Charlie";
        
        System.out.println(team1.member.name); // 输出 Charlie
        System.out.println(team2.member.name); // 输出 Alice
    }
}

解释：
在这个例子中，team1 和 team2 拥有独立的 Person 对象。因为我们在 Team 的 deepCopy() 方法里，对 Person 对象也进行了深拷贝，所以即使修改了 team1 中 Person 的名字，team2 中的 Person 也不受影响，它们是两个完全独立的对象。

总结：浅拷贝 vs 深拷贝

浅拷贝：拷贝基本数据类型的值，对于引用类型的属性，它只是拷贝了引用地址，结果就是原始对象和拷贝对象共享同一个内部引用（“共用外部资料”）。
深拷贝：不仅拷贝基本数据类型的值，还会拷贝引用类型的对象，从而确保两个对象的引用类型属性指向不同的对象。也就是说，它们是“独立的个体”，互不影响。

CopyOnWriteArrayList 的底层原理

CopyOnWriteArrayList 是一个线程安全的 List，它的底层实现有点聪明，通过“写时复制”的策略来避免读写冲突。我们来一块儿看看它是如何工作的：

1. 基本实现：用数组做基础

CopyOnWriteArrayList 其实和普通的 ArrayList 一样，底层也是用数组存储元素。但是！这里有个大招——当你要向它添加元素时，它不会直接修改原来的数组，而是复制一个新的数组。所有的写操作都在新数组上完成，读操作还是直接从原数组中获取数据。你可以把它想象成“写时复制”的阵地战：写战场是新阵地，读战场是原始阵地。

2. 写操作加锁：确保数据安全

为了避免多个线程同时写数据导致的“数据丢失”，CopyOnWriteArrayList 在进行写操作时会加锁。这样一来，写操作就变得原子性，即每次只能有一个线程修改数据，确保写入的数据不会丢失。

3. 替换原数组：完成写操作

当写操作完成后，CopyOnWriteArrayList 会把原来的数组引用指向新数组。就像在换新房子，住进去后，原房子（旧数组）不再使用，而是彻底“搬家”到了新房子（新数组）。

4. 读操作优势：无锁读取提升性能

最酷的地方来了！虽然写操作会加锁，但读操作是无锁的。读数据时，直接从原数组读取，不会被写操作干扰。因此，在读多写少的场景下，CopyOnWriteArrayList 的读性能非常高。就像是你的朋友同时在刷手机（读数据），而你在另一边改名字（写数据），你不影响他的阅读，他也不打扰你的更新。

不过要注意，虽然读性能强，但这种方式会占用更多的内存，因为每次写操作都会创建一个新数组。再加上，读到的数据可能不是最新的，所以对于实时性要求很高的场景，它并不合适。

总结

高效读取：读操作无锁，效率高，适合读多写少的应用。
写时复制：写操作会复制数组，确保并发写入安全，但开销大。
内存消耗：每次写都会复制数组，占用较多内存。
数据不实时：读到的数据可能不是最新的，不适合实时性要求高的场景。

字节码是啥？

字节码，听起来有点像机器语言的“中介语言”，其实它就是 Java 程序在编译之后生成的一种虚拟机器可以理解的中间语言。这就像是你和外星人用一种共同的语言交流，既不是你说的地球语言，也不是外星人自己的语言，而是一个大家都能懂的“中间语”。

具体来说，Java 的编译器会把我们写的 Java源代码 编译成这种字节码（.class 文件）。这个字节码不是针对某一台特定计算机的机器码，它只是为了让 Java 虚拟机（JVM） 理解。所以，不管你是用 Windows、Mac 还是 Linux，JVM 都能翻译这个字节码并执行它。说白了，它是一种跨平台的“中转站”。

字节码的执行流程

那么，Java程序到底是怎么从源代码到机器上跑起来的呢？来，我们拆解一下：

Java源代码（.java 文件） -> 通过Java编译器（javac）编译，变成 字节码（.class 文件）。
字节码并不直接运行在物理机器上，它需要一个虚拟的机器——JVM（Java虚拟机）来执行。
JVM 把字节码当成虚拟指令（也就是“外星语言”），然后通过解释器翻译成机器能懂的指令，最后让机器执行。

这种“先翻译成字节码，再翻译成机器码”的方式让Java能够在不同平台间流畅地运行。

采⽤字节码的好处

1. 跨平台性：一次编译，到处运行

传统的编程语言如果想在不同操作系统上运行，得重新编译一遍。而Java通过字节码解决了这个问题。你写好代码，编译成字节码后，无论你用的是什么操作系统，只要有 JVM，你的 Java 程序都可以运行。

想象一下：你在 Windows 上编写了一个 Java 程序，然后传给你朋友，他在 Mac 上运行。只要他的电脑上有 JVM，他就能直接运行，不需要你重新编译程序！“写一次，运行处处”，是不是很酷？

2. 提升执行效率：比纯解释型语言快

虽然 Java 是解释型语言，但它不像传统的解释型语言那样直接解释源代码，而是先编译成字节码，这样程序就不需要每次执行时都重新解释源代码了。字节码已经是一个中间层指令，接近机器码，因此比传统的解释型语言快很多。

举个例子：你有个食谱，每次做饭时都要重新看一遍每个步骤，那不就慢吗？但如果你提前把每个步骤都写在菜单上（字节码），做饭时就直接按照菜单走，效率自然高得多。

3. 平台无关性：不管你用啥机器，字节码都能跑

由于字节码是面向Java虚拟机（JVM）的，而不是特定机器的，这就意味着你只要有 JVM，字节码在哪个平台上都能跑。JVM 就像是一个通用的“翻译官”，帮你把字节码翻译成不同平台能执行的机器码。

想象你在中国用中文写信，而你的朋友在美国，他们不懂中文，这时候你就需要一个翻译官。JVM 就是这个翻译官，帮你把字节码“翻译”成他们能理解的“机器语言”，所以无论是 Windows、Mac 还是 Linux，都会正确运行。

总结：字节码的超级优点

跨平台：一个字节码，跑遍世界。只要有 JVM，你写的 Java 程序就可以在不同的操作系统上运行。
提高执行效率：虽然 Java 不是纯编译型语言，但字节码让它比传统的解释型语言运行得更快。
可移植性强：字节码不是面向某一台计算机，而是面向虚拟机，只要有 JVM，就能跑。

Java中的异常体系：简化版

在 Java 中，所有的异常都继承自一个顶级父类——Throwable。它就像是所有异常的祖宗，其他的异常都从它这里继承下来。Throwable 下面有两个重要的“子孙”：

Error
Exception

1. Error：程序的死敌

Error 是程序中最可怕的敌人。它表示一些你根本无法处理的严重问题，比如 内存溢出 或者 JVM崩溃。当这些错误发生时，程序是无法自救的，一旦出现，程序会被迫“死亡”，无法继续运行。就像是你玩游戏时，突然电源掉了，那就只能认命，游戏直接“死机”！

2. Exception：程序可以处理的麻烦

Exception 表示程序能处理的各种异常问题，虽然会让程序停一下，但你可以捕捉并处理这些问题，让程序继续运行。Exception 又被分为两大类：

RuntimeException：运行时异常（程序的隐形杀手）
- 这类异常通常是在程序运行过程中不小心犯错产生的，比如除数为零、数组越界等。这些异常可以不显式处理，因为很多时候它们是编程错误造成的。例如，你在计算机上试图除以零，这可不可能不报错吧？这些通常发生时，会让当前的程序“卡住”，但是并不影响整个系统的运行。简单来说，这些异常可以“无视”，直到程序崩溃。
CheckedException：检查异常（程序员的噩梦）
- 这些异常通常发生在程序编译时，就像老师在检查作业时挑出错误一样。如果你不处理这些异常，程序就无法通过编译！比如文件不存在、数据库连接失败等情况，编译器会强制要求你捕获这些异常或声明抛出。这类异常不容忽视，必须处理，才允许程序运行。就像你去面试，面试官要求你穿正式衣服，你不穿，直接被拒绝进入面试！