JavaSE_day17:Io流及序列化和反序列化

字节流：

   InputStream

             FileInputStream  从文件中读取字节

             BufferedInputStream  加入缓冲区功能，提高读取的效率

          ByteArrayInputStream   将数组字节变成输入流

 OutputStream

             FileOutputStream 向文件中写入字节

             BufferedOutputStream 加入缓冲区功能，使得写入效率提高

            ByteArrayOutputStream 将流的内容写入到数组。

字符流

     reader

             InputStreamReader  转换字节流为字符流

              BufferedReader   功能增强，以行为单位读取数据（装饰者模式）

            FileReader    是InputStreamReader的子类，将字符编码默认转变成操作系统的编码，不能能手动改变。没有他的父类灵活。

     writer

            OutputStreamWriter  转换字节流为输出字符流

            printWriter是以行为单位写入数据

                         write当成字符写入

                         print是将参数转换成字符串后写入的。

           FileWriter是OutputStreamWriter的子类，也是默认了编码格式为当前操作系统的编码格式，不能手动更改，没有父类使用灵活。

 

Java中的序列化：

     问题：如何将对象中的信息永久保存。

1.将对象信息存入数据库中

2.Java中提供的序列化方式来永久保存数据

首先实现Serializable序列化接口

第二使用ObjectOutputStream写入要序列化的对象

```java
public class Student implements Serializable{

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```java
Student student = new Student();
student.setId(1);
student.setName("张三");

// 序列化就是将对象变为输出字节流
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:\\student.obj"));
os.writeObject(student);
os.close();
```

如果没有实现Serializable接口，会出现NoSerializableException

注意:

1)要求对象中的所有属性也都是可以序列化的

2）如果某个属性不想序列化，可以在属性上加transient关键字

反序列化：

    就是将字节内容读取出来，还原为Java对象

objectInputStream用来读取字节内容，还原（反序列化）为Java对象         

      ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:\\student.obj"));
        Student s = (Student)is.readObject();
        System.out.println(s.getId());
        System.out.println(s.getName());
        System.out.println(s.getAddress());     

除了写入和读取对象以外，还可以写入和读取jiji本数据类型（int ，long，boolean....），读取和写入的顺序要保持一致，如果不一致就会出现EoFException，如果没有更多内容，也会出现EOEFException建议在写入时最后一个对象使用null，这样读取时就可以根据null来判断是否读取完毕

序列化和反序列化其实也是Java一种数据传输机制

## 创建对象的几种方式：
1. 反序列化
2. clone 是一种
3. new 是一种

克隆需要实现Cloneable接口，并覆盖clone方法，

public class Teacher implements Cloneable{ // 可克隆的

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 必须调用Object父类的克隆方法
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher t = new Teacher();
        t.setId(1);
        t.setName("满老师");

        Teacher t2 = (Teacher)t.clone();
        System.out.println(t2.getId());
        System.out.println(t2.getName());

        System.out.println(t2 == t);
    }
}

克隆模式对应的设计模式是原型（prototype）模式，不走构造方法，根据一个已有的对象创建一个已有新的对象

使用Cloneable接口和clone克隆对象，仅仅只是浅拷贝，如果属性为引用类型，复制的仅仅是地址。没有为这个属性创建新的对象

当然，还有深拷贝：

            利用序列化和反序列化生成新的对象，也会为属性创建新的对象：

public class Teacher2 implements Serializable{

    private int id;
    private String name;
    private Date birthday;

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Teacher2 clone() {
        try {
            // 序列化
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream os = new ObjectOutputStream(bos);
            os.writeObject(this); // 写入当前对象
            byte[] bytes = bos.toByteArray(); // 字节结果

            // 反序列化
            ObjectInputStream is = new ObjectInputStream(new ByteArrayInputStream(bytes));
            Teacher2 t = (Teacher2)is.readObject();
            return t;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        Teacher2 t = new Teacher2();
        t.setId(1);
        t.setName("满老师");
        t.setBirthday(new Date());

        Teacher2 t2 = t.clone();

        System.out.println(t == t2);
        System.out.println(t.getBirthday() == t2.getBirthday());
    }
}