首先介绍下三个序列化版本的基本情况，

1，Serializable是一般的序列化，这种序列化是一种接口，直接实现这个借口就可以，接口里面的所有属性都会被序列化

2，Externalizable 这个序列化接口是Serializable的之类，它不会调用默认的构造函数，而是调用自己的构造函数，这个序列化方式不仅仅需要实现这个接口而且需要自己在具体的方法里面添加需要序列化的属性。

3，Parcelable序列化，前两种序列化是在JavaEE中就已经存在了的，这种序列化是android特有的序列化方式，实现起来稍微复杂一点，但是相对而言，效率比之前的要高很多

4，为什么要序列化：我相信很多人跟我一样存在疑惑，为什么要序列化，有什么好处呢，我平时开发不序列化也行啊。其实序列化就是将对象给二进制化，保存下来，可以保存为txt格式的文本信息，一般来说对象是写在内存中的，这样一来我们可以让java对象信息保存道硬盘当中。另外一点，序列化后对象可以在传输过程中比较方便的进行。

5，介绍一个关键字：transient， 这个关键字可能很多人一辈子也用不到，它表示的是在序列化过程中如果你不希望这个属性被序列化写到硬盘中，你可以用这个属性来修饰，后面我们会介绍到的。

Serializable

定义两个类实现这个接口

            Man man = new Man("hubh","123456");
            Person person = new Person(man,"liuzong",21);
            //序列化后的对象可以直接输出保存为一个txt文件
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
            objectOutputStream.writeObject("string");
            objectOutputStream.writeObject(person);
            objectOutputStream.close();

接下来我们就需要读这个文件并且把对象里面的数据取出来

Externalizable

这里跟Serializable不同的就是要自己定义那个字段是需要序列化的字段，其他的用法是类似的。

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Staff implements Externalizable {
    private String username;
    // transient这个关键字 在序列化的时候不会写到文件中去
    private  int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //这里定义需要序列化的字段
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(this.username);
        out.writeObject(this.age);
    }
    //反序列化
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.username = (String) in.readObject();
        this.age = (int) in.readObject();
    }
}

Parcelable

这种序列化是Android内置的序列化方式，需要我们在Android开发环境下去实现这类的例子

package com.example.administrator.testactivity;

import android.os.Parcel;
import android.os.Parcelable;

import java.util.HashMap;

public class Person implements Parcelable {
    private String  name;
    private int age ;
    //public HashMap map = new HashMap<String,String> ();
    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 static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
    //重写Creator
        //这里是实例化并返回一个对象，从序列化中读取
        @Override
        public Person createFromParcel(Parcel source) {
            Person p = new Person();
            //p.map=source.readHashMap(HashMap.class.getClassLoader());
            p.name=source.readString();
            p.age = source.readInt();
            return p;
        }
        //构建一个集合并且返回
        @Override
        public Person[] newArray(int size) {
            // TODO Auto-generated method stub
            return new Person[size];
        }
    };

    //实现这个序列化接口需要实现这两个方法
    @Override
    public int describeContents() {
        return 0;
    }
    //这里是序列化自己需要的属性
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }
}

实现一个从activity跳到另外一个activity过程并传递数据的过程

//  第一个activity中的核心代码
    public void switchToMain2Activity(){
        Person person = new Person();
        person.setAge(102);
        person.setName("hb1");

        Person person2 = new Person();
        person2.setAge(103);
        person2.setName("hb2");

        Person person3 = new Person();
        person3.setAge(104);
        person3.setName("hb3");

        Person person4 = new Person();
        person4.setAge(105);
        person4.setName("hb4");

        ArrayList<Person> list = new ArrayList<>();
        list.add(person);
        list.add(person2);
        list.add(person3);
        list.add(person4);

        Intent i = new Intent(MainActivity.this, Main2Activity.class);
        Bundle bundle = new Bundle();
        //传递对象
        bundle.putParcelable("person", person);
        //传递List数组数据
        bundle.putParcelableArrayList("person_list", list);
        i.putExtras(bundle);
        startActivity(i);

    }
//第二个activty中的核心代码
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.ArrayList;
public class Main2Activity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        Intent intent = getIntent();
        if (intent!=null){
            Bundle b = intent.getExtras();
            Person person = (Person) b.get("person");
            if (person!=null){
                Log.i("hb---1",person.getName()+" "+person.getAge());
            }
            ArrayList<Person> list = intent.getParcelableArrayListExtra("person_list");
            for (int i=0;i<list.size();i++){
                Log.i("hb-----2", list.get(i).getName()+list.get(i).getAge()+"");
            }

        }
    }
}

我们可以到最后的结果

从最后的结果来看我们的数据成功的传递过去了，在网络上有时候也需要这样传递数据，我们都可以使用序列化的方式进行。至此序列化已经介绍完了，如果能够理解透彻这篇文章，相信你对序列化是有很深入的理解了。