Java: OutOfMemory exception when trying to read objects from a very large file

I have saved almost 10k objects in a file using this code below:

boolean exists = Tools.getDeviceInfo().exists();
        FileOutputStream fos = new FileOutputStream(Tools.getDeviceInfo(), true);
        ObjectOutputStream oos = exists ?
                new ObjectOutputStream(fos) {
                    protected void writeStreamHeader() throws IOException {
                        reset();
                    }
                }:new ObjectOutputStream(fos);
        oos.writeObject(deviceInfos);

Now when I'm trying to read the file it is throwing OutOfMemory exception. How I can resolve this. Below is the code for reading objects.

FileInputStream fis = new FileInputStream(Tools.getDeviceInfo());
        ObjectInputStream ois = new ObjectInputStream(fis);
        ArrayList<DeviceInfo> arrayList = new ArrayList<>();
        try {
            arrayList.addAll((ArrayList<DeviceInfo>)ois.readObject());
        } catch (Exception e) {
            e.printStackTrace();
        }
        ois.close();
        return arrayList;

The reason i want to read all objects is I want to show all the data in tableview so i need to add all the (10k rows) into arraylist and show it on tableview.
Is there any option to limit the readObject(), so it can only retrieve few objects from a very large file.
How I can improve this? Please help.

You're serializing and deserializing the entire collection in one go. If you write the individual objects (rather than the containing ArrayList) you'd be able to read a range at a time.

You are kind of stuffed here.

It looks like you have put all of the objects into a list and then saved the list to the file using a single writeObject call.

If you do that, you don't have any real choice but to read back the entire list. I guess, conceivably, you could implement a hack (with custom read object methods or similar) to "read" the unwanted DeviceInfo objects as null to save space. But that is liable to have down-sides.

One solution is to serialize the original list by serializing the elements individually. Then you can read them back one at a time, and ignore the ones that you don't want. It is not efficient, but you should be able to avoid filling the heap with objects that are not currently needed.

A better solution would be to use another method of saving the data:

• You could use an RDBMS, a NoSQL database or a flat-file database (like BerkleyDB) and select just the rows that you want to display.

• You could use another serialization format such as JSON, XML or CSV which has a streaming API. Then you stream the entire file and only reify the elements you want to display.

A database of some kind would be preferable.

In order to read 10k objects from a file please try to use java.util.scanner

FileInputStream fInputStream = null;
	Scanner scanner = null;
	try {
	    fInputStream = new FileInputStream(path);//file path
	    scanner = new Scanner(fInputStream, "UTF-8");
		 ArrayList<DeviceInfo> arrayList = new ArrayList<>();
	    while (scanner.hasNextLine()) {
	    DeviceInfo dObj = new DeviceInfo();
	    dObj = scanner.nextLine();
		arrayList.addall(dObj);
	    }
	    // note that Scanner suppresses out of memory exception
	    if (scanner.ioException() != null) {
	        throw scanner.ioException();
	    }
	} finally {
	    if (fInputStream != null) {
	    	fInputStream.close();
	    }
	    if (scanner != null) {
	        scanner.close();
	    }
    	}

The above code will help to process lines(one object each line) in a large file without iteratively, without exhausting the available memory.