Difference Between ObjectInputStream and ObjectOutputStream in Java - GeeksforGeeks

29 Oct, 2021
In a software project, in many instances, there are necessities to transfer the data, and it can be handled by using ObjectOutputStream and ObjectInputStream from Java IO packages. Usually, the data is written in binary format and hence we cannot view the contents. Serialization is the process of writing an object to an output stream. We can write a class object itself, which contains a combination of primitive datatype and graphs of Java objects. Deserialization is the process of reconstructing an object from an input stream.
Implementation: Let us see the ObjectOutputStream with an is illustrated for which we create a POJO class called “VehicleSpecifications”. 
Note: It should implement Serializable, otherwise, java.io.NotSerializableException will be thrown.
Example 1:
Java
// Java Program simply illustrating POJO / Model class // Importing input output classimport java.io.Serializable; // Class 1// Implements Serializable  for POJO class to aavoid// NotSerializableException will be thrownpublic class VehicleSpecifications implements Serializable {     // Member variables of this class    private String color;    private String type;    private String name;    private double price;     // Constructors of this class     // Constructor- 1    // Default constructor    public VehicleSpecifications() {}     // Constructor- 2    // Parameterized constructor accepting all attributes and    // helps to create a VehicleSpecifications class    public VehicleSpecifications(String color, String type,                                 String name, double price)    {         // This keyword refers to current object itself        this.color = color;        this.type = type;        this.name = name;        this.price = price;    }     // Methods of this class    // Specfically  Getter and Setter methods     // Method 1    public double getPrice() { return price; }     // Method 2    public void setPrice(double price)    {        this.price = price;    }     // Method 3    public String getName() { return name; }     // Method 4    public void setName(String name) { this.name = name; }     // Method 5    public String getColor() { return color; }     // Method 6    public void setColor(final String color)    {        this.color = color;    }     // Method 7    public String getType() { return type; }     // Method 8    public void setType(final String type)    {        this.type = type;    }}
  
No output is as till now by far we have implemented just the constructors and defined body of methods including getters and setters. 
Now let us create a few vehicle specifications and write them in a file. As VehicleSpecifications implemented Serializable functionality, the data can be written to a file in a binary format. For this we will be using “writeObject” function and by using that we can write class attributes using write methods provided by ObjectOutputStream.
 
Example 2:
 
Java
// Class 2// Java Program to Create Few VehicleSpecifcation and// Writing in a File // Importing required classes from packagesimport java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectOutputStream;import java.util.ArrayList;import java.util.List; // Main classpublic class VehicleSpecificationsSerializer {     // main driver method    public static void main(String[] args)    {         // Output file been passed in a string        String sampleOutputFile = "VehicleSpecifcation.db";         // Try block to check for exceptions        try {             // Create a objectoutputstream accepting the            // file name as VehicleSpecifcation.db            ObjectOutputStream vehicleObjectOutput                = new ObjectOutputStream(                    new FileOutputStream(sampleOutputFile));             // Create a list of VehicleSpecifications class            List<VehicleSpecifications> listSpecifications                = new ArrayList<VehicleSpecifications>();             // Add the necessary data using standard add()            // method Custom input            listSpecifications.add(                new VehicleSpecifications("Radiant Red",                                          "SUV", "WR-V",                                          1700000f));             listSpecifications.add(                new VehicleSpecifications("Metallic Blue",                                          "SUV", "WR-V",                                          1800000f));             listSpecifications.add(                new VehicleSpecifications(                    "Black", "SUV", "WR-V", 1900000f));             // We are writing the whole object into the file            // which is a list item of VehicleSpecifications            // object            vehicleObjectOutput.writeObject(                listSpecifications);             // Closing the connection to release memory            vehicleObjectOutput.close();        }         // Catch block to handle the exceptions        catch (IOException ex) {             // Print the exceptions along with line number            // using printStackTrace() method            ex.printStackTrace();        }    }}
  
Note: On execution of the above code, we can see that the data is written in a binary format that means, it is a non-readable format only.
 
So In order to get the data in a readable format, we are using ObjectInputStream and as we have to retrieve the class object data(i.e. VehicleSpecifications data), we need to use readObject() method, which can read class attributes using read() methods provided by ObjectInputStream.
 
Example 3:
 
Java
// Java Program to make above code human-readable // Importing classes from required packagesimport java.io.FileInputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.util.ArrayList;import java.util.List; // Main classpublic class VehicleSpecificationsDeSerializer {     // main driver method    public static void main(String[] args)    {         // Input file        String sampleInputFile = "VehicleSpecifcation.db";         // Try block to check for exceptions        try {             // Creating an object of ObjectInputStream class            ObjectInputStream vehicleObjectInputStream                = new ObjectInputStream(                    new FileInputStream(sampleInputFile));             // Creating a List class object            // Declaring object of user defined type            // (VehicleSpecifications)            List<VehicleSpecifications>                vehicleSpecificationsListData                = new ArrayList<VehicleSpecifications>();             // Using readObject, bringing back the whole            // list item of VehicleSpecifications into scope             // readObject which can read class attributes            // using read methods provided by            // ObjectInputStream.            vehicleSpecificationsListData                = (ArrayList<VehicleSpecifications>)                      vehicleObjectInputStream.readObject();             // Iterating over above object created            for (int i = 0;                 i < vehicleSpecificationsListData.size();                 i++) {                 VehicleSpecifications vehicleSpecifications                    = vehicleSpecificationsListData.get(i);                 // Print and display commands                System.out.println(                    "Color .."                    + vehicleSpecifications.getColor());                System.out.println(                    "Name .."                    + vehicleSpecifications.getName());                System.out.println(                    "Price .."                    + vehicleSpecifications.getPrice());                System.out.println(                    "Type .."                    + vehicleSpecifications.getType());            }            // Closing the resources to free up memory space            vehicleObjectInputStream.close();        }         // Catch block to handle the exceptions         // Catch block 1        // Handling input output  exceptions        catch (IOException ex) {             // Printing the line number where exception            // occured using printStackTrace() method            ex.printStackTrace();        }         // Catch block 2        // Handle exception if class not found        catch (ClassNotFoundException e) {             // Again, printing the line number where            // exception occured using printStackTrace()            // method            e.printStackTrace();        }    }}
  
Output:
 
 
Output explanation:
 
So, we are seeing the output in a human-readable format. So our entire set of class objects can be portable using ObjectInput and ObjectOutput streams provided by java.io packages. Hence, now let us finally discuss out the differences between ObjectOutputStream and ObjectInputStream after having an internal workflow understanding of them. They are illustrated below in a tabular format shown as below:
 
Not only writing class objects by means writeObject(), it also supports other write methods like as depicted below and many more methods to write for each and every data type.
 write(byte[] buffer)-> Writes an array of bytes.
writeBoolean(boolean value) -> Write boolean value
writeDouble(double value)-> Write 64 bit double value
writeInt(int value)-> Writes 32 bit int 
Not only reading class objects by means readObject(), it also supports other read methods like depicted as below and many more methods to read each and every datatype.
read()-> Reads byte of data
readBoolean() -> To read  a boolean.
readDouble()-> To read a 64 bit double.
readInt()->To Read a 32 bit int.
Possible exceptions for ObjectOutputStream is as follows:
IOException – in case of any I/O error occurs during writing stream header
SecurityException 
NullPointerException – if OutputStream not initialized and hence it may be null
Possible exceptions for ObjectInputStream is as follows:
StreamCorruptedException – Incorrect stream header
IOException – In case of any I/O error occurs while reading stream header
SecurityException 
NullPointerException – if Inputstream not initialized and hence it may be null
Possible exceptions for writeObject is as follows:
InvalidClassException – Serialization of class should be correct and if something is wrong.
NotSerializableException – Some object to be serialized does not implement the java.io.Serializable interface. This will commonly occur and hence it is mandatory to make the class to implement Serializable
IOException – During writing, if IO error occur by the underlying OutputStream.
Possible exceptions for readObject is as follows:
InvalidClassException – Serialization of class should be correct and if something is wrong.
ClassNotFoundException – Class of a serialized object should be available and if cannot be found.
IOException – During reading, if IO error occur by the underlying InputStream
StreamCorruptedException 
OptionalDataException 
 
adnanirshad158
saurabh1990aror
surinderdawra388
simmytarika5
varshagumber28
java-stream
Picked
Difference Between
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Difference between var, let and const keywords in JavaScript
Difference Between Method Overloading and Method Overriding in Java
Difference between Prim's and Kruskal's algorithm for MST
Difference between Internal and External fragmentation
Differences and Applications of List, Tuple, Set and Dictionary in Python
Arrays in Java
Split() String method in Java with examples
For-each loop in Java
Arrays.sort() in Java with examples
Reverse a string in Java