Difference Between ObjectInputStream and ObjectOutputStream in Java
Last Updated :
06 Jan, 2023
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 class
import java.io.Serializable;
// Class 1
// Implements Serializable for POJO class to avoid
// NotSerializableException will be thrown
public 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
// Specifically 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 VehicleSpecification and
// Writing in a File
// Importing required classes from packages
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
// Main class
public class VehicleSpecificationsSerializer {
// main driver method
public static void main(String[] args)
{
// Output file been passed in a string
String sampleOutputFile = "VehicleSpecification.db";
// Try block to check for exceptions
try {
// Create a objectoutputstream accepting the
// file name as VehicleSpecification.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 packages
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
// Main class
public class VehicleSpecificationsDeSerializer {
// main driver method
public static void main(String[] args)
{
// Input file
String sampleInputFile = "VehicleSpecification.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
// occurred using printStackTrace() method
ex.printStackTrace();
}
// Catch block 2
// Handle exception if class not found
catch (ClassNotFoundException e) {
// Again, printing the line number where
// exception occurred 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:
ObjectOutputStream | ObjectInputStream |
---|
Writes Java objects | Reads Java objects |
Using ArrayList, we can write multiple Java objects | Via ArrayList, we can read and retrieve multiple Java objects |
By default, ArrayList is serializable, and hence no need to implement serializable if we are writing ArrayList of objects like String, but the elements should be serializable. writeObject() is used to write ArrayList of data | During deserialization of ArrayList object, readObject() is used to read the ArrayList of data |
If we are using a class object(like the example as we discussed above), the class should implement serializable and then only while using writeObject() method, java.io.NotSerializableException will not be thrown | We need to cast the same format of object while using readObject() |
writeObject() method writes the serialized data in binary format | readObject() method deserializes and reads the data |
The binary format is not readable. Though we are passing primitive data like String, double, etc., while writing, the data is getting stored in binary format. | In order to get the data in perfect class format, we need to use ObjectInputStream which deserializes data and we can get all primitive data that is written |
As a whole object, it is getting written, there is no loss of data provided the object is serialized and written in a proper format | Similarly, whole object is read, there is no loss of data, and we can easily iterate the data also. |
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
|
Similar Reads
Difference Between FileInputStream and ObjectInputStream in Java
FileInputStream class extracts input bytes from a file in a file system. FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams of characters, consider using FileReader. It should be used to read byte-oriented data for example to read audio, video, images,
5 min read
Difference Between ZipFile and ZipInputStream in Java
Zip files are basically an archive file that is used to compress all the files in one place. Doing this reduces memory space occupied and makes transport of files bundle easy. ZipInputStream which are used to read the file entries in zip files present in the zip. In Java, there are two classes namel
5 min read
Difference between Stream.of() and Arrays.stream() method in Java
Arrays.stream() The stream(T[] array) method of Arrays class in Java, is used to get a Sequential Stream from the array passed as the parameter with its elements. It returns a sequential Stream with the elements of the array, passed as parameter, as its source. Example:Â Java // Java program to demo
5 min read
Difference Between Object and Instance in Java
The object is an instance of a class. A class is like a blueprint or template that defines the properties and behavior of objects. When we create an object we are creating an instance of that class. Object in JavaThe object is an instance of a class. A class is a blueprint or template that describes
3 min read
Difference between List, Set and Map in Java
List interface in Java is a sub-interface of the Java collections interface. It contains the index-based methods to insert, update, delete, and search the elements. It can have duplicate elements also. We can also store the null elements in the list. List preserves the insertion order, it allows pos
4 min read
Difference Between System.out.println() and System.err.println() in Java
System.out is a PrintStream to which we can write characters. Â It outputs the data we write to it on the Command Line Interface console/terminal. It is mostly used for console applications/programs to display the result to the user. It can be also useful in debugging small programs. Syntax: System.o
2 min read
Difference Between map() And flatMap() In Java Stream
In Java, the Stream interface has a map() and flatmap() methods and both have intermediate stream operation and return another stream as method output. Both of the functions map() and flatMap are used for transformation and mapping operations. map() function produces one output for one input value,
3 min read
Difference between Input and Output Interface Unit
Computer system operates the computation on the digital signals but the user sends analog signals to the computer system. Interface Units are basically used for the conversion of the signals in the computer system so that mutual communication and understanding can be established between environment
2 min read
Difference Between FileInputStream and FileReader in Java
Let us first do discuss them in order to get the understanding alongside an example to interpret the differences. Here first we will be discussing out FileReader class. So starting of with FileReader class in java is used to read data from the file. It returns data in byte format like FileInputStrea
4 min read
Difference Between Streams and Collections in Java
Collection is an in-memory data structure, which holds all the values that the data structure currently has. Every element in the Collection has to be computed before we add it to the Collection. Operations such as searching, sorting, insertion, manipulation, and deletion can be performed on a Colle
3 min read