image.pngimage.png
    image.png吧

    /*
     对象流的使用
    * 1.ObjectInputStream 和 ObjectOutputStream
    作用：
    ObjectOutputStream：内存中的对象——>存储中的文件、通过网络传输出去
    ObjectInputStream：存储中的文件、通过网络接收过来——>内存中的对象

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

       3.要想一个Java对象是可序列化的，需要满足相应的要求。见Person.class

       4.序列化机制：
      对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许吧这种
       二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点，
      反序列化：当其他程序获取了这种二进制流，就可以恢复成原来的Java对象。
    1. package com.atguigu;
    3. import org.junit.Test;
    5. import java.io.*;
    7. /**
    8.  * 对象流的使用
    9.  * 1.ObjectInputStream 和 ObjectOutputStream
    10.  * 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到
    11.  * 数据源中，也能把对象从数据源中还原回来。
    12.  *
    13.  * 3.要想一个Java对象是可序列化的，需要满足相应的要求。见Person.class
    14.  *
    15.  * 4.序列化机制：
    16.  * 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许吧这种
    17.  * 二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点，
    18.  * 当其他程序获取了这种二进制流，就可以恢复成原来的Java对象。
    19.  *
    20.  *
    21.  * @author Dxkstart
    22.  * @create 2021-06-03 15:05
    23.  */
    24. public class ObjectInput_OutputStream_Test {
    26.     /*
    27.      序列化的过程：将内存中的Java对象保存到磁盘中或通过网络传输出去
    28.      使用ObjectOutputStream实现
    30.      */
    32.     @Test
    33.     public void testObject() {
    34.         ObjectOutputStream oos = null;
    36.         try {
    37.             //1.
    38.             oos = new ObjectOutputStream(new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\IO\\Object.dat")));
    40.             //2.
    41.             oos.writeObject(new String("我爱中国"));
    42.             oos.flush();//刷新操作
    44.             oos.writeObject(new Person("泰勒斯威夫特", 22, new Account(9999)));
    45.             oos.flush();
    47.         } catch (IOException e) {
    48.             e.printStackTrace();
    49.         } finally {
    50.             //3.
    51.             try {
    52.                 if (oos != null) {
    53.                     oos.close();
    54.                 }
    55.             } catch (IOException e) {
    56.                 e.printStackTrace();
    57.             }
    58.         }
    59.     }
    61.     /*
    62.     反序列化：将磁盘中的对象还原为内存中的一个Java对象
    63.     使用ObjectInputStream来实现
    65.      */
    66.     @Test
    67.     public void testObjectinputStream() {
    68.         ObjectInputStream ois = null;
    70.         try {
    71.             //1.
    72.             ois = new ObjectInputStream(new FileInputStream(new File("C:\\Users\\Administrator\\Desktop\\IO\\Object.dat")));
    74.             //2.
    75.             Object obj = ois.readObject();
    76.             String str = (String) obj;
    79.             Person p = (Person) ois.readObject();
    81.             System.out.println(str);
    82.             System.out.println(p);
    85.         } catch (IOException e) {
    86.             e.printStackTrace();
    87.         } catch (ClassNotFoundException e) {
    88.             e.printStackTrace();
    89.         } finally {
    90.             //3.
    91.             try {
    92.                 if (ois != null) {
    93.                     ois.close();
    94.                 }
    95.             } catch (IOException e) {
    96.                 e.printStackTrace();
    97.             }
    98.         }
    101.     }
    102. }
    • Person需要满足如下的要求，方可序列化
      1.需要实现接口：Serializable
       2.当前类提供一个全局常量：serialVersionUID
      3.除了当前Person类需要实现Serializable接口外，还必须保证其内部所有属性
       也必须是可序列化的。（默认情况下，基本数据类型是可序列化的）

       补充：ObjectOutputStream 和 ObjectInoutStream不能序列化static 和 transient修饰的成员变量
      *
    1. package com.atguigu;
    3. import java.io.Serializable;
    5. /**
    6.  * Person需要满足如下的要求，方可序列化
    7.  * 1.需要实现接口：Serializable
    8.  * 2.当前类提供一个全局常量：serialVersionUID
    9.  * 3.除了当前Person类需要实现Serializable接口外，还必须保证其内部所有属性
    10.  * 也必须是可序列化的。（默认情况下，基本数据类型是可序列化的）
    11.  *
    12.  * 补充：ObjectOutputStream 和 ObjectInoutStream不能序列化static 和 transient修饰的成员变量
    13.  *
    14.  *
    15.  * @author Dxkstart
    16.  * @create 2021-06-03 15:27
    17.  */
    18. public class Person implements Serializable {
    20.     public static final long serialVersionUID = 47564312121L;//序列版本号
    22.     private String name;
    23.     private int age;
    24.     private Account acc;//账户
    26.     public Person() {
    27.     }
    29.     public Person(String name, int age, Account acc) {
    30.         this.name = name;
    31.         this.age = age;
    32.         this.acc = acc;
    33.     }
    35.     @Override
    36.     public String toString() {
    37.         return "Person{" +
    38.                 "name='" + name + '\'' +
    39.                 ", age=" + age +
    40.                 ", acc=" + acc +
    41.                 '}';
    42.     }
    43. }
    45. class Account implements Serializable {
    47.     public static final long serialVersionUID = 47564312122L;//序列版本号
    49.     private double balance;
    51.     public Account() {
    52.     }
    54.     public Account(double balance) {
    56.         this.balance = balance;
    57.     }
    59.     public double getBalance() {
    61.         return balance;
    62.     }
    64.     public void setBalance(double balance) {
    66.         this.balance = balance;
    67.     }
    69.     @Override
    70.     public String toString() {
    71.         return "Account{" +
    72.                 "balance=" + balance +
    73.                 '}';
    74.     }
    75. }