无法从文件读取多个对象

Question

I'm trying to put the (Lieu) objects into an ArrayList but but at the end of the code, my list is still empty. I've been looking on the net for an answer but all I find is "Write your objects in a collection then read the collection". But the file is already written and i need to find a way to put all the (Lieu) objects in a ArrayList.

Here's the writing Code (I can't modify it):

public static void main(String[] args) {
        Lieu<Double, String> p1;
        Lieu<Double, String> p2;
        Lieu<Double, String> p3;
        SegmentGeo<String> e1;
        SegmentGeo<String> e2;
        SegmentGeo<String> e3;
        Parcelle<String> p = new Parcelle<String>();
        ArrayList<Mesure<Point<Double>, String>> segs;
        p1 = new Lieu<Double, String>(45.573715, -73.900295, "p1");
        p2 = new Lieu<Double, String>(45.573882, -73.899748, "p2");
        p3 = new Lieu<Double, String>(45.574438, -73.900099, "p3");
        e1 = new SegmentGeo<String>(p1, p2, "Parcelle test");
        e2 = new SegmentGeo<String>(p2, p3, "Parcelle test");
        e3 = new SegmentGeo<String>(p3, p1, "Parcelle test");
        segs = new ArrayList<Mesure<Point<Double>, String>>();
        segs.add(e1);
        segs.add(e2);
        segs.add(e3);
        try {
            p.setMesures(segs);
        } catch (TrajectoireNonValideException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ObjectOutputStream ois = null;
        try {
            ois = new ObjectOutputStream(new FileOutputStream("essai.txt"));
            ois.writeObject(p.informationCumulee());
            ois.writeObject(p1);
            ois.writeObject(p2);
            ois.writeObject(p3);
        } catch (EOFException ex) {
            System.out.println("Fin de fichier atteinte.");
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

And here's what I'm trying to do:

public void actionPerformed(ActionEvent arg0) {
    JFileChooser chooser = new JFileChooser();
    int retour = chooser.showOpenDialog(getParent());
    if(retour==JFileChooser.APPROVE_OPTION){
          try{
       FileInputStream fis = new FileInputStream(chooser.getSelectedFile().getName());
       ObjectInputStream ois = new ObjectInputStream(fis);
       champNom.setText((String) ois.readObject());//that's just to display the name
       while (ois.available()!=0) 
       { 
            temp = (Lieu)ois.readObject();
            l.add(temp);
       }
       ois.close();
       System.out.print(l.size());//The size is 0
       }
       catch (FileNotFoundException e) {
           e.printStackTrace();
       }
       catch (IOException e) {
           e.printStackTrace();
       } 
       catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
     }

Answer 1

As Joetjah says, available() doesn't work like it sounds like.

One solution that is not super elegant but works surprisingly well is to just catch the Exception s which will be thrown when there is nothing left to read or another exception, as such:

    try {
        while (true)
            l.add((Lieu<Double,String>)ois.readObject());
    } catch (ClassNotFoundException | IOException e) {
        //Expecting a EOFException here
    } finally {
        try {
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Whenever there's an exception is thrown when reading (and at some point there will be one!), it will stop reading.

Answer 2

Available doesn't do what you think it does

available() does not return the amount of data left to be read, but the amount of data that can be read without blocking (pausing to wait for more data from the file/socket/database/etc.). In some cases this may return zero while there are still bytes that should be read - the 0 means that there are 0 bytes available right now (with no blocking). This may happen for various reasons - a hard drive may be busy repositioning its magnetic reader, or a network connection may be busy, or perhaps you're waiting for a user somewhere to type something before their information may be sent. Or it may be because the file you're reading really has no additional bytes to read, because you've reached the end. Using available() you have no way of knowing whether or not you should try to read the bytes anyway.

A more correct way to use a stream to copy a file is to check the return value of read for the end-of-file value (-1):

InputStream is = // some input
OutputStream os = // some output
byte buffer = new byte[1024];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {   
   os.write(buffer, 0, bytesRead);
}

When this code completes, you know that all the bytes really have been read and copied, because the while loop doesn't complete until read() returns -1, indicating the end of input.

Now, in your case, I'd advice to take it to some other direction, like this:

FileInputStream fis = new FileInputStream(chooser.getSelectedFile().getName());
ObjectInputStream ois = new ObjectInputStream(fis);
Object obj = ois.readObject();
while (obj != null) 
{ 
    champNom.setText((String)obj); 

    if (obj instanceof Lieu<Double, String>) 
        l.add(obj);

    obj = ois.readObject();
}
ois.close();
System.out.print(l.size());