java android serializable Interface

原文：点击打开链接

序列化详解2 ： 序列化详解

序列化原因

序列化的原因基本可以归纳为以下三种情况： 
1.永久性保存对象，保存对象的字节序列到本地文件中； 
2.对象在网络中传递； 
3.对象在IPC(Inter-Process Communication,进程间通信)；间传递。

序列化方法

在Android系统中关于序列化的方法一般有两种，分别是实现Serializable接口和Parcelable接口,其中Serializable接口是来自Java中的序列化接口，而Parcelable是Android自带的序列化接口。 
上述的两种序列化接口都有各自不同的优缺点，我们在实际使用时需根据不同情况而定。

比较

1.Serializable在序列化的时候会产生大量的临时变量（原因是使用了反射机制），从而引起频繁的GC，而相比之下Parcelable的性能更高(毕竟是Android自带的)，所以当在使用内存时(如：序列化对象在网络中传递对象或序列化在进程间传递对象)，更推荐使用Parcelable接口。 
2. 在内存的使用中,前者在性能方面要强于后者 
3.. Parcelable是以Ibinder作为信息载体的.在内存上的开销比较小,因此在内存之间进行数据传递的时候,Android推荐使用Parcelable,既然是内存方面比价有优势,那么自然就要优先选择. 
4.在读写数据的时候,Parcelable是在内存中直接进行读写,而Serializable是通过使用IO流的形式将数据读写入在硬盘上. 
但是：虽然Parcelable的性能要强于Serializable,但是仍然有特殊的情况需要使用Serializable,而不去使用Parcelable,因为Parcelable无法将数据进行持久化,因此在将数据保存在磁盘的时候,仍然需要使用后者,因为前者无法很好的将数据进行持久化.(原因是在不同的Android版本当中,Parcelable可能会不同,因此数据的持久化方面仍然是使用Serializable)

代码实现

Serializable接口的实现及使用

Serializable的接口实现很简单，只需让需要序列化的类继承Serializable 即可，系统会自动将其序列化，具体代码如下：

public class Book implements Serializable {
  private static final long serialVersionUID = 21455356667888L;
  private String mName;
  private String mPrice;
  public String getmName() {
    return mName;
  }
  public void setmName(String mName) {
    this.mName = mName;
  }
  public String getmPrice() {
    return mPrice;
  }
  public void setmPrice(String mPrice) {
    this.mPrice = mPrice;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在Activity中使用方法：

// serializable对象传递方法
public void setSerializableMethod() {
  Book book = new Book();
  book.setmName("王海康");
  book.setmPrice("20$");
  Intent intent = new Intent(this, BookTest.class);
  Bundle bundle = new Bundle();
  bundle.putSerializable(SER_KEY, book);
  intent.putExtras(bundle);
  startActivity(intent);
}
// serializable对象获取方法
public Book getSerializableMethod(){
  Book mBook = (Book )getIntent().getSerializableExtra(SER_KEY);
  return mBook;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Parcelable接口的实现及使用

实现Parcelable接口主要可以分为一下几步： 
1）implements Parcelable。 
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从Parcel容器获取数据。 
3）重写describeContents方法，内容接口描述，默认返回0即可。 
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator 。 
注意:若将Parcel看成是一个流，则先通过writeToParcel把对象写到流里面，再通过createFromParcel从流里读取对象，因此类实现的写入顺序和读出顺序必须一致。

具体实现代码如下：

public class Person implements Parcelable {
  private String mName;
  private String mSex;
  private int mAge;
  public String getmName() {
    return mName;
  }
  public void setmName(String mName) {
    this.mName = mName;
  }
  public String getmSex() {
    return mSex;
  }
  public void setmSex(String mSex) {
    this.mSex = mSex;
  }
  public int getmAge() {
    return mAge;
  }
  public void setmAge(int mAge) {
    this.mAge = mAge;
  }
  @Override
  public int describeContents() {
    return 0;
  }
  @Override
  public void writeToParcel(Parcel dest, int flags) {
    dest.writeString(mName);
    dest.writeString(mSex);
    dest.writeInt(mAge);
  }
  public static final Parcelable.Creator CREATOR = new Creator() {
    @Override
    public Person createFromParcel(Parcel source) {
      Person person = new Person();
      person.mName = source.readString();
      person.mSex = source.readString();
      person.mAge = source.readInt();
      return person;
    }

    //供反序列化本类数组时调用的
    @Override
    public Person[] newArray(int size) {
      return new Person[size];
    }
  };
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
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

在Activity中使用方法： 
1）传递单一对象,具体代码如下：

// parcelable对象传递方法
public void setParcelableMethod() {
  Person person = new Person();
  person.setmName("王海康");
  person.setmSex("男");
  person.setmAge(45);
  Intent intent = new Intent(this, PersonTest.class);
  Bundle bundle = new Bundle();
  bundle.putParcelable(PAR_KEY, person);
  intent.putExtras(bundle);
  startActivity(intent);
}
// parcelable对象获取方法
public Person getParcelableMethod(){
  Person mPerson = (Person)getIntent().getParcelableExtra(PAR_KEY);
  return mPerson;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2）传递对象列表,具体代码如下： 
需要注意的是，若List personList = new ArrayList();则会报错，因为下面调用的putParcelableArrayList()函数其中一个参数的类型为ArrayList。

// parcelable对象List传递方法
public void setParcelableListMethod() {
  ArrayList personList = new ArrayList();
  Person person1 = new Person();
  person1.setmName("王海康");
  person1.setmSex("男");
  person1.setmAge(45);
  personList.add(person1);
  Person person2 = new Person();
  person2.setmName("薛岳");
  person2.setmSex("男");
  person2.setmAge(15);
  personList.add(person2);
  Intent intent = new Intent(this, PersonTest.class);
  Bundle bundle = new Bundle();
  bundle.putParcelableArrayList(PAR_LIST_KEY, personList);
  intent.putExtras(bundle);
  startActivity(intent);
}

// parcelable对象获取方法
public ArrayList getParcelableMethod(){
  ArrayList mPersonList = getIntent().getParcelableExtra(PAR_LIST_KEY);
return mPersonList;
}
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
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

3）最后介绍一个投机取巧的方法： 
不用继承Parcelable或Serializable方法即可实现IPC中对象的传递。这种方法的实现原理不是很明白，只知道代码中new ArrayList()返回的其实是一个EmptyArray.OBJECT数组，不过我感觉应该还是系统调用Serializable进行序列化的，如果各位读者有好的想法，欢迎告知。 
具体代码如下：

//对象List传递
public void setObjectMethod(){
  ......（省略）
  ArrayList list = new ArrayList();
  //ObjectList为某一对象列表
  list.add(ObjectList);
  bundle.putParcelableArrayList(PAR_LIST_KEY, list);
  intent.putExtras(bundle);
  startActivity(intent);
}

//获取对象List
ArrayList list = bundle.getParcelableArrayList("list");
//强转成你自己定义的list，这样ObjectList就是你传过来的那个list了。
ObjectList= (List<Object>) list.get(0);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

总结

Java应用程序中有Serializable来实现序列化操作,Android中有Parcelable来实现序列化操作,相关的性能也作出了比较,因此在Android中除了对数据持久化的时候需要使用到Serializable来实现序列化操作,其他的时候我们仍然需要使用Parcelable来实现序列化操作,因为在Android中效率并不是最重要的,而是内存,通过比较Parcelable在效率和内存上都要优秀与Serializable,尽管Parcelable实现起来比较复杂,但是如果我们想要成为一名优秀的Android软件工程师,那么我们就需要勤快一些去实现Parcelable,而不是偷懒与实现Serializable. 
转载自：http://www.jb51.net/article/62626.htm