对象流

对象流： ObjectOutputStream和ObjectInputStream（从后缀可以看出是字节流）
作用： 用来传输对象的，也可以存储基本类型的数据，把内存层面Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
内存层面的对象随时可能会被回收，可以通过保存到文件中（文件可以持久保存），也可以通过网络传输另一端再进行还原为内存层面
可以把内存中的对象，比如new的String，或者new的一个Student来做一个传输
把对象写入到数据源（文件，数据库之类的），也可以通过网络层面进行传输
序列化： 把内存层面的写入到数据源中，把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点
反序列化： 把数据源中的还原到内存层面的，当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

反序列化和序列化的前提是对象所属的类是可序列化的，只有是可序列化的才能持久化到文件中

import java.io.*;

public class Test {
    public static void main(String[] args) {
        ObjectOutputStream  oos=null;

        try {
            //序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去，使用ObjectOutputStream来实现
            oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
            oos.writeObject(new String("我"));
            oos.flush();//刷新操作
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos!=null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
		//不能直接双击点开看内容，打开你也看不懂内容，要想看要用反序列化过程

        //反序列化过程：将磁盘文件中的对象还原为内存中的一个java对象，或者通过网络也OK
        ObjectInputStream ois=null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.txt"));
            Object obj=ois.readObject();//返回的是Object类型
            String str=(String)obj;//因为obj实际指向的是一个String,所以可以做一个强制类型转换
            System.out.println(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if(ois!=null)
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
     }
}

自定义类实现序列化反序列化操作
要想java对象可序列化需要满足的要求：
Person类需要满足这些要求才可序列化：

• 1.该类必须实现如下两个接口之一，否则，会抛出NotSerializableException异常 ，1.（用的比较多）Serializable 2.Externalizable
  Serializable什么抽象方法也没有，这种接口叫做标识接口，凡是实现的类都会被识别为可序列化的

• 2.必须要提供进入的modifier，即提供一个属性，这个属性声明为static final long serialVersionUID=42L，我们需要显示的写上public,把42随便改一个值（正负都可以）
  即需要当前类提供一个全局常量：serialVersionUID
  序列化的时候用的是这个serialVersionUID，再反序列化的时候识别这个serialVersionUID能够还原成Person类的对象
  如果自己不去加（即不加public static final long serialVersionUID=4223456478L;），用的是系统自动生成的，
  那序列化存储到磁盘中，如果在这之后对Person类进行修改，自动生成的serialVersionUID就变了，还原的时候就找不到Person类了，无法还原，会报异常
  如果自己加了，那序列化存储到磁盘中，如果在这之后对Person类进行修改，serialVersionUID还是不会变，还原的时候不会出问题

• 3.除了当前的Person类需要实现Serializable接口之外还要保证其内部所有属性也必须是可序列化的
  默认情况下，基本数据类型和String是可序列化的，如果person类中有一个private Account acc;定义了一个class叫Account。
  一定要保证Account也序列化

补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量，
用static和transient修饰的变量不会被序列化，保存的值是默认的值，个解：如果是引用变量则为null，如果是基本数据类型则为0

import java.io.*;

public class Test {
    public static void main(String[] args) {
        ObjectOutputStream oos=null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("hello3.txt"));
            oos.writeObject(new Person("Tom",23,new Account(5000)));
            oos.flush();//一定要加
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos!=null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        ObjectInputStream  ois=null;

        try {
            //读
            ois = new ObjectInputStream(new FileInputStream("hello3.txt"));
            Person p=(Person)ois.readObject();
            System.out.println(p);//Person{name='Tom', age=23, acc=Account{balance=5000.0}}
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if(ois!=null)
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
     }
}
class Person implements Serializable{
    private String name;
    private int age;
    private Account acc;
    public static final long serialVersionUID=4223456478L;//serialVersionUID序列版本号（比如自定义异常类的时候都要补一个序列版本号）
    public Person() {

    }

    public Person(String name, int age, Account acc) {
        this.name = name;
        this.age = age;
        this.acc = acc;
    }

    //serialVersionUID起到标识的作用，识别是哪个类，不加会出问题
    public Person(int age,String name) {
        this.age = age;
        this.name=name;
    }//右键点击generate，点击constructor进入构造器，用shift加上向下箭头选择参数

    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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", acc=" + acc +
                '}';
    }
}
class Account implements Serializable{
    private double balance;
    public static final long serialVersionUID=4243456478L;
    public Account(double balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                '}';
    }
}