Java的序列化和反序列化是用于对象的持久化和传输的重要机制。以下是对相关概念的详细解释:
Java 序列化与反序列化
序列化 (Serialization) 是将 Java 对象转换为字节流的过程,这样对象就可以通过网络传输或者保存到文件中。反序列化 (Deserialization) 是将字节流重新转换为 Java 对象的过程。
序列化的步骤
- 实现
Serializable
接口。 - 使用
ObjectOutputStream
将对象写入到输出流中。
java
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Person person = new Person("John", 30);
try (FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
out.writeObject(person);
} catch (IOException i) {
i.printStackTrace();
}
}
}
反序列化的步骤
- 使用
ObjectInputStream
从输入流中读取对象。
java
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
public class DeserializePerson {
public static void main(String[] args) {
Person person = null;
try (FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn)) {
person = (Person) in.readObject();
} catch (IOException i) {
i.printStackTrace();
} catch (ClassNotFoundException c) {
System.out.println("Person class not found");
c.printStackTrace();
}
System.out.println("Deserialized Person...");
System.out.println("Name: " + person.name);
System.out.println("Age: " + person.age);
}
}
Serializable 原理
Serializable
是一个标记接口(没有任何方法),它向 JVM 指示该类的对象可以被序列化。序列化过程中,JVM 将该对象的状态保存为字节流,包括其所有非瞬态和非静态字段。
Parcelable 接口原理解析
Parcelable
是 Android 特有的接口,用于更高效地在不同的进程之间传输对象。相比于 Serializable
,Parcelable
更适合 Android,因为它在内存开销和性能上更为高效。
实现 Parcelable
接口的步骤
- 实现
Parcelable
接口。 - 实现
writeToParcel
方法,将对象的字段写入Parcel
。 - 实现
CREATOR
静态字段,负责反序列化Parcelable
对象。
java
import android.os.Parcel;
import android.os.Parcelable;
public class Person implements Parcelable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
protected Person(Parcel in) {
name = in.readString();
age = in.readInt();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<Person> CREATOR = new Creator<Person>() {
@Override
public Person createFromParcel(Parcel in) {
return new Person(in);
}
@Override
public Person[] newArray(int size) {
return new Person[size];
}
};
}
JSON (JavaScript Object Notation)
JSON 是一种轻量级的数据交换格式,易于人类阅读和编写,同时也易于机器解析和生成。Java 中可以使用库如 Gson
或 Jackson
来处理 JSON 数据。
使用 Gson 进行 JSON 序列化和反序列化
java
import com.google.gson.Gson;
public class JsonExample {
public static void main(String[] args) {
Gson gson = new Gson();
Person person = new Person("John", 30);
// 序列化
String json = gson.toJson(person);
System.out.println(json);
// 反序列化
Person person2 = gson.fromJson(json, Person.class);
System.out.println("Name: " + person2.name);
System.out.println("Age: " + person2.age);
}
}
XML (Extensible Markup Language)
XML 是一种标记语言,用于描述数据。Java 中可以使用 JAXB
(Java Architecture for XML Binding) 或 XStream
等库来处理 XML 数据。
使用 JAXB 进行 XML 序列化和反序列化
java
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class Person {
private String name;
private int age;
// Default constructor is required for JAXB
public Person() {}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@XmlElement
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@XmlElement
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String[] args) throws JAXBException {
Person person = new Person("John", 30);
// 序列化
JAXBContext context = JAXBContext.newInstance(Person.class);
Marshaller marshaller = context.createMarshaller();
StringWriter writer = new StringWriter();
marshaller.marshal(person, writer);
String xml = writer.toString();
System.out.println(xml);
// 反序列化
Unmarshaller unmarshaller = context.createUnmarshaller();
Person person2 = (Person) unmarshaller.unmarshal(new StringReader(xml));
System.out.println("Name: " + person2.getName());
System.out.println("Age: " + person2.getAge());
}
}
这就是 Java 中序列化与反序列化、Serializable
原理、Parcelable
接口原理以及 JSON 和 XML 的解析方法。