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

巴特西

Android序列化的几种实现方式

一、Serializable序列化

1.Serializable使用

2.Serializable的优缺点

二、Externalizable序列化

1.Externalizable的使用

2.Externalizable的优缺点

三、Parcelable序列化

1.Parcelable的使用

2.Parcelable的优缺点

最新文章

热门文章

巴特西

Android序列化的几种实现方式

一、Serializable序列化

1.Serializable使用

2.Serializable的优缺点

二 、Externalizable序列化

1.Externalizable的使用

2.Externalizable的优缺点

三、Parcelable序列化

1.Parcelable的使用

2.Parcelable的优缺点

最新文章

热门文章

二、Externalizable序列化