import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import cnx.sxt.day1226.objectoutputstream.Student;
public class Demo {
/*
* ObjectInputStream:
* ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
* 只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
*
*
* 注意:如果一个类被序列化之后,改动了这个类的属性或者方法之类,反序列化的时候,会报错(序列化版本异常)
* 如何解决?
* 使该类的序列版本号与从流中读取的类描述符的版本号匹配(保持一致)
* 在类中添加如下代码
* private static final long serialVersionUID = 10000L;
*
* 该类的序列版本号与从流中读取的类描述符的版本号不匹配
* local class serialVersionUID = 1407881350363140898 该类的序列版本号
* stream classdesc serialVersionUID = 2768250842175706371 流中读取的类描述符的版本号
*
* 注意:如果某些属性不想序列化,可以在属性的前面加关键字transient
* private transient String name;
* 加了transient关键字的属性,不会被序列化进去,会按照属性默认值来处理
*
* 注意:如果一个类中,有另外一个类,当做这个类的属性,如果要序列化这个类,那么这个属性也得实现序列化接口
*
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1:创建反序列化流 (把文件中的对象读取到程序中)
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("student.txt"));
//2:读取对象 一次读取一个对象
/*Object obj = null;
while((obj = ois.readObject())!=null){
Student stu = (Student)obj;
System.out.println(stu.getName()+stu.getAge()+stu.getSex());
}*/
//3:直接读取集合对象
ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
for (Student stu : al) {
System.out.println(stu.getName()+stu.getAge()+stu.getSex());
}
//4:关闭流
ois.close();
}
}
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class Demo {
/*
* ObjectOutputStream
* 将 Java 对象的基本数据类型和图形写入 OutputStream。
* 可以使用 ObjectInputStream 读取(重构)对象。通过在流中使用文件可以实现对象的持久存储。
* 如果流是网络套接字流,则可以在另一台主机上或另一个进程中重构对象。
* 父类:OutputStream
*/
public static void main(String[] args) throws IOException {
Student stu1 = new Student("张三", 20, "男",new Teacher("谭老师"));
Student stu2 = new Student("李四", 30, "女",new Teacher("王老师"));
Student stu3 = new Student("王五", 40, "男",new Teacher("李老师"));
//1 创建对象输出流(序列化流--将对象流化) 把java中的对象,通过流的方式保存在文件中--对象流化
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("student.txt"));
//2:写把对象写入文件
/* oos.writeObject(stu1);
oos.writeObject(stu2);
oos.writeObject(stu3);
oos.writeObject(null); //自定义结束点
*/ //2 先把对象保存在集合中
ArrayList<Student> al = new ArrayList<>();
al.add(stu1);
al.add(stu2);
al.add(stu3);
//3:直接把集合保存到文件
oos.writeObject(al);
//3:关闭流
oos.close();
}
}
import java.io.Serializable;
/*
* Serializable :序列化接口
* 这个接口中没有任何抽象方法,是一个标记接口
*
*/
public class Student implements Serializable {
//序列化版本号
private static final long serialVersionUID = 10000L;
private transient String name;
private transient int age;
private String sex;
private Teacher t;
public Teacher getT() {
return t;
}
public void setT(Teacher t) {
this.t = t;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Student(String name, int age, String sex, Teacher t) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.t = t;
}
public Student() {
super();
}
}
import java.io.Serializable;
public class Teacher implements Serializable {
private String name;
public Teacher(String name) {
super();
this.name = name;
}
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}