Tech and Media Labs
This site uses cookies to improve the user experience.




Java IO: ObjectOutputStream

Jakob Jenkov
Last update: 2015-09-03

The Java ObjectOutputStream class (java.io.ObjectOutputStream) enables you to write Java objects to an OutputStream instead of just raw bytes. You wrap an OutputStream in a ObjectOutputStream and then you can write objects to it.

The Java ObjectOutputStream is often used together with a Java ObjectInputStream. The ObjectOutputStream is used to write the Java objects, and the ObjectInputStream is used to read the objects again. You will see an example of this later.

ObjectOutputStream Example

Here is a Java ObjectOutputStream example:

ObjectOutputStream objectOutputStream = 
    new ObjectOutputStream(new FileOutputStream("object.data"));

MyClass object = new MyClass();

output.writeObject(object);

output.close();

First this examples creates a OutputOutputStream connected to a FileOutputStream. Then the example creates a MyClass object and writes it to the ObjectOutputStream. Finally the example closes the ObjectOutputStream.

Before you can serialize and de-serialize objects the class of the object must implement java.io.Serializable. For more info, see Java Serializable.

Using an ObjectOutputStream With an ObjectInputStream

I promised earlier to show you an example of using the Java ObjectOutputStream with the ObjectInputStream. Here is that example:

import java.io.*;

public class ObjectInputStreamExample {

    public static class Person implements Serializable {
        public String name = null;
        public int    age  =   0;
    }


    public static void main(String[] args) throws IOException, ClassNotFoundException {

        ObjectOutputStream objectOutputStream =
            new ObjectOutputStream(new FileOutputStream("data/person.bin"));

        Person person = new Person();
        person.name = "Jakob Jenkov";
        person.age  = 40;

        objectOutputStream.writeObject(person);
        objectOutputStream.close();


        ObjectInputStream objectInputStream =
            new ObjectInputStream(new FileInputStream("data/person.bin"));

        Person personRead = (Person) objectInputStream.readObject();

        objectInputStream.close();

        System.out.println(personRead.name);
        System.out.println(personRead.age);
    }
}

This example first creates an ObjectOutputStream connected to a FileOutputStream. Then it creates a Person object and writes it to the ObjectOutputStream, and then closes the ObjectOutputStream.

Then the example creates an ObjectInputStream connected to the same file the ObjectOutputStream was connected to. The example then reads in an object from the ObjectInputStream and casts it to a Person object. After that the ObjectInputStream is also closed, and the values read into the Person object are printed to System.out.

The output printed from running this example should be:

Jakob Jenkov
40

Closing a ObjectOutputStream

When you are finished writing data to the ObjectOutputStream you should remember to close it. Closing a ObjectOutputStream will also close the OutputStream instance to which the ObjectOutputStream is writing.

Closing a ObjectOutputStream is done by calling its close() method. Here is how closing a ObjectOutputStream looks:

objectOutputStream.close();

You can also use the try-with-resources construct introduced in Java 7. Here is how to use and close a ObjectOutputStream looks with the try-with-resources construct:

OutputStream output = new FileOutputStream("data/data.bin");

try(ObjectOutputStream objectOutputStream =
    new ObjectOutputStream(output)){

    Person person = new Person();
    person.name = "Jakob Jenkov";
    person.age  = 40;
    
    objectOutputStream.writeObject(person);
}

Notice how there is no longer any explicit close() method call. The try-with-resources construct takes care of that.

Notice also that the first FileOutputStream instance is not created inside the try-with-resources block. That means that the try-with-resources block will not automatically close this FileOutputStream instance. However, when the ObjectOutputStream is closed it will also close the OutputStream instance it writes to, so the FileOutputStream instance will get closed when the ObjectOutputStream is closed.

Jakob Jenkov




Copyright  Jenkov Aps
Close TOC