大白话理解 Java 序列化：对标前端 JSON.stringify/parse

本文用极简示例对比前端 JSON 处理和 Java 对象序列化，零基础也能看懂，核心类比：Java 序列化 ≈ 前端 JSON.stringify ()Java 反序列化 ≈ 前端 JSON.parse ()

一、前端极简示例（JSON.stringify/JSON.parse）

核心逻辑：把「活对象」转成字符串存储，再从字符串还原成「活对象」

javascript 复制代码

// 1. 定义一个"活的"对象（有属性、可调用）
const user = {
    name: "张三",
    age: 25
};

// 2. 序列化：对象 → JSON字符串（对应Java的ObjectOutputStream）
// 把内存中的对象转成可存储/传输的字符串格式
const userStr = JSON.stringify(user); 
// 模拟存到本地（对应Java的FileOutputStream写文件）
localStorage.setItem("user", userStr);

// 3. 反序列化：JSON字符串 → 对象（对应Java的ObjectInputStream）
// 从本地读取字符串（对应Java的FileInputStream读文件）
const readStr = localStorage.getItem("user"); 
// 把字符串还原成可操作的对象
const newUser = JSON.parse(readStr);

// 验证结果
console.log("反序列化结果：", newUser); // 输出：{name: "张三", age: 25}

// 清理本地存储（可选）
localStorage.removeItem("user");

二、Java 极简示例（4 个核心类全包含）

核心逻辑：把 Java 对象转成字节存到文件，再从文件字节还原成 Java 对象涉及核心类：FileOutputStream、ObjectOutputStream（序列化）、FileInputStream、ObjectInputStream（反序列化）

步骤 1：定义可序列化的 User 类

java

运行

arduino 复制代码

import java.io.Serializable;

/**
 * 要序列化的类必须实现Serializable接口（标记接口，无实际方法）
 * 相当于给对象贴"可序列化标签"
 */
public class User implements Serializable {
    // 序列化版本号（固定写法，避免类结构变更导致反序列化失败）
    private static final long serialVersionUID = 1L;
    
    // 简单属性
    String name;
    int age;
    
    // 构造方法：初始化对象
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

步骤 2：核心序列化 + 反序列化代码

java 复制代码

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SimpleSerializeDemo {
    public static void main(String[] args) throws Exception {
        // ===================== 序列化（输出）=====================
        // 1. FileOutputStream：负责和文件交互，写字节到文件
        FileOutputStream fos = new FileOutputStream("user.txt");
        // 2. ObjectOutputStream：负责把Java对象转换成字节
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 3. 核心操作：将"活对象"写入文件
        oos.writeObject(new User("张三", 25));
        oos.close(); // 关闭流（释放资源）

        // ===================== 反序列化（输入）=====================
        // 4. FileInputStream：负责和文件交互，从文件读字节
        FileInputStream fis = new FileInputStream("user.txt");
        // 5. ObjectInputStream：负责把字节还原成Java对象
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 6. 核心操作：从文件读取并还原对象（强制类型转换）
        User newUser = (User) ois.readObject();
        ois.close(); // 关闭流（释放资源）

        // 验证结果
        System.out.println("反序列化结果：" + newUser.name + "，" + newUser.age + "岁");
        // 输出：反序列化结果：张三，25岁
    }
}

三、核心对应关系

Java 操作	前端操作	大白话解释
FileOutputStream + ObjectOutputStream 写对象	JSON.stringify()	活对象 → 可存储的格式
FileInputStream + ObjectInputStream 读对象	JSON.parse()	可存储的格式 → 活对象

四、关键总结

核心逻辑一致：不管是 Java 还是前端，都是「活对象 ↔ 可存储格式」的互相转换；
类分工明确 ：Java 中FileXxxStream管 "和文件读写"，ObjectXxxStream管 "对象和字节互转"；
核心差异：JSON 是通用明文格式（跨语言），Java 序列化是二进制格式（仅 Java 识别）。

本文示例极简可直接运行，新手也能快速理解 Java 序列化的核心逻辑～