How to Make Object Serializable in Java?

The process of serialising an object in Java so that it can be saved to a file, transmitted over a network, or kept in a database is known as serialisation. The original object can then be recreated using this byte stream, with all of its data and state intact, by de-serialising it.

In Java applications, serialisation is an effective method for conveying and storing data. Although the process of making an object serializable is quite simple, it is crucial to comprehend the guiding ideas and adhere to precise guidelines to guarantee proper execution.

Example 1: Basic Serialization and Deserialization

File Name: SerializationExample1.java

import java.io.*;
class Sample implements Serializable {
    public int num;
    public String text;
    public Sample (int num, String text) {
        this.num = num;
        this.text = text;
    }
}
public class SerializationExample1{
    public static void main(String[] args) {
        Sample object = new Sample(42, "example");
        String filename = "sample.ser";
        // Serialization
        try (FileOutputStream fileOut = new FileOutputStream(filename);
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(object);
            System.out.println("Object has been serialized");
        } catch (IOException ex) {
            System.out.println("IOException is caught");
        }
        Sample deserializedObject = null;
        // Deserialization
        try (FileInputStream fileIn = new FileInputStream(filename);
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            deserializedObject = (Sample) in.readObject();
            System.out.println("Object has been deserialized");
            System.out.println("num = " + deserializedObject.num);
            System.out.println("text = " + deserializedObject.text);
        } catch (IOException | ClassNotFoundException ex) {
            System.out.println("Exception is caught");
        }
    }
}

Output:

Object has been serialized
Object has been deserialized
num = 42
text = example

Example 2: Transient and Static Variables

File Name: SerializationExample2.java

import java.io.*;
class Person implements Serializable {
    private static final long serialVersionUID = 123456789L;
    transient int age;
    static int count;
    String name;
    double salary;
    public Person(String name, double salary, int age, int count) {
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.count = count;
    }
}
class SerializationExample2 {
    public static void printData(Person person) {
        System.out.println("name = " + person.name);
        System.out.println("salary = " + person.salary);
        System.out.println("age = " + person.age);
        System.out.println("count = " + person.count);
    }
    public static void main(String[] args) {
        Person person = new Person("Alice", 75000.0, 30, 5);
        String filename = "person.ser";
        // Serialization
        try (FileOutputStream fileOut = new FileOutputStream(filename);
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(person);
            System.out.println("Object has been serialized\nData before Deserialization.");
            printData(person);
            person.count = 10; // change static variable
        } catch (IOException ex) {
            System.out.println("IOException is caught");
        }
        person = null;
        // Deserialization
        try (FileInputStream fileIn = new FileInputStream(filename);
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            person = (Person) in.readObject();
            System.out.println("Object has been deserialized\nData after Deserialization.");
            printData(person);
        } catch (IOException | ClassNotFoundException ex) {
            System.out.println("Exception is caught");
        }
    }
}

Output:

Object has been serialized
Data before Deserialization.
name = Alice
salary = 75000.0
age = 30
count = 5
Object has been deserialized
Data after Deserialization.
name = Alice
salary = 75000.0
age = 0
count = 10

Advantages of Serialization

To save/persist an object's state: Serialization allows the state of an object to be saved to a file or database, enabling persistent storage and retrieval of object data.
To travel an object across a network: Serialized objects can be transmitted over a network, facilitating communication between different systems or components in a distributed environment.
To create deep copies of objects: Serialization can be used to create exact duplicates of objects, including all nested objects, by serializing and then deserializing them.
To cache objects: Serialized objects can be stored in memory, file systems, or distributed caches, allowing for quick retrieval and improved application performance.

Conclusion

ObjectOutputStream and ObjectInputStream are used to manage the serialization and deserialization operations, and implementing the Serializable interface is all that is needed to make an object serializable in Java.

We can successfully cache things, create deep copies, transfer objects over networks, and maintain object states by doing this. Sensitive data is maintained effectively, and the serialization process satisfies the requirements of the application when transient fields are handled correctly and bespoke serialization methods are used.

Furthermore, by providing a serialVersionUID, we may avoid problems during deserialization and preserve class compatibility between versions. By adhering to these guidelines, we may effectively serialize and deserialize objects, making the most of Java's serialization features to improve the functionality and efficiency of program.

Next TopicJava-program-to-check-if-two-words-are-present-in-a-string

← prev next →