Java - ObjectOutputStream.PutField put(String name, short val) method

---

---

Description

The Java ObjectOutputStream.PutField put(String name, short val) method puts the value of the named short field into the persistent field.

• It's used within a custom writeObject(ObjectOutputStream oos) method.

• Assigns a short value to a named field.

• You must call oos.writeFields() afterward to write the field data to the stream.

Declaration

Following is the declaration for java.io.ObjectOutputStream.PutField.put(String name, short val) method.

public abstract void put(String name, short val)

Parameters

• name − The name of the serializable field.

• val − The value to assign to the field.

Return Value

This method does not return a value.

Exception

• IllegalArgumentException − If name does not match the name of a serializable field for the class whose fields are being written, or if the type of the named field is not short.

Example - Usage of ObjectOutputStream.PutField put(String name, short val) method

The following example shows the usage of ObjectOutputStream.PutField put(String name, short val) 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 implements Serializable {
   public static void main(String[] args) {
      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 short var = 5;
      
      // assign a new serialPersistentFields 
      private static final ObjectStreamField[] serialPersistentFields = {
         new ObjectStreamField("var", Short.TYPE)
      };

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

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

         // get var
         short d = 87;
         var = fields.get("var", d);
      }

      private void writeObject(ObjectOutputStream out) throws IOException {

         // write into the ObjectStreamField array the variable var
         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 −

5

Example - Serialize a Packet with a short type code

The following example shows the usage of ObjectOutputStream.PutField put(String name, short val) method. We're using put() to store a short type code (e.g., protocol ID).

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, ClassNotFoundException {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("packet1.ser"))) {
         Packet p = new Packet("Ping", (short) 200);
         oos.writeObject(p);

         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("packet1.ser"));
         Packet p1 = (Packet)ois.readObject();
         System.out.println("Packet:: message = '" + p1.message + "'; typeCode = " + p1.typeCode);
      }
   }

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

      String message;
      short typeCode;

      public Packet(String message, short typeCode) {
         this.message = message;
         this.typeCode = typeCode;
      }

      private void writeObject(ObjectOutputStream oos) throws IOException {
         ObjectOutputStream.PutField fields = oos.putFields();
         fields.put("message", message);
         fields.put("typeCode", typeCode); //  manually write short field
         oos.writeFields();
      }

      private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
         ObjectInputStream.GetField fields = ois.readFields();
         message = (String) fields.get("message", "none");
         typeCode = fields.get("typeCode", (short) -1);
      }
   }
}

Output

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

Packet:: message = 'Ping'; typeCode = 200

Explanation

• The short field typeCode is manually serialized using put().

• It's useful for network-related or compact binary protocols.

Example - Conditionally write a short access level

The following example shows the usage of ObjectOutputStream.PutField put(String name, short val) method. We're writing a short access level based on a user's role.

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("user_access.ser"))) {
         User u = new User("admin");
         oos.writeObject(u);
      }

      // Read and display
      try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user_access.ser"))) {
         User u = (User) ois.readObject();
         System.out.println("User role: " + u.role + ", access level: " + u.accessLevel);
      } catch (ClassNotFoundException e) {
         e.printStackTrace();
      }
   }

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

      String role;
      short accessLevel;  // Derived during serialization

      public User(String role) {
         this.role = role;
      }

      private void writeObject(ObjectOutputStream oos) throws IOException {
         ObjectOutputStream.PutField fields = oos.putFields();
         fields.put("role", role);
         short level = switch (role) {
            case "admin" -> 10;
            case "editor" -> 5;
            default -> 1;
         };
         fields.put("accessLevel", level); // computed short field
         oos.writeFields();
      }

      private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
         ObjectInputStream.GetField fields = ois.readFields();
         role = (String) fields.get("role", "guest");
         accessLevel = fields.get("accessLevel", (short) 0);
      }
   }
}

Output

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

User role: admin, access level: 10