序列化对象时可以将一个装载了对象的集合中的所有对象循环存入文件中，但是反序列化时如何循环读取，一直没得到解决：
序列化代码如下：

1. 
   
2.         /**
   
3.          * 对象流演示
   
4.          */
   
5.         public static void main(String[] args) {
   
6.                 //文件输出流
   
7.                 FileOutputStream fos = null;
   
8.                 //对象序列化流
   
9.                 ObjectOutputStream out = null;
   
10.                 try {
    
11.                         fos = new FileOutputStream("objectstream.txt");
    
12.                         out = new ObjectOutputStream(fos);
    
13.                         List<Person> pList = new ArrayList<Person>();
    
14.                         pList.add(new Person("张三",25));
    
15.                         pList.add(new Person("李四",31));
    
16.                         pList.add(new Person("王五",29));
    
17.                         for(Person p : pList){
    
18.                                 out.writeObject(p);
    
19.                                 out.flush();
    
20.                         }
    
21.                 } catch (Exception e) {
    
22.                         e.printStackTrace();
    
23.                 } finally{
    
24.                         //关流
    
25.                         try{
    
26.                                 if(null != fos)
    
27.                                         fos.close();
    
28.                                 if(null != out)
    
29.                                         out.close();
    
30.                         }catch(IOException e){
    
31.                                 
    
32.                         }
    
33.                 }
    
34.         }

复制代码

反序列化代码如下，目前反序列化只能一次一次读，我觉得要是一次性存入一个文件的对象很多就不可能再这么做了，所以有没有循环读取的办法，
我试了API里，ObjectInputStream提供的很多方法基本上都行不通，不可能像读取字符流或字节流那样，通过判断read()方法返回的是不是-1来判断，所以，有什么好办法没：

1. public static void main(String[] args) {
   
2.                 //文件输入流
   
3.                 FileInputStream fis = null;
   
4.                 //对象反序列化流
   
5.                 ObjectInputStream in = null;
   
6.                 try{
   
7.                         fis = new FileInputStream("objectstream.txt");
   
8.                         in = new ObjectInputStream(fis);
   
9.                         //一个一个的读取流对象
   
10.                         Person p1 = (Person)in.readObject();
    
11.                         Person p2 = (Person)in.readObject();
    
12.                         Person p3 = (Person)in.readObject();
    
13.                         System.out.println(p1.getName() + ":" + p1.getAge());
    
14.                         System.out.println(p2.getName() + ":" + p2.getAge());
    
15.                         System.out.println(p3.getName() + ":" + p3.getAge());
    
16.                 }catch(Exception e){
    
17.                         e.printStackTrace();
    
18.                 }finally{
    
19.                         //关闭流
    
20.                         try{
    
21.                                 if(null != fis){
    
22.                                         fis.close();
    
23.                                 }
    
24.                                 if(null != in){
    
25.                                         in.close();
    
26.                                 }
    
27.                         }catch(IOException e){
    
28.                                 e.printStackTrace();
    
29.                         }
    
30.                 }
    
31.         }

复制代码

Person类：

1. public class Person implements Serializable{
   
2.         private static final long serialVersionUID = 1L;
   
3.         private String name;
   
4.         private int age;
   
5.         public String getName() {
   
6.                 return name;
   
7.         }
   
8.         public void setName(String name) {
   
9.                 this.name = name;
   
10.         }
    
11.         public int getAge() {
    
12.                 return age;
    
13.         }
    
14.         public void setAge(int age) {
    
15.                 this.age = age;
    
16.         }
    
17.         public Person() {
    
18.                 super();
    
19.         }
    
20.         public Person(String name, int age) {
    
21.                 super();
    
22.                 this.name = name;
    
23.                 this.age = age;
    
24.         }
    
25. }

复制代码

亲，如问题已解决请将分类的“未解决”改为“已解决”。
以后的问题贴也要及时更改分类哦~

哥们我也找了个遍,貌似jdk还没提供这种方法如果有的话应该是readObjectes();但遗憾的是ObjectIntputStream没有那么强大.不过我们也可以有自己的方法去方便的循环获取多个对象.
由于每个获取对象到末尾的时候都会报一个EOFException异常,这就好办了.将代码这么改:

1. // 循环读取对象直到报EOFException异常就退出循环
   
2.                  Person p1;
   
3.                 while (true) {
   
4.                         try {
   
5.                                 p1=(Person)oi.readObject();
   
6.                                 arrayList.add(p1);
   
7.                         } catch (EOFException e) {
   
8.                                 break;
   
9.                         }
   
10.                 }

复制代码

这样也可以,不过我觉得这个jdk提供的反序列化实在是不够强大啊!为什么readObject()读到数据末尾的时候不返回null呢?反而要去报一个异常!只要修改一下源代码就可是实现了,为什么开发JDK的时候就没有去这么做?郁闷啊...

straw 发表于 2013-9-20 20:02
哥们我也找了个遍,貌似jdk还没提供这种方法如果有的话应该是readObjectes();但遗憾的是ObjectIntputStream ...

这个方法也挺好，不知道jdk1.7对这个有提供解决方案没有，如果没有的话，实际开发中你这种方法可以用，还有应该可以考虑用代理，把这方法包装一下

我用的是JDK1.7.0_15版本的,依然没有解决这个问题,还有他们说1.7的新特性switch里变量可以是应用类型,可我这个版本没有这个特性,不知道从哪个版本开始才加这些特性的?