Problème avec la désérialisation

Question

J'ai une méthode dans mon programme qui lit à partir d'un fichier et j'ai associé à la fois une variable FileInputStream et une variable ObjectInputStream. Cependant, je ne sais pas combien d'objets seront sérialisés dans le fichier lorsque j'exécuterai le programme, donc je ne connais pas le nombre d'objets à désérialiser en utilisant la méthode readObject(). Ceci est la méthode de mon projet:

public void importResults(File file) throws FileNotFoundException, IOException, ClassNotFoundException { 
    TestEntry entry = null; 
    try(FileInputStream fis = new FileInputStream(file)) { 
     ObjectInputStream ois = new ObjectInputStream(fis); 

     tests.clear(); 

     entry = (TestEntry)ois.readObject(); 

     tests.add(entry); 

     ois.close(); 
    } 
} 

L'entrée variable est où je vais stocker TestEntry objets que je deserialize à partir du fichier. Le problème est que, si j'essaie de désérialiser trop d'objets, j'obtiens une exception EOFException. Comment puis-je obtenir mon programme pour déterminer combien d'objets sont sérialisés dans le fichier afin que je puisse désérialiser le bon montant? Toute aide est la bienvenue! Je vous remercie.

Answer 1

Il suffit de lire dans une boucle jusqu'à ce que vous obtenez EOFException, qui est jeté quand il n'y a pas de lire plus d'objets.

Answer 2

Je ne pense pas qu'il existe un moyen de compter combien d'objets sont sérialisés, car un fichier ne peut contenir qu'un objet. Vous obtenez probablement EOFException parce que vous faites quelque chose comme ci-dessous. Comme il n'y a qu'un seul objet dans un fichier, quel que soit le nombre de sérialités, lire deux fois à partir du même flux aura pour résultat EOFException.

in.readObject(); 
in.readObject(); 

Je viens de tester et vous pouvez lire un objet un certain nombre de fois du même fichier aussi longtemps que vous ne le faites pas ci-dessus ou quelque chose de similaire.

Mon test est inférieure à

public static void main(String []args) { 
    writeObject(new Integer(333)); 
    for(int i = 0; i < 9999; i++) { 
     Integer i = (Integer)readObject(); 
     System.out.println(i);//prints 333 
    } 
} 
public static void writeObject(Object obj) { 
    try { 
     ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("file.dat")); 
     out.writeObject(obj); 
     out.close(); 
    } 
    catch(IOException e) {} 
} 
public static Object readObject() { 
    Object obj = null; 
    try { 
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("file.dat")); 

     obj = in.readObject(); 
     in.close(); 
    } 
    catch(IOException e){} 
    catch(ClassNotFoundException e){} 
    return obj; 
} 

Answer 3

Peut-être que vous pourriez écrire le nombre d'objets qui sont présents dans le fichier et pour la désérialisation d'abord lire ce numéro (mais je ne sais pas si un fichier peut contenir plusieurs sérialisé objets).

Toutefois, si vous mettez vos objets dans un ArrayList que vous sérialiser, vous pouvez écrire que ArrayList au fichier et désérialiser simplement en lisant un objet.

J'ai fait une classe de test A et cela fonctionne:

public class A implements Serializable { 
    int a, b, c; 
} 

public static ArrayList<A> deserializeObjects(File file) throws FileNotFoundException, IOException, ClassNotFoundException { 
    FileInputStream fIn = new FileInputStream(file); 
    ObjectInputStream oIn = new ObjectInputStream (fIn); 
    ArrayList<A> objects = null; 

    // Read array of objects 
    if(fIn.available() > 0) { 
     objects = (ArrayList<A>) oIn.readObject(); 
    } 

    oIn.close(); 
    fIn.close(); 

    return objects; 
} 

public static void serializeObjects(File file, ArrayList<A> objects) throws IOException { 
    FileOutputStream fOut = new FileOutputStream(file); 
    ObjectOutputStream oOut = new ObjectOutputStream(fOut); 

    // Write the whole arraylist to file 
    oOut.writeObject(objects); 
    oOut.flush(); 
    oOut.close(); 
    fOut.close(); 
} 

public static void main(String args[]) throws IOException, ClassNotFoundException { 
    // Make test objects 
    A o1 = new A(); 
    A o2 = new A(); 

    o1.a = 1; o1.b = 2; o1.c = 3; 
    o2.a = 4; o2.b = 5; o2.c = 6; 

    ArrayList<A> objects = new ArrayList<A>(); 
    objects.add(o1); 
    objects.add(o2); 

    File f = new File("yourFile"); 
    f.createNewFile(); 

    serializeObjects(f, objects); // Serialize arraylist 
    ArrayList<A> deserialized = deserializeObjects(f); // Deserialize it 

    // Success?? 
    System.out.println("a : " + deserialized.get(0).a + ", b : " + deserialized.get(0).b + ", c : " + deserialized.get(0).c); 
    System.out.println("a : " + deserialized.get(1).a + ", b : " + deserialized.get(1).b + ", c : " + deserialized.get(1).c); 
} 

Answer 4

Vous pouvez ajouter l'objet à une liste et linéariser/désérialiser cette liste.

// entry = (TestEntry)ois.readObject(); 
    List<TestEntry> entries = (List<TestEntry>)ois.readObject();