【JavaSE】day10_对象流

【JavaSE】day10_对象流

对象是存在于内存中的。有时候我们需要将对象保存到硬盘上，又有时我们需要将对象传输到另一台计算机上等等这样的操作。这时我们需要将对象转换为一个字节序列，而这个过程就称为对象序列化。相反，我们有这样一个字节序列需要将其转换为对应的对象，这个过程就称为对象的反序列化。

1.OOS

1)java.io.ObjectOutputStream

* 该高级流的作用是将给定的java中的对象转换为一组字节，然后通过其处理的流写出。

* 将一个对象转换为一组字节的过程称为：对象序列化。

2)ObjectOutputStream提供了一个独有的方法

* void writeObject(Object o)

该方法会将给定的对象o转换为一组字节，然后再通过其处理的流写出。

代码示例：

Person.java

package day03;

import java.io.Serializable;
import java.util.List;

/**
* 该类用于测试对象序列化
*
* 若当前类的对象希望被ObjectputStream进行序列化，
* 当前类必须实现java.io.Serializable接口。
* 否则在序列化过程中会抛异常。
* 该接口没有任何抽象方法需要重写，这种接口的目的是
* 给子类打上一个标签，表示其认可这件事。而不是用来
* 约束子类应该具有哪些行为。
*
* 除了当前类之外，该类的属性若也是自定义类型的，
* 那么该类也必须实现Serializable接口才可以。
*/
public class Person implements Serializable {
/**
* 当我们的类实现了Serializable接口后，就应当定义
* 下面的常量，该常量是版本号，最好自行维护，该版本
* 号直接影响反序列化的结果。
* 当我们要反序列一个对象时，OIS首先会检查要反序列
* 化的那一组字节表示的对象的版本号是否与当前类的版本
* 号一致，不一致则直接抛异常，告知版本不匹配，无法反序列化。
* 若版本号一致，则会使用兼容默认，即：
* 若原来对象中有的属性，现在类中还有的，则还原它的值；
* 若原来对象中有的属性，现在类中没有了，则忽略；
* 若原来对象中没有的属性，现在类中有的，则使用默认值。
*
* 若不自行维护版本号，那么OOS在进行序列化时，会根据当前
* 类的结构生成一个版本号，这样做不好的地方在于：我们的类
* 结构发生改变后，版本号也会改变，由于不可控，所以不能启用
* 兼容模式。
*/
private static final long serialVersionUID = 2L;
private String name;
private int age;
private String gender;
private int salary;

/*
* 当一个属性被transient关键字修饰后，该属性在序列化
* 的时候被忽略。忽略不必要的属性是为了对象在序列化为
* 字节的时候搜身。
*/
private transient List<String> otherInfo;

//private A a;
//public void setA(A a){
//	this.a = a;
//}

public Person() {
super();
}

public Person(String name, int age, String gender, int salary,
List<String> otherInfo) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.salary = salary;
this.otherInfo = otherInfo;
}

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 getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}

public int getSalary() {
return salary;
}

public void setSalary(int salary) {
this.salary = salary;
}

public List<String> getOtherInfo() {
return otherInfo;
}

public void setOtherInfo(List<String> otherInfo) {
this.otherInfo = otherInfo;
}

public String toString(){
return name+","+age+","+gender+","+salary+","+otherInfo;
}

}

OOSDemo.java

package day03;

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

/**
* java.io.ObjectOutputStream
* 该高级流的作用是将给定的java中的对象转换为
* 一组字节，然后通过其处理的流写出。
* 将一个对象转换为一组字节的过程称为：对象序列化。
*
*/
public class OOSDemo {
public static void main(String[] args) throws IOException {
Person p = new Person();
p.setName("苍老师");
p.setAge(24);
p.setGender("女");
p.setSalary(1000000);

List<String> otherInfo = new ArrayList<String>();

otherInfo.add("写大字");
otherInfo.add("是个演员");
otherInfo.add("是个歌手");
otherInfo.add("促进中日文化交流");

p.setOtherInfo(otherInfo);

//A a = new A();
//p.setA(a);

/*
* 将该对象转换成一组字节然后写入文件
* 这里需要两个流的组合来实现：
* 1：ObjectOutputStream
*    目的：可以将一个对象转换为一组字节
* 2：FileOutputStream
*    目的：可以将一组字节写入文件
*/
FileOutputStream fos = new FileOutputStream("person.obj");

ObjectOutputStream oos = new ObjectOutputStream(fos);

/*
* ObjectOutputStream提供了一个独有的方法
* void writeObject(Object o)
* 该方法会将给定的对象o转换为一组字节，然后再
* 通过其处理的流写出。
*/
oos.writeObject(p);

System.out.println("序列化完毕!");

oos.close();
}

}

2.OIS

1)java.io.ObjectInputStream

* 该类的作用是读取一组字节（必须是由OOS将对象序列化后的一组字节），将其还原为对象。

2)Object readObject()

* ObjectInputStream提供了一个方法，该方法可以从其处理的流中将字节读取回来并转换为对象返回。只不过返回的时候以顶级父类Object形式。所以返回后需要自己造型。

* 该方法要求我们处理一个异常： ClassNotFoundException.

该异常通常出现的原因是，读取的那一组字节并不能转换为对象。这组字节不是由OOS的writreObject序列化的字节。

代码示例：

package day03;

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

/**
* java.io.ObjectInputStream
* 该类的作用是读取一组字节（必须是由OOS将对象序列化后的
* 一组字节），将其还原为对象。
*
*/
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/*
* 读取person.obj文件，将Person对象还原。
* 从字节到对象的过程称为对象的"反序列化"。
*/
FileInputStream fis = new FileInputStream("person.obj");

ObjectInputStream ois = new ObjectInputStream(fis);

/*
* Object readObject()
* ObjectInputStream提供了一个方法，该方法可以
* 从其处理的流中将字节读取回来并转换为对象返回。只
* 不过返回的时候以顶级父类Object形式。所以返回后
* 需要自己造型。
*
* 该方法要求我们处理一个异常：
* ClassNotFoundException.该异常通常出现的原因
* 是，读取的那一组字节并不能转换为对象。
* 这组字节不是由OOS的writreObject序列化的字节。
*/
Person p = (Person)ois.readObject();
System.out.println(p);

ois.close();
}

}