Java - ObjectOutputStream class

---

---

Introduction

The Java ObjectOutputStream class writes primitive data types and graphs of Java objects to an OutputStream.The objects can be read (reconstituted) using an ObjectInputStream.

Class declaration

Following is the declaration for Java.io.ObjectOutputStream class −

public class ObjectOutputStream
   extends OutputStream
      implements ObjectOutput, ObjectStreamConstants

Class constructors

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.io.Object

Example - Properly closing ObjectOutputStream

The following example shows the usage of ObjectOutputStream close() method. We're properly closing ObjectOutputStream after writing an object.

ObjectOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectOutputStreamDemo {
   public static void main(String[] args) {
      String filename = "person1.ser";

      try {
         FileOutputStream fos = new FileOutputStream(filename);
         ObjectOutputStream oos = new ObjectOutputStream(fos);

         Person person = new Person("Alice", 30);
         oos.writeObject(person);

         // Close the stream
         oos.close();
         System.out.println("ObjectOutputStream closed after writing object.");
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   static class Person implements Serializable {
      String name;
      int age;
      Person(String name, int age) {
         this.name = name;
         this.age = age;
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

ObjectOutputStream closed after writing object.

Explanation

• We're serializing a Person object and explicitly calls close() on the ObjectOutputStream.

• Closing the stream flushes the data and releases system resources.

Example - Usage of ObjectOutputStream defaultWriteObject() method

The following example shows the usage of ObjectOutputStream defaultWriteObject() method.

ObjectOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectOutputStreamDemo {
   public static void main(String[] args) throws Exception {
      String file = "user1.ser";

      // Serialize the object
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
         User user = new User("Alice", "secret123");
         oos.writeObject(user);
      }

      System.out.println("User object serialized.");
   }

   static class User implements Serializable {
      private static final long serialVersionUID = 1L;

      String username;
      transient String password; // transient field won't be serialized by default

      User(String username, String password) {
         this.username = username;
         this.password = password;
      }

      // Custom serialization
      private void writeObject(ObjectOutputStream oos) throws IOException {
         oos.defaultWriteObject(); // writes non-transient fields
         oos.writeUTF(password);   // manually write the transient field
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

User object serialized.

Explanation

• username is serialized normally via defaultWriteObject().

• password is transient, so we manually write it after.

Example - Using drain() method before writing a second object

The following example shows the usage of ObjectOutputStream drain() method. We're writing multiple objects to a file then using drain() method between them to ensure any buffered data is cleared before writing the next one.

ObjectOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ObjectOutputStreamDemo extends ObjectOutputStream {

   public ObjectOutputStreamDemo(OutputStream out) throws IOException {
      super(out);
   }

   public static void main(String[] args) {
      String filename = "drain_multiple_objects.ser";

      try (FileOutputStream fos = new FileOutputStream(filename);
         ObjectOutputStreamDemo oos = new ObjectOutputStreamDemo(fos)) {

         // Write first object
         oos.writeObject("First object");
         System.out.println("First object written.");

         // Drain buffered data (but do not flush underlying stream)
         oos.drain();
         System.out.println("Buffer drained.");

         // Write second object
         oos.writeObject("Second object");
         System.out.println("Second object written.");

      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

First object written.
Buffer drained.
Second object written.

Explanation

• We subclass ObjectOutputStream to access the protected drain() method.

• We write "First object", then call drain() - this flushes the internal buffer only, not the file stream.

• Then we write "Second object".