What is Serialization in Java? A Detailed Guide with Code Examples

Introduction to Serialization in Java

Serialization in Java is the process of converting an object into a byte stream to save it into a file, send it over the network, or store it in memory. The main purpose of serialization is to persist the state of an object, which can then be reconstructed at a later time. This concept is fundamental when it comes to developing Java applications that need to save and transfer objects.

Why Do We Need Serialization?

Serialization is crucial in situations where we need to store an object’s state or transmit it between different Java programs. Some common use cases include:

• Saving Object State: Serialization allows the program to save the state of an object so that it can be restored later, such as saving a user’s session in a web application.
• Remote Communication: In distributed applications, objects are serialized and transmitted over networks, for example, in Java RMI (Remote Method Invocation) or web services.
• Database Persistence: Serialization can also be used for storing objects in databases or files.

How Does Serialization Work in Java?

In Java, serialization is implemented via the java.io.Serializable interface. This interface acts as a marker, indicating that objects of a class can be serialized. Unlike other interfaces, it does not contain any methods, making its use simple but effective.

When you mark a class as Serializable, Java can convert its object into a byte stream and reverse the process, called deserialization, to recreate the object from that byte stream.

Code Example: Basic Serialization and Deserialization

Let’s take a simple example to understand how serialization and deserialization work in Java:

import java.io.*;

// Class implements Serializable interface
class Student implements Serializable {
    private static final long serialVersionUID = 1L; // Version control for serialization
    String name;
    int age;

    // Constructor
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Method to display student details
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class SerializationDemo {
    public static void main(String[] args) {
        try {
            // Creating an object
            Student student = new Student("John Doe", 21);
            
            // Serializing the object to a file
            FileOutputStream fileOut = new FileOutputStream("student.ser");
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            out.writeObject(student);
            out.close();
            fileOut.close();
            System.out.println("Serialization complete!");

            // Deserializing the object from the file
            FileInputStream fileIn = new FileInputStream("student.ser");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            Student deserializedStudent = (Student) in.readObject();
            in.close();
            fileIn.close();

            System.out.println("Deserialization complete!");
            deserializedStudent.display();  // Displaying the deserialized object
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
            

This code demonstrates basic serialization and deserialization. Here’s how it works:

• Serialization: The Student object is written to a file called student.ser using ObjectOutputStream.
• Deserialization: The object is then read back from the file and reconstructed into its original form using ObjectInputStream.