一次序列化多个对象，且其中密码属性不序列化，然后反序列化打印的小练习(3.16)

需求:

        要用数组存多个对象，并且要进行序列化（密码属性不序列化），然后反序列化打印出来。

思路:

        先定义User实体类，定义成员变量（password用transient修饰，意思是不序列化），再把有参无参构造，getter和setter方法，重写toString弄一下。

        再定义一个类TestOutput进行序列化，创建一个对象字节输出流包装原始的字节输出流，再抛异常，再用writeObject()方法序列化。

        定义一个类TestInput反序列化，先定义一个数组users为空，再创建一个对象字节输入流管道，包装低级的字节输入流与源文件连通，抛异常，然后用readObject()反序列化，再强转(User)给到users。再遍历输出打印。

代码:

User实体类

import java.io.Serializable;

public class User implements Serializable {
    //意思是定义程序序列化ID，保持不同版本的兼容性
    private static final long serialVersionUID = 1L;
    private String loginName;
    private String username;
    private int age;

    //序列化不想暴露密码，在User的密码变量前加修饰符transient。transient这个成员变量将不参与序列化
    private transient String passWord;

    public User() {
    }

    public User(String loginName, String username, int age, String passWord) {
        this.loginName = loginName;
        this.username = username;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", username='" + username + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

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

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

类TestOutput进行序列化

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class TestOutput {
    public static void main(String[] args) {
        ArrayList<User> users=new ArrayList<>();
        users.add(new User("admin","张三",18,"123456"));
        users.add(new User("hello","李四",20,"456789"));
        users.add(new User("world","王五",19,"789321"));

        try (
                //创建一个对象字节输出流包装原始的字节输出流
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima08.txt"));
                ){
            oos.writeObject(users);
            System.out.println("数组中多个对象序列化完成");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

类TestInput反序列化

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class TestInput {
    public static void main(String[] args) {
        ArrayList<User> users=null;

        try (
                //创建一个对象字节输入流管道，包装 低级的字节输入流与源文件连通
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("io-app2/src/itheima08.txt"));
                ){
            users = (ArrayList<User>) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.out.println("用户类没有找到");
            e.printStackTrace();
        }

        //打印反序列化后的对象
        for (User user : users) {
            System.out.println(user);
        }
    }
}