在Android中经过Intent使用Bundle传递对象

被传递的对象须要先实现序列化，而序列化对象有两种方式：java.io.Serializable和android.os.Parcelable

Java中使用的是Serializable，而谷歌在Android使用了自定义的Parcelable。
两种序列化方式的区别：
1.在使用内存的时候，Parcelable比Serializable性能高，推荐使用Parcelable类；
2.Serializable在序列化的时候会产生大量的临时变量，从而引发频繁的GC；
3.Parcelable不能使用在要将数据存储在磁盘上的状况，由于Parcelable不能很好的保证数据的持续性在外界有变化的状况下，这种状况建议使用Serializable。

第一步：定义序列化实体类；

Serializable方式：

[java] view plaincopy

1.  /** 

2.   * PersonSer 

3.   *  

4.   * @author http://blog.csdn.net/zuolongsnail 

5.   */  

6.  public class PersonSer implements Serializable {  

7.    

8.      /** 

9.       * serialVersionUID的做用是在修改实体类后，能够正常的序列化和反序列化，在此很少说，你们能够谷歌百度下。 

10.      */  

11.     private static final long serialVersionUID = -7620435178023928252L;  

12.   

13.     private String name;  

14.   

15.     private int age;  

16.   

17.     public String getName() {  

18.         return name;  

19.     }  

20.   

21.     public void setName(String name) {  

22.         this.name = name;  

23.     }  

24.   

25.     public int getAge() {  

26.         return age;  

27.     }  

28.   

29.     public void setAge(int age) {  

30.         this.age = age;  

31.     }  

32.   

33. }  

Parcelable方式：

[java] view plaincopy

1.  /** 

2.   * PersonPar 

3.   *  

4.   * @author http://blog.csdn.net/zuolongsnail 

5.   */  

6.  public class PersonPar implements Parcelable {  

7.    

8.      private String name;  

9.    

10.     private int age;  

11.   

12.     public String getName() {  

13.         return name;  

14.     }  

15.   

16.     public void setName(String name) {  

17.         this.name = name;  

18.     }  

19.   

20.     public int getAge() {  

21.         return age;  

22.     }  

23.   

24.     public void setAge(int age) {  

25.         this.age = age;  

26.     }  

27.   

28.     /** 

29.      * 序列化实体类 

30.      */  

31.     public static final Parcelable.Creator<PersonPar> CREATOR = new Creator<PersonPar>() {  

32.         public PersonPar createFromParcel(Parcel source) {  

33.             PersonPar personPar = new PersonPar();  

34.             personPar.name = source.readString();  

35.             personPar.age = source.readInt();  

36.             return personPar;  

37.         }  

38.   

39.         public PersonPar[] newArray(int size) {  

40.             return new PersonPar[size];  

41.         }  

42.     };  

43.   

44.     @Override  

45.     public int describeContents() {  

46.         return 0;  

47.     }  

48.   

49.     /** 

50.      * 将实体类数据写入Parcel 

51.      */  

52.     @Override  

53.     public void writeToParcel(Parcel parcel, int flags) {  

54.         parcel.writeString(name);  

55.         parcel.writeInt(age);  

56.     }  

57.   

58. }  

第二步：传递序列化对象；

[java] view plaincopy

1.  Intent intent = new Intent(MainActivity.this, DestActivity.class);  

2.  Bundle bundle = new Bundle();  

3.  switch (v.getId()) {  

4.  case R.id.serializable_btn:  

5.      // Serializable传递对象  

6.      PersonSer personSer = new PersonSer();  

7.      personSer.setName("zuolong");  

8.      personSer.setAge(26);  

9.      bundle.putSerializable(SER_KEY, personSer);  

10.     intent.putExtra("type", SER_TYPE);  

11.     intent.putExtras(bundle);  

12.     startActivity(intent);  

13.     break;  

14. case R.id.parcelable_btn:  

15.     // Parcelable传递对象  

16.     PersonPar personPar = new PersonPar();  

17.     personPar.setName("snail");  

18.     personPar.setAge(27);  

19.     // Bundle有putParcelableArray和putParcelableArrayList方法，也就能够传递数组和列表  

20.     bundle.putParcelable(PAR_KEY, personPar);  

21.     intent.putExtra("type", PAR_TYPE);  

22.     // Intent也有putParcelableArrayListExtra方法，能够传递实现Parcelable接口的对象列表  

23.     intent.putExtras(bundle);  

24.     startActivity(intent);  

25.     break;  

26. }  

第三步：获取对象；

[java] view plaincopy

1.  StringBuffer sb = new StringBuffer();  

2.  String type = getIntent().getStringExtra("type");  

3.  // 根据type判断是哪一种类型  

4.  if (type.equals(MainActivity.SER_TYPE)) {  

5.      // 获取Serializable对象  

6.      PersonSer personSer = (PersonSer) getIntent().getSerializableExtra(  

7.              MainActivity.SER_KEY);  

8.      sb.append("----From Serializable----").append("\n");  

9.      sb.append("Name:").append(personSer.getName()).append("\n");  

10.     sb.append("Age:").append(personSer.getAge()).append("\n");  

11. } else if (type.equals(MainActivity.PAR_TYPE)) {  

12.     // 获取Parcelable对象  

13.     PersonPar personPar = (PersonPar) getIntent().getParcelableExtra(  

14.             MainActivity.PAR_KEY);  

15.     sb.append("----From Parcelable----").append("\n");  

16.     sb.append("Name:").append(personPar.getName()).append("\n");  

17.     sb.append("Age:").append(personPar.getAge()).append("\n");  

18. }