Android序列化的几种实现方式

小蚂蚁

一、Serializable序列化
Serializable是java提供的一种序列化方式,其使用方式非常简单,只需要实现Serializable接口就可以实现序列化.

public interface Serializable {
}

1.Serializable使用

import java.io.Serializable;
public class Person implements Serializable {
  //如果不定义,系统会自动生成一个
  //一般来说,我们需要手动指定,当反序列化时,如果类发生了改变,比如增加或删除了某些成员变量,系统重新计算serialVersionUID的值
  //这个时候,保存在文件中的那个对象的serialVersionUID值和当前类的serialVersionUID值已经不一致了,会导致序列化失败
  //如果你修改了类名,或者成员变量的数据类型,也是会序列化失败,因为结构已经发生了根本性的改变
  private final static long serialVersionUID = 1L;
  //transient和static修饰的成员变量不会参与序列化
  private transient int verson;
  public String name;
  public int age;
}

public static void main(String[] args){
  Person person = new Person();
  person.name = "miku";
  person.age = 18;
  try {
    //将对象保存到本地文件
    try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\person.obj"))) {
       objectOutputStream.writeObject(person);
    }
    //将保存到本地文件的对象反序列化,转换成可实际操作的对象
    try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\person.obj"))) {
       Person personWrite = (Person)objectInputStream.readObject();
       System.out.println("===========反序列化=============");
       System.out.println("name:" + personWrite.name);
       System.out.println("age:" + personWrite.age);
    }
   } catch (Exception e) {
     e.printStackTrace();
  }
}

2.Serializable的优缺点
优点:
a.Serializable支持将对象保存到本地文件中,持久化保存
b.使用方便,应该是最方便的一种序列化方式了
缺点:
a.性能开销(cpu和磁盘读写)占用过高
b.安全性不强,用文本编辑器甚至能看到部分数据

二 、Externalizable序列化
Externalizable和Serializable区别其实不大,只是比Serializable多了自定义序列化的选择而已,因为Externalizable是继承自
Serializable接口多了一个读、写的方法而已.Externalizable可以自由选择哪些变量可以被序列化.

public interface Externalizable extends java.io.Serializable {
  void writeExternal(ObjectOutput out) throws IOException;
  void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

1.Externalizable的使用

public class User implements Externalizable{
  public String name;
  public int age;
  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
//注意,写入的顺序和读取的顺序要一致,比如我先写入name,后写入age
//那么readExternal()读取的时候也要一致,不然会抛异常
    out.writeObject("writeUser");
    out.writeInt(18);
  }
  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    this.name = (String)in.readObject();
    this.age = in.readInt();
  }
}

public static void main(String[] args) {
  User user = new User();
  user.name = "miku";
  user.age = 16;
  System.out.println("==========序列化之前===========");
  System.out.println("name: " + user.name);
  System.out.println("age: " + user.age);
  try {
//将对象保存到文件
    try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\user.obj"))) {
      objectOutputStream.writeObject(user);
  }
//将保存到文件的对象反序列化,还原成内存中的对象
  try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\user.obj"))) {
      User userWrite = (User)objectInputStream.readObject();
      System.out.println("=============序列化之后==========");
      System.out.println("name:" + userWrite.name);
      System.out.println("age:" + userWrite.age);
  }
  } catch (Exception e) {
     e.printStackTrace();
  }
}

2.Externalizable的优缺点
与Serializable一致,只不过比Serializable多了一个自定义序列化的过程,可人为控制
三、Parcelable序列化
Parcelable其实是安卓系统提供的一种内存数据传递的实现,严格来说并不能算是序列化,因为它只存在于
内存,无法持久化存储
官方文档介绍:
Parcelable

public interface Parcelable {
  public void writeToParcel(Parcel dest, @WriteFlags int flags);
  public interface Creator<T> {
    public T createFromParcel(Parcel source);
    public T[] newArray(int size);
  }
  public interface ClassLoaderCreator<T> extends Creator<T> {
    public T createFromParcel(Parcel source, ClassLoader loader);
  }
}

1.Parcelable的使用

public class Person implements Parcelable {
  public String name;
  public int age;
  public int type;
  public Object obj;
  public Person user;
  public Person(){
  }
  //出来实现接口提供的方法,还需要定义一个Parcel参数的构造函数CREATOR 调用
  //读取的顺序要和写入的顺序一致,比如 type,name,age,那么writeToParcel()方法
  //中的顺序也要一致
  private Person(Parcel in) {
    type = in.readInt();
name = in.readString();
age = in.readInt();
user = in.readParcelable(Thread.currentThread().getContextClassLoader());
  }
  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];
    }
  };
  //默认返回0就可以了
  //官方文档:https://developer.android.com/reference/android/os/Parcelable.html#CONTENTS_FILE_DESCRIPTOR
  @Override
  public int describeContents() {
    return 0;
  }
  //将数据写入到Parcel
  @Override
  public void writeToParcel(Parcel dest, int flags) {
    dest.writeInt(type);
    dest.writeString(name);
    dest.writeInt(age);
dest.writeParcelable(user,0);
  }
}

Person person = new Person();
person.name = "miku";
person.age = 16;
person.type = 1;
//直接通过intent传递
Intent intent = new Intent(this,xxx.class);
intent.putExtra("user", person);
startActivity(intent);

xxxActivity.java
Person person = (Person) getIntent().getParcelableExtra("user")

2.Parcelable的优缺点
优点:
a.性能效率都比Serializable高.毕竟都是在内存中操作
b.因为数据都存在于内存,安全性要比Serializable
缺点:
a.Parcelable无法持久化存储,只能存在于内存
b.数据大小限制为几~KB,超过会抛 TransactionTooLargeException异常