Day60（打印流，数据流，对象流，对象的序列化，Serializable接口，SerialVersionUID常量）

处理流之四：打印流(了解)出程序。

@Test
    /*
     * 2. 打印流：
     * PrintStream 和PrintWriter
     * 说明：
     * 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
     * System.out返回的是PrintStream的实例
     */
    public void test1() {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("text.txt"));
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节'\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if (ps != null) {// 把标准输出流(控制台输出)改成文件
                System.setOut(ps);
            }
            for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                System.out.print((char) i);
                if (i % 50 == 0) { // 每50个数据一行
                    System.out.println(); // 换行
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
    }

• 实现将基本数据类型的数据格式转化为字符串输出

• 打印流：PrintStream和PrintWriter

  • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出

  • PrintStream和PrintWriter的输出不会抛出IOException异常

  • PrintStream和PrintWriter有自动flush功能

  • PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter 类。

  • System.out返回的是PrintStream的实例

为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。

处理流之五：数据流(了解)

@Test
    /*
     * 3. 数据流：
     * DataInputStream 和 DataOutputStream
     * 作用：
     * 用于读取或写出基本数据类型的变量或字符串
     * 示例代码：
     *
       练习：将内存中的字符串、基本数据类型的变量写出到文件中。
       注意：处理异常的话，仍然应该使用try-catch-finally.
     */
    public void test2(){
        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("data.txt"));
            dos.writeUTF("西瓜");
            dos.flush();
            dos.writeInt(30);
            dos.flush();
            dos.writeBoolean(true);
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dos != null){
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    public void test3(){
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new FileInputStream("data.txt"));
            String name = dis.readUTF();
            int age = dis.readInt();
            boolean isMale = dis.readBoolean();
            System.out.println("name = "+name);
            System.out.println("age = "+age);
            System.out.println("isMale = "+isMale);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dis != null){
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

• 数据流有两个类：(用于读取和写出基本数据类型、String类的数据）

  • DataInputStream和DataOutputStream

  • 分别“套接”在InputStream和OutputStream子类的流上

• DataInputStream中的方法

boolean readBoolean()

byte readByte()

char readChar()

float readFloat()

double readDouble()

short readShort()

long readLong()

int readInt()

String readUTF()

void readFully(byte[] b)

• DataOutputStream中的方法
  • 将上述的方法的read改为相应的write即可。

处理流之六：对象流

import java.io.*;

/**
 * 1.对象流：
 * ObjectInputStream 和 ObjectOutputStream
 * 2.作用：
 * ObjectOutputStream:内存中的对象--->存储中的文件、通过网络传输出去：序列化过程
 * ObjectInputStream:存储中的文件、通过网络接收过来 --->内存中的对象：反序列化过程
 * 3.对象的序列化机制：
 * 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘
 * 上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的
 * Java对象
 * 实现序列化的对象所属的类需要满足：
 * 1.需要实现接口：Serializable
 * 2.当前类提供一个全局常量：serialVersionUID
 * 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所属性
 *   也必须是可序列化的。（默认情况下，基本数据类型可序列化）
 *
 *
 * 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
 */
public class ObjectInputOutputStreamTest {
//序列化代码实现：
    @Test
    public void test() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            oos.writeObject(new String("我爱北京天安门"));
            oos.flush();
            oos.writeObject(new Person("阿黄",12));
            oos.flush();
            oos.writeObject(new Person("草莓",20,15,new Account(10000.0)));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
//反序列化代码实现：
    @Test
    public void test1() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            Person p1 = (Person)ois.readObject();
            Person p2 = (Person)ois.readObject();
            System.out.println(obj);
            System.out.println(p1);
            System.out.println(p2);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.io.Serializable;

public class Person implements Serializable {
    public static final long serivalVersionUID = 21242141L;
    private String name;
    private int age;
    private int id;
    private Account account;

    public Person() {
    }

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

    public Person(String name, int age) {
        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;
    }

    public int getId() {
        return id;
    }

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

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ", account=" + account +
                '}';
    }
}

class Account implements Serializable {
    private static final long serialVersionUID = 898782L;
    private double balance;

    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 +
                '}';
    }
}

• ObjectInputStream和OjbectOutputSteam

  • 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

• 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

• 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

• ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象的序列化

• 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

• 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

• 序列化是RMI（Remote Method Invoke –远程方法调用）过程的参数和返回值都必须实现的机制，而RMI 是JavaEE的基础。因此序列化机制是JavaEE平台的基础

• 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常

  • Serializable

  • Externalizable

• 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

  • private static final long serialVersionUID;

  • serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。

  • 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化。故建议，显式声明。

• 简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

使用对象流序列化对象

• 若某个类实现了Serializable接口，该类的对象就是可序列化的：

  • 创建一个ObjectOutputStream

  • 调用ObjectOutputStream对象的writeObject(对象) 方法输出可序列化对象

  • 注意写出一次，操作flush()一次

• 反序列化

  • 创建一个ObjectInputStream

  • 调用readObject() 方法读取流中的对象

• 强调：如果某个类的属性不是基本数据类型或String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field 的类也不能序列化

谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化，是空方法接口，还有其它认识吗？

• 实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。

• 由于大部分作为参数的类如String、Integer等都实现了java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。