序列化：
将数据结构或对象转换成二进制的过程。
序列化的用途： 网络上，跨进程
序列化方案：json xml protobuf serializable（java） percelable（Android独有）....
持久化：
把数据结构或对象存储起来 硬盘
如何选择合理的序列化方案。
Serializable学习：
//里面没有任何方法，就是一个标志。
public interface Serializable { }public interface Externalizable extends java.io.Serializable {
? void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}案例一
/*
如果没有实现Serializable，执行就会报错
Caused by: java.io.NotSerializableException:
com.android.serializable.SerializableTest$User
*/
static class User { //定义非基本数据类型的对象，不实现序列化
private String mName;
private int mAge;
public User(String name, int age) {
mName = name;
mAge = age;
}
@Override
public String toString() {
return "User{" +
"mName='" + mName + '\'' +
", mAge=" + mAge +
'}';
}
}
//对它进行写出操作，path为磁盘路径
outputStream = new ObjectOutputStream(new FileOutputStream(path));
outputStream.writeObject(object);
//对它进行读入操作
inputStream = new ObjectInputStream(new FileInputStream(path));
return inputStream.readObject();在上面的案例可以看出当中就算user实现了Serializable接口，也要自己使用对象的IO流（ObjectOutput，ObjectInput ）辅助实现序列化。
static class User implements Externalizable {
private String mName;
private int mAge;
public User(){} //使用Externalizable 必要要有无参构造函数
public User(String name, int age) {
mName = name;
mAge = age;
}
@Override
public String toString() {
return "User{" +
"mName='" + mName + '\'' +
", mAge=" + mAge +
'}';
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
//方便指定哪些成员变量需要序列化，哪些成员变量不需要序列化
out.writeObject(mName);
out.writeInt(mAge);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
mName = (String) in.readObject();
mAge = in.readInt();
}
}
private static void externalizableTest(){
User user = new User("fw123",18);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = null;
byte[] userDate = null;
try {
objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(user);
userDate = byteArrayOutputStream.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new ByteArrayInputStream(userDate));
User object = (User) objectInputStream.readObject();
System.out.println("fw123 object: " + object);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
上面必须要注意的是：使用Externalizable 必须要有无参构造函数。
问题一?serialVersionUID的作用：
上面的两个案例都没有定义常量，可是可以进行正常完成的：
private static final long serialVersionUID = 7579060052569229166L;
既然没有serialVersionUID也没报错，那这个有什么作用吗？
1.作用将对象A进行序列化，2 .修改A，3.反序列化A。 如果有了serialVersionUID将不会报错。
问题二? 序列化时，你希望某些成员变量不需要序列化，你如何实现昵？
就是将这个变量定义为静态或者瞬态(trasient)变量。反序列化以后，被这个修饰的变量打印出来为null。我自己测试静态的变量是可以反序列化，这里有问题？？？
问题三， 如果类中的一个成员未实现可序列化接口，会发生什么？
运行时会报NotSerializableException异常。
问题四 如何自定义序列化过程，
在类中写下面两个函数就可以了。?
private void writeObject(ObjectOutputStream out) throws IOException{}
private void readObject(ObjectInputStream in) throws IOException{}如果父类可以序列化，那么它的子类也是可以序列化的。如果子类不想序列化，就可以复写上面的方法抛出异常就可以了。
Serializable源码分析：
首先：
ObjectOutputStream.java#writeObject(Object obj)
--->writeObject0(Object obj, boolean unshared)
--->} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);}
-->
if (desc.isExternalizable() && !desc.isProxy()) {
writeExternalData((Externalizable) obj);//是不是实现Externalizable
} else {
writeSerialData(obj, desc);
}
--writeString((String) obj, unshared);//一层一层往下走，直到最后的对象是基本数据类型
在writeSerialData中：
private void writeSerialData(Object obj, ObjectStreamClass desc)
{
if (slotDesc.hasWriteObjectMethod()) {//如果有自定义WriteObject函数，将走这里
slotDesc.invokeWriteObject(obj, this);
} else {
defaultWriteFields(obj, slotDesc);// 没有自定义WriteObject，将走这里
}
}
}
在使用为什么需要无参构造函数：
在ObjectInputStream#readObject()--》readObject0-》readOrdinaryObject(unshared)
---》
try {
obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
throw (IOException) new InvalidClassException(
desc.forClass().getName(),
"unable to create instance").initCause(ex);
}
1.反序列化后的对象，不需要调用构造函数重新构造。
2.序列化前后的对象是地址是不一样的，是深拷贝关系，但是枚举类型是一样。
3.Bundle的内部有变量mMap（ArrayMap<String, Object>）这个比Map的存储大小有优化，
4.