Serialization and deserialization in java with examples

Serialization and Deserialization is one of the commonly used concept in java to store object in any other location like, File, DB, Cloud,...etc and vice versa is called as Deserialization. In other words, Java provides a mechanism called Serialization to persist Java object into a file, database, network, process or any other system. Serialization makes object into an ordered or Serialized stream of bytes. That includes the object data as well as object type of data stored. Before moving further in Serialization and Deserialization in java, have a look at Input and Output streams.

If you need to make your object as Serialized, the object class should be implemented from Serializable interface. Serializable is one of the interface called as marker interface in java. Marker interface is nothing but an interface which has no methods or fields to implement but it will do some functionality. Serializable interface is part of java.io package in java.

ObjectOutputStream and ObjectInputStream classes are high level streams that contains the methods for Serializing and Deserializing and object. ObjectOutputStream class has many methods for Serializing an object. But most commonly used method is writeObject().

private void writeObject(ObjectOutputStram os)throws IOException{

}

ObjectInputStream has few methods available in it. We use readObject() method for Deserializing an object. The below is the syntax for readObject() method.

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

}

What is the need of Serialization?
As I already explained, Serialization is used to store object from one location to another location either it is in a File or DB or into Network. Now, the problem is network and hard disk will not understand Java objects, it will understand only Bits and Bytes. Serializable interface helps to convert Java object in Bytes and share over the network or saving into a file. Deserialization is vice versa to Serialization, conversion of byte code into normal Java code.

SerialVersionUID: SerialVersionUID is used to make sure same class object is loaded during Deserialization. SerialVersionUID is used for version control of object.

Car.java:

package com.javatbrains.serialization;

import java.io.Serializable;

public class Car implements Serializable {
     private static final long serialVersionUID = -7617174890882744651L;
     private int number;
     private String name;
     private double cost;

     public int getNumber() {
          return number;
     }

     public void setNumber(int number) {
          this.number = number;
     }

     public String getName() {
          return name;
     }

     public void setName(String name) {
          this.name = name;
     }

     public double getCost() {
          return cost;
     }

     public void setCost(double cost) {
          this.cost = cost;
     }
}

Car.java class represents a simple bean class in java. Car class implemented an interface called Serializable. When a class implements Serializable interface then that class available for Serialization. In below class Serializing Car object into a file.

Serialization.java:

package com.javatbrains.serialization;

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

public class Serialization {

     public static void main(String[] args) {
          try {
              Car car = new Car();
              FileOutputStream fos = new FileOutputStream("D:/Car.ser");
              ObjectOutputStream oos = new ObjectOutputStream(fos);
              for (int i = 0; i < 5; i++) {
                   car.setNumber(i);
                   car.setName("car " + i);
                   car.setCost(100.00 + i);
                   oos.writeObject(car);
              }
              fos.close();
              oos.close();
              System.out.println("Serialization is done.");
          } catch (IOException ie) {
              ie.printStackTrace();
          }
     }
}

If the above class executed successfully, it will print console with the message of Serialization is done otherwise it will print some IOException. Before executing the program, you make sure you have given the proper file path in FileOutputStream.

Static and Transient fields in Serialization:
Static variables are not getting Searialized because static variables are not part of the Object, those are part of the Class. Transient is a keyword in java. It is also called as modifier of instance variable of a class. It specifies that the transient variable is not part of the persistent state of an object and that never serialized during serialization.

Deserialization in Java:
Deserialization is a quit opposite process of Serialization. If we need to get persisted object into normal Java object we can use Deserialization in java. The below program will give you an overview of Deserializing Car class object.

package com.javatbrains.serialization;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;

public class Deserialization {
     public static void main(String[] args) {
          Car car = null;
          List<Car> cars = new ArrayList<Car>();
          try {
              FileInputStream fis = new FileInputStream("D:/Car.ser");
              ObjectInputStream ois = new ObjectInputStream(fis);
              for (int i = 0; i < 5; i++) {
                   car = (Car) ois.readObject();
                   cars.add(car);
              }
              ois.close();
              fis.close();
          } catch (IOException ie) {
              ie.printStackTrace();
              return;
          } catch (ClassNotFoundException cf) {
              System.out.println("Car class is not found: ");
              cf.printStackTrace();
              return;
          }
          System.out.println("Deserialized objects: ");
          for (Car carr : cars) {
              System.out.println("Number: " + carr.getNumber());
              System.out.println("Name: " + carr.getName());
              System.out.println("Cost: " + carr.getCost());
          }
     }
}

As on when we execute the above program, that will Deserialize all the objects from the file and print values in Console.

Related Posts:

• Cloning in java
• IO Streams with examples in java
• Reading properties from file and finding leap year with examples in java
• Prime number, Fibonacci series and Factorial with examples in java
• Find total weekends list in between passing date range