Java 反序列化文件时未检索所有对象

通过

try {
  FileOutputStream fileOut = new FileOutputStream(
      "C:\\Users\\saikiran\\Documents\\NetBeansProjects\\FTP\\reg.ser", true);
  ObjectOutputStream out = new ObjectOutputStream(fileOut);
  out.writeObject(r);
  out.close();
  fileOut.close();
  System.out.printf("Serialized data is saved in /tmp/reg.ser");
  pr.println("Registered Successfully ");
} catch (IOException i) {
  i.printStackTrace();
}

反序列化时，不获取整个文件对象，只获取单个对象，即仅启动对象

 FileInputStream fileIn = new FileInputStream("C:\\Users\\saikiran\\Documents\\NetBeansProjects\\FTP\\reg.ser");
                   ObjectInputStream in = null;                       
while (fileIn.available() != 0) {

  in = new ObjectInputStream(fileIn);
  while (in != null && in.available() != 0) {
    r = (Registration) in.readObject();
    System.out.println("Logged in :" + "User name :" + r.u + "Password  " + r.p);

    if (r.u.equals(ur) && r.p.equals(ps)) {
      System.out.println("Logged in :" + "User name :" + r.u + "Password  " + r.p);
      pr.println("Display");

    }
  }
}

---

我已经为您创建了工作样本。

我的

POJO serializable

类将是

import java.io.Serializable;

public class Pojo implements Serializable{

    String name;
    String age;
    String qualification;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getQualification() {
        return qualification;
    }
    public void setQualification(String qualification) {
        this.qualification = qualification;
    }

}

我的

main

课程将是

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class Serialization {

    /**
     * @param args
     */
    public static final String FILENAME = "F:\\test\\cool_file.ser";

    public static void main(String[] args) throws IOException, ClassNotFoundException {


        FileOutputStream fos = null;
        //ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(FILENAME);
            //oos = new ObjectOutputStream(fos);
/*          for (String s : test.split("\\s+")) {
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeObject(s);
            }*/

            for(int i=0;i<10;i++){
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                Pojo pojo = new Pojo();
                pojo.setName("HumanBeing - "+i);
                pojo.setAge("25 - "+i);
                pojo.setQualification("B.E - "+i);
                oos.writeObject(pojo);
            }

        } finally {
            if (fos != null)
                fos.close();
        }

        List<Object> results = new ArrayList<Object>();

        FileInputStream fis = null;
        //ObjectInputStream ois = null;

        try {
            fis = new FileInputStream(FILENAME);
            //ois = new ObjectInputStream(fis);
            while (true) {
                ObjectInputStream ois = new ObjectInputStream(fis);
                results.add(ois.readObject());
            }
        } catch (EOFException ignored) {
            // as expected
        } finally {
            if (fis != null)
                fis.close();
        }
        System.out.println("results = " + results);

        for (int i=0; i<results.size()-1; i++) {
            System.out.println(((Pojo)results.get(i)).getName()+ "    "+((Pojo)results.get(i)).getAge()+ "    "+((Pojo)results.get(i)).getQualification());
        }
    }

}

import java.io.EOFException；
导入java.io.FileInputStream；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
导入java.util.ArrayList；
导入java.util.List；
公共类序列化{
/**
*@param args
*/
公共静态最终字符串FILENAME=“F:\\test\\cool\u file.ser”；
公共静态void main（字符串[]args）引发IOException，ClassNotFoundException{
FileOutputStream=null；
//ObjectOutputStream oos=null；
试一试{
fos=新文件输出流（文件名）；
//oos=新对象输出流（fos）；
/*用于（字符串s:test.split（\\s+））{
ObjectOutputStream oos=新的ObjectOutputStream（fos）；
oos.写入对象；
}*/
对于（int i=0；i什么是
fileIn
，什么是
in
？当进入外部
循环时，为什么在
中重新分配
，而
循环？r.u和r.p为空？您的第一个代码段仅序列化单个对象。您希望其他对象来自何处？AFAIK重复序列化为单独的
ObjectOutputStream
s将不允许您使用单个
ObjectInputStream
读取多个对象。或者使用单个
ObjectOutputStream
（以及对
writeObject（）
的多次调用）写入所有对象，或者使用多个单独的
ObjectInputStream
读取它们。为什么在（in.available（）！=0）时进行两次检查这有帮助吗？