Android 实现Parcelable接口完成序列化

Parcelable接口是Android中用于实现对象序列化的一种机制，它比Java中的Serializable接口更高效。通过实现Parcelable接口，可以将自定义的对象在不同组件或进程之间进行传递。
要实现Parcelable接口，可以按照以下步骤进行操作：

1. 在目标类中实现Parcelable接口，并重写以下方法：writeToParcel(Parcel dest, int flags)和describeContents()。

2. 在构造函数中读取Parcel对象并赋值给类的成员变量。

3. 创建一个名为CREATOR的静态Parcelable.Creator对象，并实现createFromParcel(Parcel in)和newArray(int size)方法。
   下面是一个示例，展示如何实现Parcelable接口：

   import android.os.Parcel;
   import android.os.Parcelable;
   
   import androidx.annotation.NonNull;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class TestBean implements Parcelable {
       public int id;
       public String name;
       public List score;
       public List> data;
       public Address address;
   
       protected TestBean(Parcel in) {
           id = in.readInt();
           name = in.readString();
           score = new ArrayList<>();
           in.readList(score, Integer.class.getClassLoader());
           data = new ArrayList<>();
           in.readList(data, List.class.getClassLoader());
           address = in.readParcelable(Address.class.getClassLoader());
       }
   
       @Override
       public void writeToParcel(Parcel dest, int flags) {
           dest.writeInt(id);
           dest.writeString(name);
           dest.writeList(score);
           dest.writeList(data);
           dest.writeParcelable(address, flags);
       }
   
       @Override
       public int describeContents() {
           return 0;
       }
   
       public static final Creator CREATOR = new Creator() {
           @Override
           public TestBean createFromParcel(Parcel in) {
               return new TestBean(in);
           }
   
           @Override
           public TestBean[] newArray(int size) {
               return new TestBean[size];
           }
       };
   
       public static class Address implements Parcelable{
           public String city;
           public String road;
   
           protected Address(Parcel in) {
               city = in.readString();
               road = in.readString();
           }
   
           public static final Creator
    CREATOR = new Creator
   () {
               @Override
               public Address createFromParcel(Parcel in) {
                   return new Address(in);
               }
   
               @Override
               public Address[] newArray(int size) {
                   return new Address[size];
               }
           };
   
           @Override
           public int describeContents() {
               return 0;
           }
   
           @Override
           public void writeToParcel(@NonNull Parcel parcel, int i) {
               parcel.writeString(city);
               parcel.writeString(road);
           }
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84

在上述代码中，TestBean类实现了Parcelable接口，并将其成员变量都包含在序列化过程中。
在构造函数protected TestBean(Parcel in)中，通过readInt()、readString()和readParcelable()等方法逐个读取传入的Parcel对象中的数据，并将它们赋值给类的成员变量。
在writeToParcel(Parcel dest, int flags)方法中，通过writeInt()、writeString()和writeParcelable()等方法将类的成员变量写入传入的Parcel对象中。
最后，通过静态的CREATOR对象实现了createFromParcel(Parcel in)和newArray(int size)方法，用于创建TestBean对象的实例和数组。