Parcelable的那些坑（传自定义对象、List）

Parcelable是安卓中的一个接口，用于实现序列化。同Serializable一样。
二者的区别：Parcelable效率要高于Serializable。主要用在内存中实现序列化。在安卓中推荐使用Parcelable。但是实现起来要稍微麻烦些。
Serializable主要用于在存储设备中实现序列化。实现起来比较简单。

1.Parcelable使用方法：
自定义类实现Parcelable接口，并重写以下方法：

public class Book implements Parcelable {

    public String bookName;
    public int bookId;
    public boolean isColorBook;

    public Book() {

    }

    public Book(String bookName, int bookId, boolean isColorBook) {
        super();
        this.bookName = bookName;
        this.bookId = bookId;
        this.isColorBook = isColorBook;
    }

        //反序列化方法  
    private Book(Parcel p) {
        bookId = p.readInt();
        bookName = p.readString();
        isColorBook = p.readInt() == 1;
    }

    @Override
    public int describeContents() {
        //固定写法 返回0
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        // 序列化方法
        dest.writeString(bookName);
        dest.writeInt(bookId);
        dest.writeInt(isColorBook ? 1 : 0);// 未提供writeBoolean方法 1为true 0为false
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {

        @Override
        public Book createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            return new Book(source);
        }

        @Override
        public Book[] newArray(int size) {
            // TODO Auto-generated method stub
            return new Book[size];
        }
    };
    }

---

这样就完成序列化操作了。Parcelable接口中未提供boolean的序列化方法，所以使用int来代替boolean。1为true，0为false。

---

如果当前类中包含有其他自定义的类，怎么传呢。首先要确保自定义的类实现了可序列化的接口。接下来就是在可序列话方法中稍微修改下就可以了：

public class AllBook implements Parcelable {

    private String bookName;
    // 自定义类Book 实现了Pracelable接口
    private Book book;

    public AllBook() {
    }

    public AllBook(Parcel p) {
        // 序列化自定义对象 需要传入上下文类加载器
        book = p.readParcelable(Thread.currentThread().getContextClassLoader());
        bookName = p.readString();

    }

    public AllBook(String bookName, int bookId, boolean isColor, Book books) {
        super();
        this.bookName = bookName;
        this.book = books;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        // TODO Auto-generated method stub
        out.writeString(bookName);
        // 序列化自定义类对象 第二个参数绝大多数情况下传0即可
        out.writeParcelable(book, 0);

    }

    public static final Creator<AllBook> CREATOR = new Creator<AllBook>() {

        @Override
        public AllBook createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            return new AllBook(source);
        }

        @Override
        public AllBook[] newArray(int size) {
            // TODO Auto-generated method stub
            return new AllBook[size];
        }
    };
}

---

如果要传自定义集合，同样也要要保证集合中的类已经实现了序列化接口。
代码如下：

public class MyBook implements Parcelable {

    private String bookName;
    private int bookId;
    private boolean isColor;
    //自定义集合 Book实现了Parcelable接口
    private ArrayList<Book> books;

    public MyBook() {
    }

    public MyBook(Parcel p) {

        bookName = p.readString();
        bookId = p.readInt();
        isColor = p.readInt() == 1;

        // 用这种方法会报错。
        // books=p.readArrayList(Thread.currentThread().getContextClassLoader());

        // 传递自定义List 只能用以下方法
        books= in.createTypedArrayList(Book.CREATOR);

    }

    public MyBook(String bookName, int bookId, boolean isColor,
            ArrayList<Book> books) {
        super();
        this.bookName = bookName;
        this.bookId = bookId;
        this.isColor = isColor;
        this.books = books;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookId() {
        return bookId;
    }

    public void setBookId(int bookId) {
        this.bookId = bookId;
    }

    public boolean isColor() {
        return isColor;
    }

    public void setColor(boolean isColor) {
        this.isColor = isColor;
    }

    public ArrayList<Book> getBooks() {
        return books;
    }

    public void setBooks(ArrayList<Book> books) {
        this.books = books;
    }

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

    @Override
    public void writeToParcel(Parcel out, int flags) {
    //序列化集合
        out.writeTypedList(books);
        out.writeInt(isColor ? 1 : 0);
        out.writeInt(bookId);
        out.writeString(bookName);
    }

    public static final Creator<MyBook> CREATOR = new Creator<MyBook>() {

        @Override
        public MyBook createFromParcel(Parcel source) {
            return new MyBook(source);
        }

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

    @Override
    public String toString() {
        return "MyBook [bookName=" + bookName + ", bookId=" + bookId
                + ", isColor=" + isColor + "]";
    }

也就是说序列化自定义List的方法为：

out.writeTypedList(list);

反序列化的方法为：

list = in.createTypedArrayList(Entity.CREATOR);

这里保证对象实现了Parcelable接口，传集合内对象的CREATOR

这样就可以传自定义List集合了。