/*
ObjectOutputStream 叫做序列化流。 可以将java程序中的对象写入到文件中。
构造方法：
ObjectOutputStream(OutputStream out)： 传递一个字节输出流对象。
写对象方法：
void writeObject(Object obj)： 向文件中写入对象。
使用步骤：
1. 创建序列化流对象。
2. 调用writeObject方法，向文件中写入一个指定的对象。
3. 调用close方法，释放资源
要写入到文件的类的对象，必须实现一个接口，这个接口叫做Serializable。
这个接口叫做序列化接口。只有实现这个接口的类的对象，才具备序列化的作用
*/
public class Demo01ObjectOutputStream {
public static void main(String[] args) throws IOException {
//1.创建序列化流对象,传入字节输出流对象
//创建字节输出流对象
FileOutputStream fos=new FileOutputStream("E:\\就业班代码\\fiel02.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2 调入writeObject方法，向文件中写入一个指定对象
Person p=new Person();
oos.writeObject(p);
oos.close();//释放资源
}
}
/* ObjectInputStream是反序列化流，可以将文件中的对象读取到java程序中。
构造方法：
ObjectInputStream(InputStream in)： 传递一个字节输入流
读取对象的方法
Object readObject()： 从文件中读取对象并返回
如果读取的时候，这个类不存在，那么就会抛出ClassNotFountException
*/
public class Demo02ObjectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1创建反序列化流对象，并传递字节输入流对象作为参数
FileInputStream fis=new FileInputStream("fiel02.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
Object o = ois.readObject();
Person p=(Person)o;
System.out.println(p.getAge()+p.getName());
ois.close();
}
}
public class Demo04StaticAndTransient {
//定义方法，将文件中的Person对象读取到Java程序中
public static void main(String[] args) throws IOException, ClassNotFoundException {
writeObject();
readObject();
}
//向文件中读取一个对象
public static void readObject() throws IOException, ClassNotFoundException {
//创建ObjectInputStream反序列化流对象
//创建字节流输入对象作为参数，并绑定目标文件
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\就业班代码\\fiel02.txt"));
//调用readObject进行读取
Object obj = ois.readObject();
Person p = (Person) obj;
System.out.println(p.getName() + "-" + p.getAge());
}
//向文件中写入一个对象
public static void writeObject() throws IOException {
//创建序列化流对象，传入字节输出流对象作为参数
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\就业班代码\\fiel02.txt"));
oos.writeObject(new Person(18, "李白"));
oos.close();
}
}
/*
Serializable这个接口中没有任何方法。这个接口只是做一个标记。
只有实现这个接口的类的对象，才能被序列化。
如何给类分配一个固定不变的版本号（序列号）
在类的成员位置提供一个long类型的静态常量即可，这个静态常量必须叫做serialVersionUID
*/
public class Person implements Serializable{
//给这个类分配一个固定的版本号，不管这个类的内容怎么修改，类的版本号永远是0
private static final long serialVersionUID = 0L;
private String name;
private /*static*/ /*transient*/ int age;
public void sleep() {
}
public Person() {
}
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;
}
}
*练习
1. 将存有多个自定义对象的集合序列化操作，保存到 list.txt 文件中。
2. 反序列化 list.txt ，并遍历集合，打印对象信息
思路：
1. 创建集合，并且添加多个Person对象。
2. 序列化流对象
3. 将集合写入到文件。
4. 创建反序列化流
5. 把文件中的集合对象读取出来。
*/
public class Demo05Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建集合存储对象
ArrayList<Person> list = new ArrayList<>();
//存储几个Person对象
list.add(new Person(18, "李白"));
list.add(new Person(19, "郭德纲"));
list.add(new Person(12, "马云"));
//创建序列化对象，传入字节输出流对象作为参数
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\就业班代码\\day010\\src\\list.txt"));
//调用序列化流方法,将集合写入文件
oos.writeObject(list);
//创建反序列化流对象，创建字节输入流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\就业班代码\\day010\\src\\list.txt"));
//调用方法，将文件中的对象集合读出
Object o = ois.readObject();
//向下强转为person类型
ArrayList<Person> list2 = (ArrayList<Person>) o;
System.out.println(list2);
//遍历集合
for (Person person : list) {
System.out.println(person.getAge() + "的" + person.getName());
}
}
}