Android 对象序列化 Java中实现Serializable序列化与Android特有的实现Parceable接口序列化操作

1、Serializable 接口是Java提供的一个序列化空接口，它为对象提供标准的序列化与反序列化操作。使用Serializable实现序列化非常简单，只需要实现Serializable接口，在类的生命中指定一个标识，可以自动实现默认的自动序列化过程。private static final long serialVersionUID = 1L ;

序列化与反序列化过程需要大量的IO操作，适用于序列化到本地或网络传输

完整的对象序列化

public class BookSerializable implements Serializable {
    
    private static final long serialVersionUID = 1L ;
    private String name ;
    private String author ;
    private int publishDate ;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getPublishDate() {
        return publishDate;
    }

    public void setPublishDate(int publishDate) {
        this.publishDate = publishDate;
    }

    @Override
    public String toString() {
        return "BookSerializable{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", publishDate=" + publishDate +
                '}';
    }
}

/**
         * 对于使用序列化还有两点需要注意：
         * 1.静态成员变量属于类不属于对象，所以不参与序列化过程
         * 2.用transient关键字标记的成员变量不参与序列化过程
         */
        BookSerializable book = new BookSerializable() ;
        book.setName("java 程序设计");
        book.setAuthor("未知");
        book.setPublishDate(1200);
        
        File file = new File("test.txt") ;
        if (!file.exists()){
            try {
                file.createNewFile() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //序列化到本地
        try {
            FileOutputStream fileOS = new FileOutputStream(file) ;
            ObjectOutputStream objectOS = new ObjectOutputStream(fileOS) ;
            objectOS.writeObject(book);
            objectOS.flush();
            objectOS.close();
            fileOS.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //反序列化
        try {
            FileInputStream fileIS = new FileInputStream("test.txt") ;
            ObjectInputStream objectIS = new ObjectInputStream(fileIS) ;
            BookSerializable bookSerializable = (BookSerializable) objectIS.readObject() ;
            objectIS.close();
            fileIS.close();
            System.out.print("book-->"+bookSerializable.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

2、Parceable接口

Parceable接口是AndroidSDK提供的一个专门为Android应用中对象序列化与反序列化的方式

实现Parceable接口的类的实现

序列化与反序列化不需要大量的IO操作，适用于内存序列化。

public class BookParcelable implements Parcelable {

    private String name;
    private String author;
    private int publishDate;
    private List<String> list = new ArrayList<>();
    private List<Integer> integerList = new ArrayList<>() ;
    private  String address ;

    @Override
    public String toString() {
        return "BookParcelable{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", publishDate=" + publishDate +
                ", list=" + list +
                ", integerList=" + integerList +
                ", address='" + address + '\'' +
                '}';
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public List<Integer> getIntegerList() {
        return integerList;
    }

    public void setIntegerList(List<Integer> integerList) {
        this.integerList = integerList;
    }

    public BookParcelable() {

    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getPublishDate() {
        return publishDate;
    }

    public void setPublishDate(int publishDate) {
        this.publishDate = publishDate;
    }

    protected BookParcelable(Parcel in) {
        //如果元素数据是list类型的时候需要： lits = new ArrayList<?> in.readList(list);
        //否则会出现空指针异常.并且读出和写入的数据类型必须相同.
        // 如果不想对部分关键字进行序列化,可以使用transient关键字来修饰以及static修饰.
        //Parcel 读操作 与写顺序保持一致 
        name = in.readString();
        author = in.readString();
        publishDate = in.readInt();
        list = in.readArrayList(String.class.getClassLoader()) ;
        integerList = in.readArrayList(Integer.class.getClassLoader()) ;
        address = in.readString() ;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {

        //Parcel 写操作 与对顺序相对应
        dest.writeString(name);
        dest.writeString(author);
        dest.writeInt(publishDate);
        dest.writeList(list);
        dest.writeList(integerList);
        dest.writeString(address);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator<BookParcelable> CREATOR = new Creator<BookParcelable>() {
        @Override
        public BookParcelable createFromParcel(Parcel in) {
            return new BookParcelable(in);
        }

        @Override
        public BookParcelable[] newArray(int size) {
            return new BookParcelable[size];
        }
    };
}