Java - ObjectOutputStream writeFields() method

Description

The Java ObjectOutputStream writeFields() method writes the buffered fields to the stream.

• writeFields() is used inside a custom writeObject(ObjectOutputStream oos) method of a Serializable class.

• It's used after calling putFields() to specify which fields to serialize manually.

• This gives you full control over what gets serialized, without relying on default serialization.

• It's useful when you want to−

  • Skip fields.

  • Add derived/calculated fields.

  • Handle versioning.

Declaration

Following is the declaration for java.io.ObjectOutputStream.writeFields() method.

public void writeFields()

Parameters

NA

Return Value

This method does not return a value.

Exception

• IOException − If I/O errors occur while writing to the underlying stream.

• NotActiveException − Called when a classes writeObject method was not called to write the state of the object.

Example - Usage of ObjectOutputStream writeFields() method

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

ObjectOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.io.Serializable;

public class ObjectOutputStreamDemo {
   public static void main(String[] args) {
      double d = 1.59875d;
      
      try {
         // create a new file with an ObjectOutputStream
         FileOutputStream out = new FileOutputStream("test.txt");
         ObjectOutputStream oout = new ObjectOutputStream(out);

         // write something in the file
         oout.writeObject(new Example());
         oout.flush();
         oout.close();

         // create an ObjectInputStream for the file we created before
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.txt"));

         // read an object from the stream and cast it to Example
         Example a = (Example) ois.readObject();

         // print var of a
         System.out.println("" + a.var);
      } catch (Exception ex) {
         ex.printStackTrace();
      }
   }

   static public class Example implements Serializable {
      static int var = 76458;
      
      // assign a new serialPersistentFields 
      private static final ObjectStreamField[] serialPersistentFields = {
         new ObjectStreamField("var", Integer.TYPE)
      };

      private void readObject(ObjectInputStream in)
         throws IOException, ClassNotFoundException {

         // get the field and assign it at var
         ObjectInputStream.GetField fields = in.readFields();

         // get var
         var = fields.get("var", 0);
      }

      private void writeObject(ObjectOutputStream out) throws IOException {

         // write into the ObjectStreamField array the variable string
         ObjectOutputStream.PutField fields = out.putFields();
         fields.put("var", var);
         out.writeFields();
      }
   }
}

Output

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

76458

Example - Serialize only selected fields manually using putFields() and writeFields()

The following example shows the usage of ObjectOutputStream writeFields() method. We're writing name, and skipping password.

ObjectOutputStreamDemo.java

package com.tutorialspoint;

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

public class ObjectOutputStreamDemo {
   public static void main(String[] args) throws IOException {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user1.ser"))) {
         User user = new User("alice", "secret123");
         oos.writeObject(user);
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user1.ser"));
         User u1 = (User)ois.readObject();
         System.out.println("User: name=" + u1.name +", password=" +u1.password);
      }catch (ClassNotFoundException cne){
         cne.printStackTrace();
      }
   }

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

      String name;
      String password;

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

      private void writeObject(ObjectOutputStream oos) throws IOException {
         ObjectOutputStream.PutField fields = oos.putFields();
         fields.put("name", name);         // Only write 'name'
         // password is intentionally not written
         oos.writeFields();
      }
   }
}

Output

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

User: name=alice, password=null

Explanation

• We manually control what's serialized.

• password is excluded for security.

Example - Add a derived fullName field during serialization

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

ObjectOutputStreamDemo.java

package com.tutorialspoint;

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

public class ObjectOutputStreamDemo {
   public static void main(String[] args) throws IOException {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person2.ser"))) {
         Person person = new Person("John", "Doe");
         oos.writeObject(person);

         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person2.ser"));
         Person p = (Person)ois.readObject();
         System.out.println(" User:: firstName = " + p.firstName + " ; lastName = " + p.lastName + "; fullName = " + p.fullName);
      }catch(ClassNotFoundException ce){
         ce.printStackTrace();
      }
   }

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

      String firstName;
      String lastName;
      String fullName;

      public Person(String firstName, String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
      }

      private void writeObject(ObjectOutputStream oos) throws IOException {
         fullName = firstName + " " + lastName;  
         ObjectOutputStream.PutField fields = oos.putFields();
         fields.put("firstName", firstName);
         fields.put("lastName", lastName);
         fields.put("fullName", fullName);
         oos.writeFields();
      }
   }
}

Output

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

User:: firstName = John ; lastName = Doe; fullName = John Doe

Explanation

• Field fullname is not written during writeObject(), but added with "fields.put:".