Java IO Tutorial

How to read and write Java object to a file

Java object Serialization is an API provided by Java Library stack as a means to serialize Java objects. Serialization is a process to convert objects into a writable byte stream. Once converted into a byte-stream, these objects can be written to a file. The reverse process of this is called de-serialization.

A Java object is serializable if its class or any of its superclasses implement either the java.io.Serializable interface or its subinterface, java.io.Externalizable.

1. Java Object

Person.java

package com.mkyong;

import java.io.Serializable;

public class Person implements Serializable {

	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private String gender;

	Person() {
	};

	Person(String name, int age, String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Name:" + name + "\nAge: " + age + "\nGender: " + gender;
	}
}

2. Writing and Reading objects in Java

The objects can be converted into byte-stream using java.io.ObjectOutputStream. In order to enable writing of objects into a file using ObjectOutputStream, it is mandatory that the concerned class implements Serializable interface as shown in the class definition below.

Reading objects in Java are similar to writing object using ObjectOutputStreamObjectInputStream. Below example shows the complete cycle of writing objects and reading objects in Java.

On reading objects, the ObjectInputStream directly tries to map all the attributes into the class into which we try to cast the read object. If it is unable to map the respective object exactly then it throws a ClassNotFound exception.

Let us now understand the writing and reading process using an example. We are using the Person class shown above as an object.

WriterReader.java

package com.mkyong;

package com.mkyong;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class WriterReader {

	public static void main(String[] args) {

		Person p1 = new Person("John", 30, "Male");
		Person p2 = new Person("Rachel", 25, "Female");

		try {
			FileOutputStream f = new FileOutputStream(new File("myObjects.txt"));
			ObjectOutputStream o = new ObjectOutputStream(f);

			// Write objects to file
			o.writeObject(p1);
			o.writeObject(p2);

			o.close();
			f.close();

			FileInputStream fi = new FileInputStream(new File("myObjects.txt"));
			ObjectInputStream oi = new ObjectInputStream(fi);

			// Read objects
			Person pr1 = (Person) oi.readObject();
			Person pr2 = (Person) oi.readObject();

			System.out.println(pr1.toString());
			System.out.println(pr2.toString());

			oi.close();
			fi.close();

		} catch (FileNotFoundException e) {
			System.out.println("File not found");
		} catch (IOException e) {
			System.out.println("Error initializing stream");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

On executing the above code, we get below output:


Name:John
Age: 30
Gender: Male
Name:Rachel
Age: 25
Gender: Female

References

  1. Serialization Java Docs
  2. ObjectInputStream Java Docs
  3. ObjectOutputStream Java Docs

About Author

author image
A technically sound person, oriented towards learning things logically rather than technically. It is my logical approach that has helped me learn and take up any programming language and start with coding. With a responsibility of Java based Web development professionally, I highly believe in imparting knowledge online for any technical subject that I can handle.

Comments

Subscribe
Notify of
17 Comments
Most Voted
Newest Oldest
Inline Feedbacks
View all comments
Rechilar
5 years ago

great tutorial that is easy to understand for beginners

Reeshabh Ranjan
6 years ago

Oh my God, you have the best tutorials out of everyone on the first search result page of Google. Awesome!

Parth
2 years ago

Thanks a lot for providing the easiest to understand tutorial on the web!

Maheshwaran E
4 years ago

If i open the app, store some data and closing that app…when i return to the app, i need to resume my work…how to achieve this? Please explain

Parth
2 years ago
Reply to  Maheshwaran E

Save it to a file….then read it back when the app is re-opened

Lalit
4 years ago

Suppose I wrote some serialized content to a file and then later on I want to read it using deserialization but before reading it some of the values of the actual object that I wrote to file have been changed. How can I handle this so that the object and file are always in sync. Do I need to keep writing to file again and again or is there any other alternative ?

martin
4 years ago

this is very good!! thanks!!

Arsalan
1 year ago

how can I use only one object, to write multiple states of one objects in a file.
like using a for loop.
eg:
for(int I=0;I<3;i++){

// initialise p1 here.

o.writeobject(p1);

}

is there a way to do it like this.

Douglas
2 years ago

simple and to the point, kudos

Abdullah Shahid
2 years ago

What if i want to store multiple objects from arraylist of objects and read multiple objects into arraylist of objects?
can someone please modify the program?

Kittu
3 years ago

we’ll use serialization mostly over the network not in local 🙂
Do we have any example over network(Data transmission)

Last edited 3 years ago by Kittu
charles
4 years ago

This code was working for me, then it decided to throw the IOException for the ObjectInputStream, do you know why this could occur?

klauss
2 years ago
Reply to  charles

Don’t know if it is because the object variables (fields) are all in lowercase when the object is serializing them with first letters in uppercase… How it will assoc them right when unserializing?

Looks like it’s more convenient using native Property read/write mechanisms (since JDK 1.0)…

package Stuff;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

Properties props = new Properties();

// Setting
props.setProperty("property", "value");

// Getting
props.getProperty("property");

// Saving
props.store(new FileOutputStream("path/to/file.properties"), "");

// Loading
props.load(new FileInputStream("path/to/file.properties"));

// Iterating
props.foreach
(
   function ( key, value )
   {
      System.out.println("Object Key: " + key + "\n" + "Object Value: " + value);
   }
)

// Iterating (short version)
props.foreach( (key, value) -> System.out.println("Object Key: " + key + "\n" + "Object Value: " + value) );
Santa Claus
4 years ago
Reply to  charles

You need to implement Serializable in your object class.

Ron Breier
5 years ago

This could be much more useful to show how an object that is NOT serializable can be written to file then read back in another JVM. This is just calling the toString method and outputting that to a file. If the object changes and the toString does not get updated, data will be loss. Plus you will have to parse the string to read it like this.

I often encounter java classes in external sources that I can not just annotate as serializable. There are complex objects that would save a lot of time when I just dump the JSON into a file, make a small change, then reboot the project and import that complex object.

Lito
5 years ago

how can you find a person from the file by their name

Guy Upton
5 years ago
Reply to  Lito

Take the file into your program and then search through it