Parcelable的基本使用

public class Student2 implements Parcelable {
    private String name;
    private int age;
    private boolean hasFinished;
    private Book book;
    private List<Book> bookList;
    private Book[] bookArray;
    private int[] gradesArray;
    private Map<Integer, String> bookMap;


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isHasFinished() {
        return hasFinished;
    }

    public void setHasFinished(boolean hasFinished) {
        this.hasFinished = hasFinished;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public List<Book> getBookList() {
        return bookList;
    }

    public void setBookList(List<Book> bookList) {
        this.bookList = bookList;
    }

    public Book[] getBookArray() {
        return bookArray;
    }

    public void setBookArray(Book[] bookArray) {
        this.bookArray = bookArray;
    }

    public int[] getGradesArray() {
        return gradesArray;
    }

    public void setGradesArray(int[] gradesArray) {
        this.gradesArray = gradesArray;
    }

    public Map<Integer, String> getBookMap() {
        return bookMap;
    }

    public void setBookMap(Map<Integer, String> bookMap) {
        this.bookMap = bookMap;
    }

    /**
     * 描述
     * 返回的是内容的描述信息
     * 只针对一些特殊的需要描述信息的对象,需要返回1,其他情况返回0就可以
     *
     * @return
     */
    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * 序列化过程，将Student对象的字段都写入parcel
     *
     * @param dest
     * @param flags
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
        //注意boolean类型的字段写入的是byte类型
        dest.writeByte((byte) (hasFinished ? 1 : 0));
        //注意Book对象是用writeParcelable方法写入
        dest.writeParcelable(book, flags);
        //注意List集合的写入方法
        dest.writeTypedList(bookList);
        //注意引用类型的数组的写入方法时writeTypedArray,例如Book[]
        dest.writeTypedArray(bookArray, flags);
        //注意基本类型的数据的写入方法，例如int[]数组用的是writeIntArray
        dest.writeIntArray(gradesArray);
        //注意Map集合是用writeMap写入的
        dest.writeMap(bookMap);
    }

    /**
     * 构造方法都数据
     *
     * @param in
     */
    protected Student2(Parcel in) {
        name = in.readString();
        age = in.readInt();
        hasFinished = in.readByte() != 0;
        book = in.readParcelable(Book.class.getClassLoader());
        bookList = in.createTypedArrayList(Book.CREATOR);
        bookArray = in.createTypedArray(Book.CREATOR);
        gradesArray = in.createIntArray();
        bookMap = new HashMap<>();
        in.readMap(bookMap, getClass().getClassLoader());
    }

    /**
     * 通过重写的createFromParcel方法就可以看出是获取对象数据
     * 所以CREATOR是反序列化过程。
     */
    public static final Creator<Student2> CREATOR = new Creator<Student2>() {
        /**
         * 从序列化对象中，获取原始的对象
         * @param in
         * @return
         */
        @Override
        public Student2 createFromParcel(Parcel in) {
            return new Student2(in);
        }

        /**
         * 创建指定长度的原始对象数组
         * @param size
         * @return
         */
        @Override
        public Student2[] newArray(int size) {
            return new Student2[size];
        }
    };
}

注意，如果Parcelable的实现类中的成员变量有引用对象，例如Student2中的Book，引用类型也必须是序列化的。

过程分析

首先说一下Parcel，Parcel内部包装了可序列号的数据，可以在Binder中自由传输。
在序列化的过程中需要实现的功能有序列化，反序列化和内容描述。
序列化功能有writeToParcel方法完成，最终是通过Parcel中的一系列write方法来完成的。
反序列化功能由CREATOR来完成，其内部标明了如何创建序列化对象和数组，并通过Parcel的一系列read方法来完成反序列化过程。
内容描述功能有describeContents方法来完成的，几乎在所有情况下这个方法都应该返回0，仅当当前对象中存在文件描述符时，此方法返回1.
需要注意的是，在Student2中Book也是一个序列化对象，所以它的反序列化过程需要传递当前线程的上下文类加载器，否者会报无法找到类的错误。

parceleble和serilizable的区别和比较

serilizable比parceleble用法简单。
parecleble比serilizable更高效。
Parceleble和Serilizable都是实现序列化并且都可以用于Intent间传递数据，Serilizable是Java的实现方式，可能会频繁的IO操作，所以消耗比较大，但是实现方式简单。Parcelable是Android提供的方式，效率高，但是实现起来复杂一些。
二者的选取规则是：内存序列化上选择Parceleble，存储到设置或者网络上选择Serializable。

选择序列化方法的原则

1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为在外界有变化的情况下，Parcelable不能很好的保证数据的持续性。尽管Serializable效率低点，但此时还是建议使用Serializable 。