ObjectInputStream not reading full file after appending data

Question

I am writing a small program that inserts customer details in ArrayList and write it in file.

The problem is with ObjectOutputStream I was able to append data in file with turning FileOutputStream("",true). But when I try to read data with ObjectInputStream it only reads data that was inserted at first instance. But data is being added to file.

Here is the code -

public void insertCustomer() throws IOException 
{       
        Customer1=new customerDetails("1", "Moeen4", "654654", "asdf", "coding", "student", "65464", "3210");
        Customer3=new customerDetails("3", "Moeen5", "888888", "asdf", "coding", "student2", "65464", "321022");
        Customer4=new customerDetails("4", "Moeen6", "654654", "asdf", "coding", "student", "65464", "7890");
        
        _list=new ArrayList<customerDetails>();
        _list.add(Customer1);
        _list.add(Customer3);
        _list.add(Customer4);
        
        customersList cl=new customersList();
        
        cl.WriteObjectToFile(files._customers, _list);
        
        ArrayList<customerDetails>li=new ArrayList<customerDetails>();
        li= (ArrayList) cl.ReadObjectFromFile(files._customers);           
        for(int i=0;i<li.size();i++)
        {   System.out.println(li.size());
            System.out.println(li.get(i).Id);
            System.out.println(li.get(i).name);
            System.out.println(li.get(i).annual_Salary);
            System.out.println(li.get(i).Company);
            System.out.println(li.get(i).dateOfBirth);
            System.out.println(li.get(i).phone_Number);
        }
    }


public void WriteObjectToFile(String filepath,Object serObj) {       
    try {
        
        FileOutputStream fileOut = new FileOutputStream(filepath,true);
        ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);
        objectOut.writeObject(serObj);
        objectOut.close();
        System.out.println("The Object  was succesfully written to a file");

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

public Object ReadObjectFromFile(String filepath) {      
    try {

        FileInputStream fileIn = new FileInputStream(filepath);
        ObjectInputStream objectIn = new ObjectInputStream(fileIn);

        Object obj = objectIn.readObject();
        objectIn.close();
        System.out.println("The Object has been read from the file");
        
        return obj;

    } catch (Exception ex) {
        ex.printStackTrace();
        return null;
    }
}

Answer 1

The real problem here is this:

  FileOutputStream fileOut = new FileOutputStream(filepath, true);
  ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);
  objectOut.writeObject(serObj);

You cannot append to an existing serialization like this. If you do get an exception when attempting to read any objects appended to a pre-existing (non-empty) file.

There is a trick / hack that allows you to append objects though; see Appending to an ObjectOutputStream. (The trick involves suppressing the writing of the object stream header. It is most easily done by overriding the method that does this.)

The other approach is to keep the ObjectOutputStream open between writeObject calls. However there are use-cases where that won't be possible.

Note that there is a semantic difference between these two approaches. The best way to explain it is that the first one behaves as if you called reset() each time you write an object; see the javadoc.

---

Another thing to note about your example is that your reader code only reads one object. If you want to read multiple objects, you need to call readObject in a loop. And that will only work if you have used the trick / hack above to avoid writing a spurious header.

Answer 2

As suggested the code is only reading the first object and you would need to use a loop to read all the objects from multiple writes.

However -

If you change the above code i.e. ReadObjectFromFile to use a loop this will lead to an StreamCorruptedException: invalid type code: AC. The ObjectOutputStream constructor writes a serialization stream header to the OutputStream i.e. the file, when it is closed and reopend using new ObjectOutputStream and new FileOutputStream(filepath, true) a new header will be written at the append point so you will get an exception as the header is only expected once at the beginning of the file

This will need to be handled e.g.

• Use the same ObjectOutputStream for the duration
• Override java.io.ObjectOutputStream.writeStreamHeader() to account for append to a file
• Change the approach and use List<List<Object>> which you could read, add, write to as a whole.

Loop example would throw exception unless ObjectOutputStream approach is changed

public Object ReadObjectFromFile(String filepath) {
    
    List<List<Object>> objects = new ArrayList<>();
    
    FileInputStream fileIn = new FileInputStream(filepath);
    ObjectInputStream objectIn = new ObjectInputStream(fileIn);
    
    try {
        while (true) {
            List<Object> obj = (List<Object>) objectIn.readObject();
            // This will throw StreamCorruptedException: invalid type code: AC
            objects.add(obj);
            System.out.println("The Object has been read from the file");                
        }
    } catch (EOFException ex) {
        // ENDS WHEN ALL READ
    } finally {
        fileIn.close();
        objectIn.close();
    }
    
    return objects;
}

Sudo code List<List<Object>> approach -

public void readAndWrite() {
    List<Object> customer = List.of(new CustomerDetails(...),
                                    new CustomerDetails(...),
                                    new CustomerDetails(...));
    
    List<List<Object>> objects = readFromFile("existing-customer-file.txt");

    objects.addAll(customer);
    
    writeObjectToFile(objects);
}