1、概述
对象序列化化后可以传递自定义对象数据，序列化的目的是将对象数据转换成字节流的形式。但是序列与反序列化仅处理Java变量而不处理方法，序列与反序列化仅对数据进行处理。
实现方法：
- 实现Serializable接口（JDK提供的接口）
- 实现Parcelable（AndroidSDK提供的接口，优先使用）
二者区别：
- 在内存的使用中,实现Parcelable接口在性能方面要强于实现Serializable接口。
- 前者在序列化操作的时候会产生大量的临时变量,(原因是使用了反射机制)从而导致GC的频繁调用。
- Parcelable是以Ibinder作为信息载体的.在内存上的开销比较小,因此在内存之间进行数据传递的时候,Android推荐使用Parcelable,既然是内存方面比价有优势,那么自然就要优先选择。
在读写数据的时候,Parcelable是在内存中直接进行读写,而Serializable是通过使用IO流的形式将数据读写入在硬盘上。
但是：虽然Parcelable的性能要强于Serializable，但是仍然有特殊的情况需要使用Serializable，而不去使用Parcelable，因为Parcelable无法将数据进行持久化，因此在将数据保存在磁盘的时候，仍然需要使用后者,因为前者无法很好的将数据进行持久化。
以上内容copy于某大神文章，但由于时间久远已忘记原出处，此处感谢原作者的分享,谢谢。
2、实现Serializable接口
User.java
/**
* Created by magic on 2016年10月20日. 类通过实现 java.io.Serializable
* 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有
* 子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
*/
public class User implements Serializable {
// 该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类
private static final long serialVersionUID = 1L;
String name;
int age;
public User(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}API中是这样描述的类通过实现Serializable接口以启用其序列化功能。启用了就一定会用吗？答案是否定的，序列化操作是基于网络或者管道进行传输的时候序列化才会用到，就是把User对象通过Socket、Http等方式进行传递；或者将User对象保存到本地文件才会执行序列化操作，而通过反序列化又可以将其映射成为User对象。（其实刚开始，我一直以为实现了Serializable接口的类对象在初始化的时候就会执行序列化操作，但是，无奈一直找不到本地持久化的二进制对象文件，原来是理解错误）
Serializable在Android中的应用：
// Activity
User user = new User("Magic-帅帅", 21);
Intent intent = new Intent(this, MainActivity.class);
intent.putExtra("NAME", user);
startActivity(intent);
// 获取
User user2 = (User) getIntent().getSerializableExtra("NAME");
System.out.println("user2=" + user2.toString());
// User [name=Magic-帅帅, age=21]
// Fragment
Fragment fragment = new Fragment();
Bundle bundle = new Bundle();
bundle.putSerializable("NAME", user);
fragment.setArguments(bundle);
// 获取
User user3 = (User) fragment.getArguments().getSerializable("NAME");
System.out.println("user3=" + user3.toString());
// User [name=Magic-帅帅, age=21] 以上代码大家肯定不陌生，当Activity或者Fragment之间传递自定义对象的时候都会对该对象实现Serializable或者Parcelable接口，上面说了对象初始化不会对可序列化对象执行序列化操作，那是不是在putExtra()、putSerializable()方法中执行了序列化操作呢？追踪源码到ArrayMap的put(K key, V value)方法中并未发现序列化操作。也就是说以上的使用并未进行序列化操作。其实是由于同在一个虚拟机之中。
ArrayMap put(K key, V value)源码如下：
@Override
public V put(K key, V value) {
final int hash;
int index;
if (key == null) {
hash = 0;
index = indexOfNull();
} else {
hash = key.hashCode();
index = indexOf(key, hash);
}
if (index >= 0) {
index = (index<<1) + 1;
final V old = (V)mArray[index];
mArray[index] = value;
return old;
}
index = ~index;
if (mSize >= mHashes.length) {
final int n = mSize >= (BASE_SIZE*2) ? (mSize+(mSize>>1))
: (mSize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);
if (DEBUG) Log.d(TAG, "put: grow from " + mHashes.length + " to " + n);
final int[] ohashes = mHashes;
final Object[] oarray = mArray;
allocArrays(n);
if (mHashes.length > 0) {
if (DEBUG) Log.d(TAG, "put: copy 0-" + mSize + " to 0");
System.arraycopy(ohashes, 0, mHashes, 0, ohashes.length);
System.arraycopy(oarray, 0, mArray, 0, oarray.length);
}
freeArrays(ohashes, oarray, mSize);
}
if (index < mSize) {
if (DEBUG) Log.d(TAG, "put: move " + index + "-" + (mSize-index)
+ " to " + (index+1));
System.arraycopy(mHashes, index, mHashes, index + 1, mSize - index);
System.arraycopy(mArray, index << 1, mArray, (index + 1) << 1, (mSize - index) << 1);
}
mHashes[index] = hash;
mArray[index<<1] = key;
mArray[(index<<1)+1] = value;
mSize++;
return null;
}那么如何在本地持久化一个对象呢？
jdk为为我们提供了
- ObjectOutputStream 序列化
- ObjectInputStream 反序列化
User user = new User("Magic-帅帅", 21);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"User.serializable"));
oos.writeObject(user);
oos.flush();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"User.serializable"));
User user2 = (com.magic.test.User) ois.readObject();
System.out.println(user2.toString());
// User [name=Magic-帅帅, age=21]
oos.close();
ois.close();刷新项目，项目下会有一个User.serializable文件，文件内容如下：
总结.
3、实现Parcelable接口
基本步骤：
- 列表内容
- 列表内容
- 实现Parcelable接口
- 添加实体属性
- 覆写writeToParcel(Parcel dest, int flags)方法，指定写入Parcel类的数据。
- 创建Parcelable.Creator静态对象，有两个方法createFromParcel(Parcel in)与newArray(int size)，前者指定如何从Parcel中读取出数据对象，后者创建一个数组。
覆写describeContents方法，默认返回0。
User2.java
/**
* Created by magic on 2016年10月20日.
*/
public class User2 implements Parcelable {
String name;
int age;
boolean isBoy;
User user;
List<User> list;
String[] strs;
public User2(String name, int age, boolean isBoy, User user,
List<User> list, String[] strs) {
super();
this.name = name;
this.age = age;
this.isBoy = isBoy;
this.user = user;
this.list = list;
this.strs = strs;
}
@Override
public int describeContents() {
// 内容接口描述，默认返回0就可以
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
// 将类的数据写入外部提供的Parcel中
dest.writeString(name);
dest.writeInt(age);
dest.writeInt(isBoy ? 1 : 0);
dest.writeSerializable(user);
dest.writeList(list);
// 数组写入
if (strs != null) {
dest.writeInt(strs.length);
} else {
dest.writeInt(0);
}
dest.writeStringArray(strs);
}
//该类的命名固定不能改变
public static final Parcelable.Creator<User2> CREATOR = new Creator<User2>() {
@Override
public User2[] newArray(int size) {
return new User2[size];
}
@Override
public User2 createFromParcel(Parcel source) {
// 从Parcel容器中读取传递数据值，封装成Parcelable对象返回
String name=source.readString();
int age=source.readInt();
boolean isBoy=(source.readInt()==1?true:false);
User user=(User) source.readSerializable();
List<User> list=source.readArrayList(new ClassLoader() {});
String[] strs = new String[source.readInt()];
source.readStringArray(strs);
return new User2(name, age, isBoy, user, list, strs);
}
};
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isBoy() {
return isBoy;
}
public void setBoy(boolean isBoy) {
this.isBoy = isBoy;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public List<User> getList() {
return list;
}
public void setList(List<User> list) {
this.list = list;
}
public String[] getStrs() {
return strs;
}
public void setStrs(String[] strs) {
this.strs = strs;
}
@Override
public String toString() {
return "User2 [name=" + name + ", age=" + age + ", isBoy=" + isBoy
+ ", user=" + user + ", list=" + list + ", strs="
+ Arrays.toString(strs) + "]";
}
}Parcelable在Android中的使用：
Intent intent = new Intent(this, TwoActivity.class);
User user = new User("Magic", 21);
List<User> list = new ArrayList<User>();
list.add(user);
String[] strs = new String[] { "A", "B", "C" };
User2 user2 = new User2("Magic", 21, true, user, list, strs);
intent.putExtra("KEY", user2);
startActivity(intent);
// 获取
User2 u = getIntent().getExtras().getParcelable("KEY");
System.out.println(u.toString());
// User2 [name=Magic, age=21, isBoy=true,user=com.magic.test_test.User@4180a228,list=[com.magic.test_test.User@4180b090], strs=[A, B, C]]
//...4、参考
http://blog.csdn.net/androiddevelop/article/details/22108843
感觉自己的理解有很多问题，恳请大神指正，谢谢~~~
不成人才，必成人渣！
作者：MAGIC_JSS 发表于2016/10/21 11:28:02 原文链接
阅读：114 评论：0 查看评论