Android序列化Serializable与Parcelable的异同

Android开发,Serializable,Parcelable

两种都是用于支持序列化、反序列化话操作，两者最大的区别在于存储媒介的不同，Serializable使用IO读写存储在硬盘上，而Parcelable是直接在内存中读写，很明显内存的读写速度通常大于IO读写，所以在Android中通常优先选择Parcelable。

Serializable不是当前关注的焦点，不过可以查看《Java序列化算法透析》这篇文章中实现一个简单的Serializable例子，查看序列化生成的IO文件，并且以16进制读取并一一解释每一个16进制数字的含义。


1、作用

Serializable的作用是为了保存对象的属性到本地文件、数据库、网络流、rmi以方便数据传输，当然这种传输可以是程序内的也可以是两个程序间的。而Android的Parcelable的设计初衷是因为Serializable效率过慢，为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计，这些数据仅在内存中存在，Parcelable是通过IBinder通信的消息的载体。

从上面的设计上我们就可以看出优劣了。


2、效率及选择

Parcelable的性能比Serializable好，在内存开销方面较小，所以在内存间数据传输时推荐使用Parcelable，如activity间传输数据，而Serializable可将数据持久化方便保存，所以在需要保存或网络传输数据时选择Serializable，因为android不同版本Parcelable可能不同，所以不推荐使用Parcelable进行数据持久化
 

3、编程实现

对于Serializable，类只需要实现Serializable接口，并提供一个序列化版本id(serialVersionUID)即可。而Parcelable则需要实现writeToParcel、describeContents函数以及静态的CREATOR变量，实际上就是将如何打包和解包的工作自己来定义，而序列化的这些操作完全由底层实现。

Parcelable的一个实现例子如下

public class MyParcelable implements Parcelable {
     private int mData;
     private String mStr;

     public int describeContents() {
         return 0;
     }

     // 写数据进行保存
     public void writeToParcel(Parcel out, int flags) {
         out.writeInt(mData);
         out.writeString(mStr);
     }

     // 用来创建自定义的Parcelable的对象
     public static final Parcelable.Creator<MyParcelable> CREATOR
             = new Parcelable.Creator<MyParcelable>() {
         public MyParcelable createFromParcel(Parcel in) {
             return new MyParcelable(in);
         }

         public MyParcelable[] newArray(int size) {
             return new MyParcelable[size];
         }
     };
     
     // 读数据进行恢复
     private MyParcelable(Parcel in) {
         mData = in.readInt();
         mStr = in.readString();
     }
 }

从上面我们可以看出Parcel的写入和读出顺序是一致的。如果元素是list读出时需要先new一个ArrayList传入，否则会报空指针异常。如下：

list = new ArrayList<String>();
in.readStringList(list);

 PS: 在自己使用时，read数据时误将前面int数据当作long读出，结果后面的顺序错乱，报如下异常，当类字段较多时务必保持写入和读取的类型及顺序一致。

11-21 20:14:10.317: E/AndroidRuntime(21114): Caused by: java.lang.RuntimeException: Parcel android.os.Parcel@4126ed60: Unmarshalling unknown type code 3014773 at offset 164
 

4、高级功能上

Serializable序列化不保存静态变量，可以使用Transient关键字对部分字段不进行序列化，也可以覆盖writeObject、readObject方法以实现序列化过程自定义

为了优化Android应用的启动速度，我们在首次初始化时导入静态数据库到Android应用中。本文就来讲讲如何实现这个功能。

一个Android除了要有好的创意和美观的界面，性能也是很关键的部分，本文讨论的就是第一次启动的速度问题。 Android应用的启动过程不能让用户等待太长时间，个人觉得最好控制在3秒之内。一般来说，内容的初始化是影响Android应用第一次启动速度的主要因素之一，尤其是创建数据库并插入一定数量的初始记录，对于这种问题，最好的办法莫过于在首次初始化时导入静态数据库。

 在Android中导入静态数据库很简单，首先将准备好的静态数据库文件放到Android工程的res目录中的raw子目录下面，如果没有这个子目录的话就手动创建该目录，然后在应用的初始化阶段通过类似下面的代码将数据库文件拷贝到特定的目录下面，假设Android应用的包名是com.test，那么大部分情况下该应用默认的数据库文件位于/data/data/com.test/databases目录下面。


 String dbDirPath = "/data/data/com.test/databases";  

File dbDir = new File(dbDirPath);if(!dbDir.exists())

// 如果不存在该目录则创建    

dbDir.mkdir();

// 打开静态数据库文件的输入流  

InputStream is = context.getResources().openRawResource(R.raw.data);

// 打开目标数据库文件的输出流

FileOutputStream os = new FileOutputStream(dbDirPath+"/data.db");

byte[] buffer = newbyte[1024];

int count = 0;

// 将静态数据库文件拷贝到目的地

while ((count = is.read(buffer)) > 0) {  

os.write(buffer, 0, count);  

}

is.close();  

os.close();


以最近完成的一个应用来看，采用导入静态数据库的方式后，第一次启动时间从将近4秒变成了1秒，效果还是很明显的。  


不过，这种方式是假定所有Android设备的应用安装目录是相同的，而且数据库文件的目录都是/data/data/包名/databases，但是Android的文档中并没有明确规定所有设备具有此种目录结构，所以将静态数据库文件拷贝到一个事先定死的目录的做法还是有一定危险性的。更好的做法是使用Android系统提供的API去解决这个问题，总之，我们要避免的就是使用固定目录，下面是更好的拷贝过程：
复制代码

// 打开静态数据库文件的输入流  

InputStream is = context.getResources().openRawResource(R.raw.data);

// 通过Context类来打开目标数据库文件的输出流，这样可以避免将路径写死。  

FileOutputStream os = context.openFileInput("data.db");

byte[] buffer = newbyte[1024];

int count = 0;

// 将静态数据库文件拷贝到目的地

while ((count = is.read(buffer)) > 0) {  

 os.write(buffer, 0, count);

}

is.close();

os.close();

｝


最终的数据库文件将位于/data/data/com.data/files目录下，需要注意的是，使用Context类的openOrCreateDatabase方法或者SQLiteOpenHelper工具类时，不能再传递数据库的名称作为参数，而是要把数据库文件的全路经传递给它们。

java开发的Android应用，性能一直是一个大问题，，或许是Java语言本身比较消耗内存。本文我们来谈谈Android 性能优化之MemoryFile文件读写。

Android匿名共享内存对外Android系统的匿名共享内存子系统的主体是以驱动程序的形式实现在内核空间的，同时在应用程序框架层提供了Java调用接口。在Android应用程序框架层，提供了一个MemoryFile接口来封装了匿名共享内存文件的创建和使用，它实现在frameworks/base/core/java/android/os/MemoryFile.java

public MemoryFile(String name, int length) throws IOException {  
   mLength = length;  
   //打开"/dev/ashmem"设备文件  
   mFD = native_open(name, length);  
   if (length > 0) {  
       //将打开的"/dev/ashmem"设备文件映射到进程虚拟地址空间中  
       mAddress = native_mmap(mFD, length, PROT_READ | PROT_WRITE);  
   } else {  
       mAddress = 0;  
   }
}  

native_open函数是一个本地函数，通过JNI实现在C++层，代码位于frameworks\base\core\jni\android_os_MemoryFile.cpp

static jobject android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring name, jint length)  
{  
   //字符串转换  
   const char* namestr = (name ? env->GetStringUTFChars(name, NULL) : NULL);  
   //打开设备文件"/dev/ashmem"，并修改设备文件名称及共享内存大小  
   int result = ashmem_create_region(namestr, length);  
   if (name)  
       env->ReleaseStringUTFChars(name, namestr);  
   if (result < 0) {  
       jniThrowException(env, "java/io/IOException", "ashmem_create_region failed");  
       return NULL;  
   }  
   //设备文件句柄转换  
   return jniCreateFileDescriptor(env, result);  
}

函数首先将Java层传过来的你们共享内存名称转换为C++层的字符串，然后调用ashmem_create_region函数创建一个名为dev/ashmem/的匿名共享内存，并且修改该共享内存的名称及大小，然后将创建的匿名共享内存设备文件句柄值返回到Java空间中。函数ashmem_create_region在Android 匿名共享内存C接口分析中有详细分析，该接口函数就是用于创建一块匿名共享内存。

在Java空间构造MemoryFile对象时，首先打开/dev/ashmem设备文件并在内核空间创建一个ashmem_area，接着需要将内核空间分配的共享内存地址映射到进程虚拟地址空间中来，映射过程是通过native_mmap函数来完成的。


static jint android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jobject fileDescriptor,  
       jint length, jint prot)  
{  
   int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
   jint result = (jint)mmap(NULL, length, prot, MAP_SHARED, fd, 0);  
   if (!result)  
       jniThrowException(env, "java/io/IOException", "mmap failed");  
   return result;  
}  

该函数直接调用mmap来实现地址空间映射，注意标志位MAP_SHARED，表示该缓冲区以共享方式映射。映射过程是由Ashmem驱动来完成，Android 匿名共享内存驱动源码分析详细分析了Android匿名共享内存的实现过程。在构造MemoryFile对象时完成了匿名共享内存的创建及地址空间的映射过程，将创建的匿名共享内存的大小保存到MemoryFile的成员变量mLength中，成员变量mFD保存创建的匿名共享内存的文件描述符，成员变量mAddress保存匿名共享内存映射到进程地址空间的起始地址。有了这些信息后，就可以直接使用该匿名共享内存了。

匿名共享内存读

对匿名共享内存的读取操作，在Java空间被封装成MemoryInputStream来完成，该类继承于输入流InputStream，并对外提供了read方法，定义如下：

@Override  
public int read() throws IOException {  
   if (mSingleByte == null) {  
       mSingleByte = new byte[1];  
   }  
   int result = read(mSingleByte, 0, 1);  
   if (result != 1) {  
       return -1;  
   }  
   return mSingleByte[0];  
}  
@Override  
public int read(byte buffer[], int offset, int count) throws IOException {  
   if (offset < 0 || count < 0 || offset + count > buffer.length) {  
       // readBytes() also does this check, but we need to do it before  
       // changing count.  
       throw new IndexOutOfBoundsException();  
   }  
   count = Math.min(count, available());  
   if (count < 1) {  
       return -1;  
   }  
   int result = readBytes(buffer, mOffset, offset, count);  
   if (result > 0) {  
       mOffset += result;  
   }  
   return result;  
}  

MemoryInputStream类提供了两个read重载方法，第一个无参read方法调用有参read方法来读取1字节的数据，而有参read方法的数据读取过程是调用MemoryInputStream的外部类MemoryFile的readBytes方法来实现匿名共享内存数据的读取过程。

public int readBytes(byte[] buffer, int srcOffset, int destOffset, int count)  
       throws IOException {  
   if (isDeactivated()) {  
       throw new IOException("Can't read from deactivated memory file.");  
   }  
   if (destOffset < 0 || destOffset > buffer.length || count < 0  
           || count > buffer.length - destOffset  
           || srcOffset < 0 || srcOffset > mLength  
           || count > mLength - srcOffset) {  
       throw new IndexOutOfBoundsException();  
   }  
   return native_read(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);  
}  

该函数也仅仅作了一些判断，然后直接调用本地方法native_read在C++空间完成数据读取，在构造MemoryFile对象时，已经打开并映射了dev/ashmem设备文件，因此在这里直接将打开该设备文件得到的文件句柄值传到C++空间，以正确读取指定的匿名共享内存中的内容，mAddress为匿名共享内存映射到进程地址空间中的起始地址。

static jint android_os_MemoryFile_read(JNIEnv* env, jobject clazz,  
       jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset,  
       jint count, jboolean unpinned)  
{  
   int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
   if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {  
       ashmem_unpin_region(fd, 0, 0);  
       jniThrowException(env, "java/io/IOException", "ashmem region was purged");  
       return -1;  
   }  
   env->SetByteArrayRegion(buffer, destOffset, count, (const jbyte *)address + srcOffset);  
   if (unpinned) {  
       ashmem_unpin_region(fd, 0, 0);  
   }  
   return count;  
}  

匿名共享内存写

将指定数据写入到匿名共享内存中，对匿名共享内存的写操作使用MemoryOutputStream来封装，该类提供了两个重载的write方法，一个用于向匿名共享内存写入多字节数据，另一个则只写入一个字节数据。这里简单介绍多字节数据写入过程：

public void write(byte buffer[], int offset, int count) throws IOException {  
   writeBytes(buffer, offset, mOffset, count);  
   mOffset += count;  
}  
参数buffer是指写入匿名共享内存中的字节数组，offset指定数据buffer开始写的偏移量，参数count指定写入匿名共享内存的字节长度，函数调用MemoryFile的writeBytes函数来完成数据写入。

public void writeBytes(byte[] buffer, int srcOffset, int destOffset, int count)  
       throws IOException {  
   if (isDeactivated()) {  
       throw new IOException("Can't write to deactivated memory file.");  
   }  
   if (srcOffset < 0 || srcOffset > buffer.length || count < 0  
           || count > buffer.length - srcOffset  
           || destOffset < 0 || destOffset > mLength  
           || count > mLength - destOffset) {  
       throw new IndexOutOfBoundsException();  
   }  
   native_write(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);  
}  

该函数首先检验参数的正确性，然后调用native方法native_write通过JNI转入C++完成数据写入，第一个参数是匿名共享内存的文件描述符，第二个参数是匿名共享内存映射到进程地址空间的基地值，后面三个参数上面已经介绍了，最后一个参数mAllowPurging表示是否允许内存回收

描述了匿名共享内存的写入过程，本质上就是将buffer中指定位置开始的数据拷贝到匿名共享内存指定的偏移位置
frameworks\base\core\jni\android_os_MemoryFile.cpp

static jint android_os_MemoryFile_write(JNIEnv* env, jobject clazz,  
       jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset,  
       jint count, jboolean unpinned)  
{  
   int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
   if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {  
       ashmem_unpin_region(fd, 0, 0);  
       jniThrowException(env, "java/io/IOException", "ashmem region was purged");  
       return -1;  
   }  
   env->GetByteArrayRegion(buffer, srcOffset, count, (jbyte *)address + destOffset);  
   if (unpinned) {  
       ashmem_unpin_region(fd, 0, 0);  
   }  
   return count;  
}  

数据写入过程是通过JNI函数GetByteArrayRegion完成数据的拷贝操作。

MemoryFile主要的构造方法 MemoryFile(String name, int length) ，这里第二个参数为文件大小，需要说明的是Android的MemoryFile和传统的mmap还有一点点区别，毕竟是手机，它内部的内存管理方式ashmem会从内核中回收资源。毕竟目前部分低端机型的RAM也比较吃紧。

synchronized boolean  allowPurging(boolean allowPurging)  //允许ashmem清理内存，线程安全同步的方式。

void  close() //关闭，因为在Linux内部mmap占用一个句柄，不用时一定要释放了

InputStream  getInputStream()  返回读取的内容用Java层的InputStream保存

OutputStream  getOutputStream()  把一个OutputSream写入到MemoryFile中

boolean  isPurgingAllowed() //判断是否允许清理

int  length()  //返回内存映射文件大小

下面就是我们熟悉的，读写细节，主要是对字符数组的操作，这里大家要计算好每个文件类型的占用，同时考虑到效率对于自己分配的大小考虑粒度对齐。

int  readBytes(byte[] buffer, int srcOffset, int destOffset, int count)

void  writeBytes(byte[] buffer, int srcOffset, int destOffset, int count)


应用场合：对于I/O需要频繁操作的，主要是和外部存储相关的I/O操作，MemoryFile通过将 NAND或SD卡上的文件，分段映射到内存中进行修改处理，这样就用高速的RAM代替了ROM或SD卡，性能自然提高不少，对于Android手机而言同时还减少了电量消耗。

手机应用中交互表单经常会用到多选，本文我们来看看android应用开发中如何在ListVie中实现多选的办法。

必须自己实现baseAdapter吗？如果提供了多选的choice_mode，为什么会没有提供简单的实现呢。。

问题：

使用ListView实现多选，要求数据源使用List<T>，尝试使用SimpleAdapter配和自己定义的checkBox控件无法获得选中项，在非继承ListActivity的类中自己实现一个Adapter比较麻烦。

回答：

通过ArrayAdapter使用android.R.layout.simple_list_item_multiple_choice来实现多选必须有几个限制条件：
1.所在类必须继承ListActivity
2.必须使用内部定义的ListView的id，即ListView控件的id属性必须为 android:id=”@id/android:list”
（需要注意的是存在多个ListView需要使用@id/android:list，而非@+id/android:list或者@android:id/list）
3.ListView对象通过getListView()方法获得。

ps：
使用ArrayAdapter的simple_multiple_choice解决多选从成本上来说比较小，如果数据源是cursor的可能更方便一点，但是现在数据源是List<T>，从样式上来会比较固定，需要T类自己实现toString()方法控制输出文案。

下面来为各位介绍一个安卓4.4上实现透明导航栏和状态栏 Translucent system bar例子，希望本文章对各位会带来帮助．