Question

利用ObjectInputStream类中的readObject()，读取多个对象

通过ObjectOutputStream类的writeObject()方法写入了多个对象，并存储到文件中，如可利用ObjectInputStream类中的readObject()，一次读取多个对象？

public class ObjectStreamDemo {
/**
* @param args
* @throws IOException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
//writeObj();
readObj();
}
public static void readObj() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));
//对象的反序列化
//Person p = (Person)ois.readObject();
//Person p1 = (Person)ois.readObject();
//
//System.out.println(p.getName()+":"+p.getAge());
//System.out.println(p1.getName()+":"+p1.getAge());
//
//ois.close();
ArrayList<Person> al = new ArrayList<Person>();
Person p=null;
while((p = (Person)ois.readObject())!=null){
System.out.println(p.getName());
}
for(Person pe:al){
System.out.println(pe.getName());
}
}
public static void writeObj() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));
//对象序列化。被序列化的对象必须实现Serializable接口。
oos.writeObject(new Person("小强",30));
oos.writeObject(new Person("王五",20));
oos.close();
}
}

Answer 1

/**
* 文件转化为Object
* @param fileName
* @return byte[]
*/
public static Object file2Object(String fileName) {

FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = new FileInputStream(fileName);
ois = new ObjectInputStream(fis);
Object object = ois.readObject();
return object;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (ois != null) {
try {
ois.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
return null;
}
/**
* 把Object输出到文件
* @param obj
* @param outputFile
*/
public static void object2File(Object obj, String outputFile) {
ObjectOutputStream oos = null;
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new File(outputFile));
oos = new ObjectOutputStream(fos);
oos.writeObject(obj);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
}

/**
*如果是多个对象被序列化，那么在序列化文件中它应当是ArrayList。序列化可以是数组，那么
*你反序列化自然是对象数组,在序列化是使用这种数组方式比单个序列化要合适。如果按照你的
*这种写法，生成的序列化文件相当于一个table，反序列化时一次readObject()只能读一个对
*象，下一个对象需要再写一次readObject(),这样一来需要一个循环，然后每次读到的对象放
*入一个数组中，so非常麻烦。
*
*/

Answer 2

一个序列化的对象