一、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异常