android Parcelable 带有数组的对象如何序列化 String[] Long[] int[] Object[]

1. package com.example.demo_app.paracble;  
2.   
3. import android.os.Parcel;  
4. import android.os.Parcelable;  
5. import android.util.Log;  
6.   
7. public class Person implements Parcelable{  
8.   
9.     public String name ;  
10.     public int age ;  
11.     public String[] msg ;  
12.     public int garde ;  
13.     public Son son ;  
14.       
15.     @Override  
16.     public int describeContents() {  
17.         Log.v("Tag", " describeContents ");  
18.         return 0;  
19.     }  
20.       
21.     @Override  
22.     public void writeToParcel(Parcel dest, int flags) {  
23.         Log.v("Tag", this+" ------> writeToParcel "+flags);  
24.         //这里是把对象的字段一个一个写到流里面，写的顺序要和下面读的顺序一摸一样  
25.           
26.         dest.writeInt(age);  
27.         dest.writeString(name);  
28.           
29.         //这几句话是写数组的,因为数组的长度不确定，所以先确定数组长度，如果为空就不写，但是要把0 给发过去  
30.         //让下面的好判断能不能读数组，也就是说下面如果读到的长度是0，那么就不读数组了，否则就创建相同长度的数组去读  
31.         if(msg==null){  
32.             dest.writeInt(0);  
33.         }else{  
34.             dest.writeInt(msg.length);  
35.         }  
36.         //如果数组为空，就可以不写  
37.         if(msg!=null){  
38.             dest.writeStringArray(msg);  
39.         }  
40.           
41.           
42.         dest.writeInt(garde);  
43.         dest.writeParcelable(son, flags);  
44.     }  
45.       
46.     public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {  
47.           
48.         @Override  
49.         public Person[] newArray(int size) {  
50.             Log.w("Tag", " person new Array : "+size);  
51.             return new Person[size];  
52.         }  
53.           
54.         @Override  
55.         public Person createFromParcel(Parcel source) {  
56.             //开始读对象的流顺序要和上面写的一样  
57.             Log.w("Tag", " createFromParcel ");  
58.             int age = source.readInt();  
59.             String name = source.readString() ;  
60.               
61.             //开始读数组的长度   
62.             int length = source.readInt() ;  
63.             Log.v("Tag", " length : "+length);  
64.             String[] msg = null ;  
65.             //如果数组长度大于0，那么就读数组， 所有数组的操作都可以这样。  
66.             if(length>0){  
67.                 msg = new String[length];  
68.                 source.readStringArray(msg);  
69.             }  
70.               
71.             int grade = source.readInt() ;  
72.             Son son = source.readParcelable(Son.class.getClassLoader());  
73.             Log.i("Tag", " son : "+son);  
74.               
75.             Person p = new Person();  
76.             p.age = age ;  
77.             p.name = name ;  
78.             p.msg = msg ;  
79.             p.garde = grade ;  
80.             p.son = son ;  
81.             Log.d("Tag", p + " -- > name : "+p.name +" , age : "+p.age+" , garde : "+p.garde+" , son : "+p.son+" , msg : "+p.msg+" length : "+length);  
82.             return p ;  
83.         }  
84.     };  
85. }  

这个是普通的Parcelable对象

[java] view plaincopy

1. package com.example.demo_app.paracble;  
2.   
3. import android.os.Parcel;  
4. import android.os.Parcelable;  
5.   
6. public class Son implements Parcelable{  
7.   
8.     public String name ;  
9.       
10.     @Override  
11.     public int describeContents() {  
12.         return 0;  
13.     }  
14.   
15.     @Override  
16.     public void writeToParcel(Parcel dest, int flags) {  
17.         dest.writeString(name);  
18.     }  
19.       
20.     public static final Creator<Son> CREATOR = new Creator<Son>() {  
21.   
22.         @Override  
23.         public Son createFromParcel(Parcel source) {  
24.             Son s = new Son();  
25.             s.name = source.readString();  
26.             return s;  
27.         }  
28.   
29.         @Override  
30.         public Son[] newArray(int size) {  
31.             return new Son[size];  
32.         }  
33.           
34.     };  
35.   
36. }