Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：Java基础面经
📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。
Java基础
- 一、Java中的序列化和反序列化是什么？
- 1、序列化
- 1.1 Java序列化关键类和接口
- 2、反序列化
- 3、注意点
- 3.1 transient 关键字
- 3.2 serialVersionUID
- 3.3 序列化性能问题
- 3.4 安全性
- 4、序列化和反序列化理解
- 4.1 Java 序列化 Serializable 的意义
- 4.2 serialVersionUID 又有什么用？
- 4.2 Java 序列化不包含静态变量
- 二、什么是 Java 中的不可变类？
- 1、特征
- 1.1 不可变类 Person 实现
- 1.2 验证不可变性
- 2、不可变类的优缺点
- 2.1 优点
- 2.2 缺点
- 3、举例 String
一、Java中的序列化和反序列化是什么？
应用场景：
网络传输、远程调用、持久化存储（比如：保存数据到文件或者数据库）、以及分布式系统中数据交换。
1、序列化
在Java中 序列化就是把
对象转换为字节流
这样对象可以通过网络传输、持久化存储或者缓存
Java 提供了java.io.Serializable接口来支持序列化，只要类实现了这个接口，就可以将该类的对象进行序列化.
1.1 Java序列化关键类和接口
- 通过实现
Serializable接口，然后用ObjectOutputStream和ObjectInputStream ObjectOutputStream用于序列化，ObjectInputStream用于反序列化- 类必须 实现
Serializable接口 才能被序列化
2、反序列化
是将字节流重新转换为对象的过程，即从存储中读取数据，并重新创建对象
3、注意点
3.1 transient 关键字
- 在序列化过程中，有些字段不需要被序列化，例如：敏感数据，可以使用
transient关键字 标记不需要序列化的字段。
3.2 serialVersionUID
- 每一个
Serializable类都应该定义一个serialVersionUID，用于在反序列化时验证版本的一致性。如果没有明确指定serialVersionUID，Java会根据类的定义自动生成一个 UID ，版本不匹配可能导致反序列化失败。
3.3 序列化性能问题
- Java默认的序列化机制可能比较慢，尤其是对于大规模分布式系统，可能会选择更加高效的序列化框架
- 比如：
Protobuf、Kryo等
3.4 安全性
- 反序列化是一个潜在的安全风险，因为通过恶意构造的字节流，可能会加载不安全的类 或者 执行不是期望的代码。因此，反序列化过程需要进行输入验证，避免反序列化漏洞。
4、序列化和反序列化理解
序列化其实就是将对象转化为可传输的字节序列格式，以便于存储和传输。
- 因为对象在 JVM 中可以认为是“立体的”，会有各种引用。
- 比如在内存地址中 Ox666 引用了某某某对象，呢此时这个对象要传输到网络的另一端的时候，就需要把这些引用“压扁”。
- 因为网络另一端的内存地址 Ox666 可以没有某某某对象，所以传输的对象需要包含这些信息，然后接收端将这些扁平的信息再反序列化得到对象。
- 所以，反序列化就是将字节序列格式转换为对象的过程
4.1 Java 序列化 Serializable 的意义
Serializable 接口没有什么实际的含义，就是起到一个标记的作用
- 观看一下源码就会非常清楚，除了String，数组，枚举之外，如果实现了 serializable 这个接口就走 writeOrdinaryObject，否则序列化就会抛出异常。
4.2 serialVersionUID 又有什么用？
private static final long serialVersionUID = 1L;
想必经常会看到这样的代码，这个 ID 其实就是用来验证序列化的对象和反序列化对应的对象的 ID 是否是一致的。所以这个 ID 的数字其实不重要，无论是 1L 还是 idea 自动生成的，只要序列化的时候对象 serialVersionUID和反序列化的时候对象的 serialVersionUlD 一致的话就行。如果没有显式指定 serialVersionUlD 则编译器会根据类的相关信息自动生成一个，可以认为是一个指纹。所以如果你没有定义一个 serialVersionUID 然后序列化个对象之后，在反序列化之前把对象的类的结构改了，比如增加了一个成员变量，则此时的反序列化会失败。因为类的结构变了，生成的指纹就变了，所以 serialVersionUID 就不一致了.
4.2 Java 序列化不包含静态变量
简单地说就是序列化之后存储的内容不包含静态变量的值，看一下下面的代码就很清晰了。
import java.io.*;
public class Test implements Serializable {
//指纹
private static final long serialVersionUID = 1L;
public static int n = 1;
public static void main(String[] args) {
try {
ObjectOutputStream outputStream = new ObjectOutputStream(
new FileOutputStream("明志学编程！"));
outputStream.writeObject(new Test());
outputStream.close();
//序列化后修改值
Test.n = 2;
ObjectInputStream objectInputStream = new ObjectInputStream(
new FileInputStream("明志学编程！"));
Test t = (Test) objectInputStream.readObject();
objectInputStream.close();
System.out.println(t.n);
} catch (Exception e) {
e.printStackTrace();
}
}
}
二、什么是 Java 中的不可变类？
不可变类 是指在创建后其状态（对象的字段）无法被修改的类。一旦对系被创建，它的所有属性都不能被修改。也就是说，对象的所有成员变量在初始化后就不能被修改，无论是通过外部方法还是内部方法。这种类的实例整个生命周期内保持不变。
1、特征
- 字段声明为 final，防止子类继承
- 该类的所有字段都是 private 和 final，确保只能在构造函数中初始化，之后不能修改。另外，不要提供 serter 方法，因为 setter 会改变变量的值。
- 如果类中有可变对象的引用，比如一个 Date 对象，那么在获取该对象的时候应该返回其副本而不是原对象，防止外部修改影响内部状态。
- 通过构造函数初始化所有字段
- 如果有一个可变对象，比如一个Date类型的birthDate，那么在getter中应该返回birthDate的克隆或者新的Date对象，而不是直接返回引用，这样可以避免外部的修改影响到Person类内部的状态。
- 可能还需要注意
深拷贝的问题，特别是在构造函数中传入可变对象时，应该进行拷贝，而不是直接引用。比如，如果构造函数的参数是Date，应该创建一个新的Date对象保存其值，这样外部的Date对象后续变化不会影响Person内部的birthDate。 - 另外，确保类不会被扩展，所以类本身要声明为final，这样不会有子类覆盖方法导致状态变化的风险。
Java中经典不可变类有 ：
String，Integer，BigDecimal，LocalDate等
1.1 不可变类 Person 实现
public final class Person {
// 1. 成员变量声明为 private final
private final String name;
private final int age;
private final List<String> hobbies;
// 2. 通过构造函数初始化所有成员变量
public Person(String name, int age, List<String> hobbies) {
this.name = name;
this.age = age;
// 3. 对可变对象进行深拷贝（防御性拷贝）
this.hobbies = new ArrayList<>(hobbies);
}
// 4. 不提供 setter 方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
// 5. 返回可变对象的不可变视图或深拷贝
public List<String> getHobbies() {
return Collections.unmodifiableList(hobbies);
// 或者返回深拷贝：return new ArrayList<>(hobbies);
}
}
1.2 验证不可变性
public class Main {
public static void main(String[] args) {
List<String> hobbies = new ArrayList<>();
hobbies.add("Reading");
Person person = new Person("Alice", 30, hobbies);
// 尝试修改原始 hobbies
hobbies.add("Cooking");
System.out.println("Original Hobbies: " + hobbies); // [Reading, Cooking]
// 不可变类的 hobbies 未被修改
System.out.println("Person's Hobbies: " + person.getHobbies()); // [Reading]
// 尝试通过 getHobbies() 修改（会抛出 UnsupportedOperationException）
person.getHobbies().add("Gaming");
}
}
2、不可变类的优缺点
2.1 优点
- 线程安全：由于不可变对象的状态不能被修改，他们天生就是线程安全的，在并发环境中无需同步。
- 缓存友好：不可变对象可以安全的被缓存和共享，如 string 的字符常量池。
- 防止状态不一致：不可变类可以有效避免因意外修改对象状态而导致的不一致问题。
2.2 缺点
- 性能问题：不可变对象需要在每次状态变化时创建新的对象，这可能会导致性能开销，尤其是对于大规模对象或频繁修改的场景（例如String频繁拼接）
3、举例 String
String就是典型的不可变类，当你创建一个String对象之后，这个对象就无法被修改。
因为无法被修改，所以像执行S += “a” ,这样的方法，其实返回的是一个新建的String对象，老的 S 指向的对象不会发生变化，只是 S 的引用指向了新的对象而已。
所以不要在字符串拼接频繁的场景使用+来拼接，因为这样会频繁的创建对象。
不可变类的好处就是安全，因为知晓这个对象不可能会被修改，因此可以放心大胆的用，在多线程环境下也是线程安全的。
查看 String 的源码，发现 String 类是 final 修饰的，表示无法被继承。
String本质是一个char数组，然后用final修饰，不过 final 限制不了数组内部的数据，所以这还不够。所以value是用private修饰的，并且没有暴露出set方法，这样外部其实就接触不到vlue所以无法修改。
当然还是有修改的需求，比如replace方法，所以这时候就需要返回一个新对象来作为结果。
就是私有化变量，然后不要暴露St方法，即使有修改的需求也是返回一个新对象。
