&nbsp&#8250&nbsp&nbsp&#8250&nbsp
Android系统中Parcelable和Serializable的区别
转载，原文 ：&进行Android开发的时候，我们都知道不能将对象的引用传给Activities或者Fragments，我们需要将这些对象放到一个Intent或者Bundle里面，然后再传递。通过Android的API，我们知道有两种选择，即在传递对象时，需要对我们的对象进行&&或者化。作为Java开发者，相信大家对Serializable 机制有一定了解，那为什么还需要 Parcelable呢？为了回答这个问题，让我们分别来看看这两者的差异。Serializable, 简单易用//&access&modifiers,&accessors&and&constructors&omitted&for&brevity
public&class&SerializableDeveloper&implements&Serializable
&&&&String&
&&&&int&yearsOfE
&&&&List&Skill&&skillS
&&&&float&favoriteF
&&&&static&class&Skill&implements&Serializable&{
&&&&&&&&String&
&&&&&&&&boolean&programmingR
}serializable的迷人之处在于你只需要对某个类以及它的属性实现Serializable 接口即可。Serializable 接口是一种标识接口（），这意味着无需实现方法，Java便会对这个对象进行高效的序列化操作。这种方法的缺点是使用了反射，序列化的过程较慢。这种机制会在序列化的时候创建许多的临时对象，容易触发垃圾回收。Parcelable, 速度至上//&access&modifiers,&accessors&and&regular&constructors&ommited&for&brevity
class&ParcelableDeveloper&implements&Parcelable&{
&&&&String&
&&&&int&yearsOfE
&&&&List&Skill&&skillS
&&&&float&favoriteF
&&&&ParcelableDeveloper(Parcel&in)&{
&&&&&&&&this.name&=&in.readString();
&&&&&&&&this.yearsOfExperience&=&in.readInt();
&&&&&&&&this.skillSet&=&new&ArrayList&Skill&();
&&&&&&&&in.readTypedList(skillSet,&Skill.CREATOR);
&&&&&&&&this.favoriteFloat&=&in.readFloat();
&&&&void&writeToParcel(Parcel&dest,&int&flags)&{
&&&&&&&&dest.writeString(name);
&&&&&&&&dest.writeInt(yearsOfExperience);
&&&&&&&&dest.writeTypedList(skillSet);
&&&&&&&&dest.writeFloat(favoriteFloat);
&&&&int&describeContents()&{
&&&&&&&&return&0;
&&&&static&final&Parcelable.Creator&ParcelableDeveloper&&CREATOR
&&&&&&&&&&&&=&new&Parcelable.Creator&ParcelableDeveloper&()&{
&&&&&&&&ParcelableDeveloper&createFromParcel(Parcel&in)&{
&&&&&&&&&&&&return&new&ParcelableDeveloper(in);
&&&&&&&&ParcelableDeveloper[]&newArray(int&size)&{
&&&&&&&&&&&&return&new&ParcelableDeveloper[size];
&&&&static&class&Skill&implements&Parcelable&{
&&&&&&&&String&
&&&&&&&&boolean&programmingR
&&&&&&&&Skill(Parcel&in)&{
&&&&&&&&&&&&this.name&=&in.readString();
&&&&&&&&&&&&this.programmingRelated&=&(in.readInt()&==&1);
&&&&&&&&@Override
&&&&&&&&void&writeToParcel(Parcel&dest,&int&flags)&{
&&&&&&&&&&&&dest.writeString(name);
&&&&&&&&&&&&dest.writeInt(programmingRelated&?&1&:&0);
&&&&&&&&static&final&Parcelable.Creator&Skill&&CREATOR
&&&&&&&&&&&&=&new&Parcelable.Creator&Skill&()&{
&&&&&&&&&&&&Skill&createFromParcel(Parcel&in)&{
&&&&&&&&&&&&&&&&return&new&Skill(in);
&&&&&&&&&&&&}
&&&&&&&&&&&&Skill[]&newArray(int&size)&{
&&&&&&&&&&&&&&&&return&new&Skill[size];
&&&&&&&&&&&&}
&&&&&&&&};
&&&&&&&&@Override
&&&&&&&&int&describeContents()&{
&&&&&&&&&&&&return&0;
}根据&的说法，这些代码将会运行地特别快。原因之一就是我们已经清楚地知道了序列化的过程，而不需要使用反射来推断。同时为了更快地进行序列化，对象的代码也需要高度优化。因此，很明显实现Parcelable并不容易。实现Parcelable接口需要写大量的模板代码，这使得对象代码变得难以阅读和维护。速度测试当然，我们还是想知道到底Parcelable相对于Serializable要快多少。测试方法通过将一个对象放到一个bundle里面然后调用方法来模拟传递对象给一个activity的过程，然后再把这个对象取出来。在一个循环里面运行1000 次。两种方法分别运行10次来减少内存整理，cpu被其他应用占用等情况的干扰。参与测试的对象就是上面代码中的SerializableDeveloper 和 ParcelableDeveloper。在多种Android软硬件环境上进行测试LG Nexus 4 C Android 4.2.2Samsung Nexus 10 C Android 4.2.2HTC Desire Z C Android 2.3.3结果parcelable-vs-serializableNexus 10Serializable: 1.0004ms, &Parcelable: 0.0850ms C 提升10.16倍。Nexus 4Serializable: 1.8539ms C Parcelable: 0.1824ms C 提升11.80倍。Desire ZSerializable: 5.1224ms C Parcelable: 0.2938ms C 提升17.36倍。由此可以得出: Parcelable 比 Serializable快了10多倍。有趣的是，即使在Nexus 10这样性能强悍的硬件上，一个相当简单的对象的序列化和反序列化的过程要花将近一毫秒。总结如果你想成为一个优秀的软件工程师，你需要多花点时间来实现&&，因为这将会为你对象的序列化过程快10多倍，而且占用较少的资源。但是大多数情况下，&&的龟速不会太引人注目。你想偷点懒就用它吧，不过要记得serialization是一个比较耗资源的操作，尽量少使用。如果你想要传递一个包含许多对象的列表，那么整个序列化的过程的时间开销可能会超过一秒，这会让屏幕转向的时候变得很卡顿。&本文翻译自：
上一篇： 本文为转载，原译文的标题是 为什么不能往Android的Application对象里存储数据 ，之所以去掉了“不能往”是因为在读完之后，发现作者因为这种做法可能会导致的问题而全面否定它，事实上，我认为还是可以往Application对象里存储数据的。只是需要考虑周全。
下一篇： 几个月前（这篇文章的日期是2014 年11月10日），google发布了app和web应用的Material Design设计准则之后，设计师Emmanuel Pacamalan在youtube上发布了一则概念视频，演示了Instagram如果做成Material风格会是什么样子： 这仅仅是停留在图像上的设计，是美好学习内容：
1.序列化的目的
2.Android中序列化的两种方式
3.Parcelable与Serializable的性能比较
4.Android中如何使用Parcelable进行序列化操作
5.Parcelable的工作原理
6.相关实例
1.序列化的目的
& （1）.永久的保存对象数据(将对象数据保存在文件当中,或者是磁盘中
& （2）.通过序列化操作将对象数据在网络上进行传输(由于网络传输是以字节流的方式对数据进行传输的.因此序列化的目的是将对象数据转换成字节流的形式)
& （3）.将对象数据在进程之间进行传递(Activity之间传递对象数据时,需要在当前的Activity中对对象数据进行序列化操作.在另一个Activity中需要进行反序列化操作讲数据取出)
& （4）.Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长（即每个对象都在JVM中）但在现实应用中，就可能要停止JVM运行，但有要保存某些指定的对象，并在将来重新读取被保存的对象。这是Java对象序列化就能够实现该功能。（可选择入数据库、或文件的形式保存）
& （5）.序列化对象的时候只是针对变量进行序列化,不针对方法进行序列化.
& （6）.在Intent之间,基本的数据类型直接进行相关传递即可,但是一旦数据类型比较复杂的时候,就需要进行序列化操作了.
2.Android中实现序列化的两种方式（1）.Implements Serializable 接口 (声明一下即可)Serializable 的简单实例：
public class Person implements Serializable{
private static final long serialVersionUID = -0464481L;
private int
public String getName(){
public void setName(String name){
this.name =
public int getAge(){
public void setAge(int age){
this.age =
（2）.Implements Parcelable 接口(不仅仅需要声明,还需要实现内部的相应方法)Parcelable的简单实例:
注：写入数据的顺序和读出数据的顺序必须是相同的.
public class Book implements Parcelable{
private String bookN
private int publishD
public Book(){
public String getBookName(){
return bookN
public void setBookName(String bookName){
this.bookName = bookN
public String getAuthor(){
public void setAuthor(String author){
this.author =
public int getPublishDate(){
return publishD
public void setPublishDate(int publishDate){
this.publishDate = publishD
public int describeContents(){
public void writeToParcel(Parcel out, int flags){
out.writeString(bookName);
out.writeString(author);
out.writeInt(publishDate);
public static final Parcelable.Creator&Book& CREATOR = new Creator&Book&(){
　　　　 @Override
public Book[] newArray(int size){
return new Book[size];
public Book createFromParcel(Parcel in){
return new Book(in);
public Book(Parcel in){
//如果元素数据是list类型的时候需要： lits = new ArrayList&?& in.readList(list);
//否则会出现空指针异常.并且读出和写入的数据类型必须相同.如果不想对部分关键字进行序列化,可以使用transient关键字来修饰以及static修饰.
bookName = in.readString();
author = in.readString();
publishDate = in.readInt();
我们知道在Java应用程序当中对类进行序列化操作只需要实现Serializable接口就可以,由系统来完成序列化和反序列化操作,但是在Android中序列化操作有另外一种方式来完成,那就是实现Parcelable接口.也是Android中特有的接口来实现类的序列化操作.原因是Parcelable的性能要强于Serializable.因此在绝大多数的情况下,Android还是推荐使用Parcelable来完成对类的序列化操作的.
3.Parcelable与Serializable的性能比较
首先Parcelable的性能要强于Serializable的原因我需要简单的阐述一下
& 1）. 在内存的使用中,前者在性能方面要强于后者
& 2）. 后者在序列化操作的时候会产生大量的临时变量,(原因是使用了反射机制)从而导致GC的频繁调用,因此在性能上会稍微逊色
& 3）. Parcelable是以Ibinder作为信息载体的.在内存上的开销比较小,因此在内存之间进行数据传递的时候,Android推荐使用Parcelable,既然是内存方面比价有优势,那么自然就要优先选择.
& 4）. 在读写数据的时候,Parcelable是在内存中直接进行读写,而Serializable是通过使用IO流的形式将数据读写入在硬盘上.
& 但是：虽然Parcelable的性能要强于Serializable,但是仍然有特殊的情况需要使用Serializable,而不去使用Parcelable,因为Parcelable无法将数据进行持久化,因此在将数据保存在磁盘的时候,仍然需要使用后者,因为前者无法很好的将数据进行持久化.(原因是在不同的Android版本当中,Parcelable可能会不同,因此数据的持久化方面仍然是使用Serializable)
& 速度测试：
& 测试方法：
1）、通过将一个对象放到一个bundle里面然后调用Bundle#writeToParcel(Parcel, int)方法来模拟传递对象给一个activity的过程，然后再把这个对象取出来。
2）、在一个循环里面运行1000 次。
3）、两种方法分别运行10次来减少内存整理，cpu被其他应用占用等情况的干扰。
4）、参与测试的对象就是上面的相关代码
5）、在多种Android软硬件环境上进行测试
LG Nexus 4 & Android 4.2.2
Samsung Nexus 10 & Android 4.2.2
HTC Desire Z & Android 2.3.3&
&结果如图：
性能差异：
Serializable: 1.0004ms,& Parcelable: 0.0850ms & 提升10.16倍。
Serializable: 1.8539ms & Parcelable: 0.1824ms & 提升11.80倍。
Serializable: 5.1224ms & Parcelable: 0.2938ms & 提升17.36倍。
由此可以得出: Parcelable 比 Serializable快了10多倍。
& 从相对的比较我们可以看出,Parcelable的性能要比Serializable要优秀的多,因此在Android中进行序列化操作的时候,我们需要尽可能的选择前者,需要花上大量的时间去实现Parcelable接口中的内部方法.
4.Android中如何使用Parcelable进行序列化操作
说了这么多,我们还是来看看Android中如何去使用Parcelable实现类的序列化操作吧.&Implements Parcelable的时候需要实现内部的方法：
1）.writeToParcel 将对象数据序列化成一个Parcel对象(序列化之后成为Parcel对象.以便Parcel容器取出数据)
2）.重写describeContents方法,默认值为0
3）.Public static final Parcelable.Creator&T&CREATOR (将Parcel容器中的数据转换成对象数据) 同时需要实现两个方法:　　3.1 CreateFromParcel(从Parcel容器中取出数据并进行转换.)&　　3.2 newArray(int size)返回对象数据的大小
&因此，很明显实现Parcelable并不容易。实现Parcelable接口需要写大量的模板代码，这使得对象代码变得难以阅读和维护。具体的实例就是上面Parcelable的实例代码.就不进行列举了.(有兴趣的可以去看看Android中NetWorkInfo的源代码,是关于网络连接额外信息的一个相关类,内部就实现了序列化操作.大家可以去看看)
5.Parcelable的工作原理
&无论是对数据的读还是写都需要使用Parcel作为中间层将数据进行传递.Parcel涉及到的东西就是与C++底层有关了.都是使用JNI.在Java应用层是先创建Parcel(Java)对象,然后再调用相关的读写操作的时候.就拿读写32为Int数据来说吧：
static jint android_os_Parcel_readInt(JNIEnv* env, jobject clazz){
Parcel* parcel = parcelForJavaObject(env, clazz);
if (parcel != NULL) {
return parcel-&readInt32();
调用的方法就是这个过程,首先是将Parcel(Java)对象转换成Parcel(C++)对象,然后被封装在Parcel中的相关数据由C++底层来完成数据的序列化操作.
status_t Parcel::writeInt32(int32_t val){
return writeAligned(val);
template&class t=""&
status_t Parcel::writeAligned(T val) {
COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));
if ((mDataPos+sizeof(val)) &= mDataCapacity) {
restart_write:
*reinterpret_cast&t*&(mData+mDataPos) =
return finishWrite(sizeof(val));
status_t err = growData(sizeof(val));
if (err == NO_ERROR) goto restart_
真正的读写过程是由下面的源代码来完成的.
status_t Parcel::continueWrite(size_t desired)
// If shrinking, first adjust for any objects that appear
// after the new data size.
size_t objectsSize = mObjectsS
if (desired & mDataSize) {
if (desired == 0) {
objectsSize = 0;
while (objectsSize & 0) {
if (mObjects[objectsSize-1] & desired)
objectsSize--;
if (mOwner) {
// If the size is going to zero, just release the owner's data.
if (desired == 0) {
freeData();
return NO_ERROR;
// If there is a different owner, we need to take
// posession.
uint8_t* data = (uint8_t*)malloc(desired);
if (!data) {
mError = NO_MEMORY;
return NO_MEMORY;
size_t* objects = NULL;
if (objectsSize) {
objects = (size_t*)malloc(objectsSize*sizeof(size_t));
if (!objects) {
mError = NO_MEMORY;
return NO_MEMORY;
// Little hack to only acquire references on objects
// we will be keeping.
size_t oldObjectsSize = mObjectsS
mObjectsSize = objectsS
acquireObjects();
mObjectsSize = oldObjectsS
if (mData) {
memcpy(data, mData, mDataSize & desired ? mDataSize : desired);
if (objects && mObjects) {
memcpy(objects, mObjects, objectsSize*sizeof(size_t));
//ALOGI("Freeing data ref of %p (pid=%d)\n", this, getpid());
mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);
mOwner = NULL;
mObjects =
mDataSize = (mDataSize & desired) ? mDataSize :
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
mDataCapacity =
mObjectsSize = mObjectsCapacity = objectsS
mNextObjectHint = 0;
} else if (mData) {
if (objectsSize & mObjectsSize) {
// Need to release refs on any objects we are dropping.
const sp&ProcessState& proc(ProcessState::self());
for (size_t i=objectsS i&mObjectsS i++) {
const flat_binder_object* flat
= reinterpret_cast&flat_binder_object*&(mData+mObjects[i]);
if (flat-&type == BINDER_TYPE_FD) {
// will need to rescan because we may have lopped off the only FDs
mFdsKnown = false;
release_object(proc, *flat, this);
size_t* objects =
(size_t*)realloc(mObjects, objectsSize*sizeof(size_t));
if (objects) {
mObjects =
mObjectsSize = objectsS
mNextObjectHint = 0;
// We own the data, so we can just do a realloc().
if (desired & mDataCapacity) {
uint8_t* data = (uint8_t*)realloc(mData, desired);
if (data) {
mDataCapacity =
} else if (desired & mDataCapacity) {
mError = NO_MEMORY;
return NO_MEMORY;
if (mDataSize & desired) {
mDataSize =
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
if (mDataPos & desired) {
mDataPos =
ALOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);
// This is the first data. Easy!
uint8_t* data = (uint8_t*)malloc(desired);
if (!data) {
mError = NO_MEMORY;
return NO_MEMORY;
if(!(mDataCapacity == 0 && mObjects == NULL
&& mObjectsCapacity == 0)) {
ALOGE("continueWrite: %d/%p/%d/%d", mDataCapacity, mObjects, mObjectsCapacity, desired);
mDataSize = mDataPos = 0;
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
ALOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);
mDataCapacity =
return NO_ERROR;
1）.整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高很多
2）.读写时是4字节对齐的，可以看到#define PAD_SIZE(s) (((s)+3)&~3)这句宏定义就是在做这件事情
3）.如果预分配的空间不够时newSize = ((mDataSize+len)*3)/2;会一次多分配50%
4）.对于普通数据，使用的是mData内存地址，对于IBinder类型的数据以及FileDescriptor使用的是mObjects内存地址。后者是通过flatten_binder()和unflatten_binder()实现的，目的是反序列化时读出的对象就是原对象而不用重新new一个新对象。6.相关实例
最后上一个例子..
首先是序列化的类Book.class
public class Book implements Parcelable{
private String bookN
private int publishD
public Book(){
public String getBookName(){
return bookN
public void setBookName(String bookName){
this.bookName = bookN
public String getAuthor(){
public void setAuthor(String author){
this.author =
public int getPublishDate(){
return publishD
public void setPublishDate(int publishDate){
this.publishDate = publishD
public int describeContents(){
public void writeToParcel(Parcel out, int flags){
out.writeString(bookName);
out.writeString(author);
out.writeInt(publishDate);
public static final Parcelable.Creator&Book& CREATOR = new Creator&Book&(){
　　　　 @Override
public Book[] newArray(int size){
return new Book[size];
public Book createFromParcel(Parcel in){
return new Book(in);
public Book(Parcel in){
//如果元素数据是list类型的时候需要： lits = new ArrayList&?& in.readList(list); 否则会出现空指针异常.并且读出和写入的数据类型必须相同.如果不想对部分关键字进行序列化,可以使用transient关键字来修饰以及static修饰.
bookName = in.readString();
author = in.readString();
publishDate = in.readInt();
第一个Activity,MainActivity
Book book = new Book();
book.setBookname("Darker");
book.setBookauthor("me");
book.setPublishDate(20);
Bundle bundle = new Bundle();
bundle.putParcelable("book", book);
Intent intent = new Intent(MainActivity.this,AnotherActivity.class);
intent.putExtras(bundle);
第二个Activity,AnotherActivity
Intent intent = getIntent();
Bundle bun = intent.getExtras();
Book book = bun.getParcelable("book");
System.out.println(book);
总结：Java应用程序中有Serializable来实现序列化操作,Android中有Parcelable来实现序列化操作,相关的性能也作出了比较,因此在Android中除了对数据持久化的时候需要使用到Serializable来实现序列化操作,其他的时候我们仍然需要使用Parcelable来实现序列化操作,因为在Android中效率并不是最重要的,而是内存,通过比较Parcelable在效率和内存上都要优秀与Serializable,尽管Parcelable实现起来比较复杂,但是如果我们想要成为一名优秀的Android软件工程师,那么我们就需要勤快一些去实现Parcelable,而不是偷懒与实现Serializable.当然实现后者也不是不行,关键在于我们头脑中的那一份思想。
阅读(...) 评论()Android系统中Parcelable和Serializable的区别 - 为程序员服务
Android系统中Parcelable和Serializable的区别
进行Android开发的时候，我们都知道不能将对象的引用传给Activities或者Fragments，我们需要将这些对象放到一个Intent或者Bundle里面，然后再传递。
通过Android的API，我们知道有两种选择，即在传递对象时，需要对我们的对象进行
或者化。作为Java开发者，相信大家对Serializable 机制有一定了解，那为什么还需要 Parcelable呢？
为了回答这个问题，让我们分别来看看这两者的差异。
Serializable, 简单易用
// access modifiers, accessors and constructors omitted for brevity
public class SerializableDeveloper implements Serializable
int yearsOfE
List&Skill& skillS
float favoriteF
static class Skill implements Serializable {
boolean programmingR
}serializable的迷人之处在于你只需要对某个类以及它的属性实现Serializable 接口即可。Serializable 接口是一种标识接口（），这意味着无需实现方法，Java便会对这个对象进行高效的序列化操作。
这种方法的缺点是使用了反射，序列化的过程较慢。这种机制会在序列化的时候创建许多的临时对象，容易触发垃圾回收。
Parcelable, 速度至上
// access modifiers, accessors and regular constructors ommited for brevity
class ParcelableDeveloper implements Parcelable {
int yearsOfE
List&Skill& skillS
float favoriteF
ParcelableDeveloper(Parcel in) {
this.name = in.readString();
this.yearsOfExperience = in.readInt();
this.skillSet = new ArrayList&Skill&();
in.readTypedList(skillSet, Skill.CREATOR);
this.favoriteFloat = in.readFloat();
void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(yearsOfExperience);
dest.writeTypedList(skillSet);
dest.writeFloat(favoriteFloat);
int describeContents() {
static final Parcelable.Creator&ParcelableDeveloper& CREATOR
= new Parcelable.Creator&ParcelableDeveloper&() {
ParcelableDeveloper createFromParcel(Parcel in) {
return new ParcelableDeveloper(in);
ParcelableDeveloper[] newArray(int size) {
return new ParcelableDeveloper[size];
static class Skill implements Parcelable {
boolean programmingR
Skill(Parcel in) {
this.name = in.readString();
this.programmingRelated = (in.readInt() == 1);
void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(programmingRelated ? 1 : 0);
static final Parcelable.Creator&Skill& CREATOR
= new Parcelable.Creator&Skill&() {
Skill createFromParcel(Parcel in) {
return new Skill(in);
Skill[] newArray(int size) {
return new Skill[size];
int describeContents() {
根据 的说法，这些代码将会运行地特别快。原因之一就是我们已经清楚地知道了序列化的过程，而不需要使用反射来推断。同时为了更快地进行序列化，对象的代码也需要高度优化。
因此，很明显实现Parcelable并不容易。实现Parcelable接口需要写大量的模板代码，这使得对象代码变得难以阅读和维护。
当然，我们还是想知道到底Parcelable相对于Serializable要快多少。
通过将一个对象放到一个bundle里面然后调用方法来模拟传递对象给一个activity的过程，然后再把这个对象取出来。
在一个循环里面运行1000 次。
两种方法分别运行10次来减少内存整理，cpu被其他应用占用等情况的干扰。
参与测试的对象就是上面代码中的SerializableDeveloper 和 ParcelableDeveloper。
在多种Android软硬件环境上进行测试
LG Nexus 4 – Android 4.2.2
Samsung Nexus 10 – Android 4.2.2
HTC Desire Z – Android 2.3.3
parcelable-vs-serializable
Serializable: 1.0004ms,
Parcelable: 0.0850ms – 提升10.16倍。
Serializable: 1.8539ms – Parcelable: 0.1824ms – 提升11.80倍。
Serializable: 5.1224ms – Parcelable: 0.2938ms – 提升17.36倍。
由此可以得出: Parcelable 比 Serializable快了10多倍。有趣的是，即使在Nexus 10这样性能强悍的硬件上，一个相当简单的对象的序列化和反序列化的过程要花将近一毫秒。
如果你想成为一个优秀的软件工程师，你需要多花点时间来实现
，因为这将会为你对象的序列化过程快10多倍，而且占用较少的资源。
但是大多数情况下，
的龟速不会太引人注目。你想偷点懒就用它吧，不过要记得serialization是一个比较耗资源的操作，尽量少使用。
如果你想要传递一个包含许多对象的列表，那么整个序列化的过程的时间开销可能会超过一秒，这会让屏幕转向的时候变得很卡顿。
本文翻译自：
本站点构建于之上。本文地址：
A Android fan‘s tech blog.
原文地址：, 感谢原作者分享。
您可能感兴趣的代码