java 中通过实现 serializable 接口并使用 objectoutputstream 和 objectinputstream 进行序列化传输。具体做法是将对象转换为字节流发送,接收端再将其还原为对象。若字段不需要参与序列化,可标记为 transient;若需自定义逻辑,可实现 writeobject() 和 readobject() 方法。

基本类型与包装类的序列化差异是什么
基本类型(如 int、boolean)在序列化时直接存储其值,而包装类(如 Integer、Boolean)作为对象处理,包含对象头信息。这种差异导致包装类序列化后的体积通常更大,且在反序列化时可能涉及额外的对象创建开销。

import java.io.*;
public class BasicVsWrapper {
public static void main(String[] args) throws Exception {
// 测试基本类型
int primitive = 42;
ByteArrayOutputStream baosPrim = new ByteArrayOutputStream();
ObjectOutputStream oosPrim = new ObjectOutputStream(baosPrim);
oosPrim.writeInt(primitive); // 直接写入 int
oosPrim.close();
byte[] primBytes = baosPrim.toByteArray();
// 测试包装类
Integer wrapper = 42;
ByteArrayOutputStream baosWrap = new ByteArrayOutputStream();
ObjectOutputStream oosWrap = new ObjectOutputStream(baosWrap);
oosWrap.writeObject(wrapper); // 写入对象
oosWrap.close();
byte[] wrapBytes = baosWrap.toByteArray();
System.out.println("Primitive bytes length: " + primBytes.length);
System.out.println("Wrapper bytes length: " + wrapBytes.length);
}
}
运行结果:基本类型 int 序列化后长度为 4 字节,而包装类 Integer 序列化后长度显著大于 4 字节(通常包含对象头、类描述符等元数据)。这证实了包装类因对象结构导致体积增加。
如何避免敏感字段被序列化
使用 transient 关键字修饰字段可防止其被序列化。当对象被序列化时,transient 字段的值会被忽略,反序列化后该字段恢复为默认值(如 null 或 0)。这是保护密码、密钥等敏感信息的标准做法。

import java.io.*;
public class TransientExample implements Serializable {
private String username;
private transient String password; // 标记为 transient
public TransientExample(String user, String pass) {
this.username = user;
this.password = pass;
}
public static void main(String[] args) throws Exception {
TransientExample obj = new TransientExample("admin", "secret123");
// 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.close();
// 反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
TransientExample restored = (TransientExample) ois.readObject();
ois.close();
System.out.println("Username: " + restored.username);
System.out.println("Password: " + restored.password);
}
}
运行结果:username 正确还原为 "admin",而 password 输出为 null。这验证了 transient 关键字有效阻止了敏感数据的持久化。
如果对象图存在循环引用会怎样
Java 的序列化机制通过维护一个对象引用表来处理循环引用。当序列化器遇到已序列化的对象时,它不会再次写入整个对象内容,而是写入一个引用标识。反序列化时,它会解析这些引用并重建正确的对象图关系,从而避免无限递归和栈溢出错误。
import java.io.*;
public class CircularRef implements Serializable {
public Node self;
public static class Node implements Serializable {
public Node next;
public String data;
}
public static void main(String[] args) throws Exception {
Node n1 = new Node();
n1.data = "Node1";
Node n2 = new Node();
n2.data = "Node2";
n1.next = n2;
n2.next = n1; // 循环引用
CircularRef container = new CircularRef();
container.self = n1;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(container); // 成功序列化
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
CircularRef restored = (CircularRef) ois.readObject(); // 成功反序列化
ois.close();
System.out.println("Restored cycle valid: " + (restored.self.next == restored.self));
}
}
运行结果:Restored cycle valid: true。这表明 Java 序列化能正确处理循环引用,反序列化后对象间的引用关系保持完整。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











