Serialization and Deserialization in Java with Example

In Java, serialization and deserialization are concepts that allow you to convert objects into a byte stream and vice versa. These techniques are especially useful when you need to save the state of an object to a file, send it over a network, or persist data between different sessions.

What is Serialization?

Serialization is the process of converting an object into a byte stream. The byte stream can then be easily saved to a file, sent over a network, or stored in a database. The primary purpose of serialization is to preserve the state of an object so that it can be reconstructed later.

What is Deserialization?

Deserialization is the reverse process of serialization. It involves converting a byte stream back into a Java object. Once deserialized, the object can be used in the program as if it were the original object.

Why Use Serialization and Deserialization?

1. Persistence: Store the state of objects for future use (e.g., saving user data or application state).
2. Communication: Send objects between distributed applications or over the network (e.g., remote method invocation, web services).
3. Caching: Store objects in a cache for faster retrieval.

How to Serialize and Deserialize an Object in Java?

To make a Java object serializable, the class must implement the Serializable interface. This interface does not have any methods; it simply marks the class as being eligible for serialization.

Example: Serialization and Deserialization

Step 1: Serialize an Object

Here’s an example of how you can serialize a simple Person object to a file:

import java.io.*;

class Person implements Serializable {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class SerializationExample {
    public static void main(String[] args) {
        Person person = new Person("John", 30);

        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            out.writeObject(person);
            System.out.println("Serialization complete!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In this code:

1. The Person class implements the Serializable interface, making it eligible for serialization.
2. We use ObjectOutputStream to write the object to a file (person.ser).

Step 2: Deserialize the Object

Now, let’s see how to deserialize the object back from the file:

import java.io.*;

public class DeserializationExample {
    public static void main(String[] args) {
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person person = (Person) in.readObject();
            System.out.println("Deserialization complete!");
            System.out.println(person);  // Output: Person{name='John', age=30}
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

In this code:

1. We use ObjectInputStream to read the object from the file.
2. The object is cast back to the Person class, and its state is restored.

Key Points to Remember

• Serializable Interface: A class must implement the Serializable interface to allow its objects to be serialized.
• Transient Keyword: If you want to exclude a member variable from serialization, mark it as transient. This tells Java not to serialize the variable.

  private transient String password;  // This will not be serialized.
  

• SerialVersionUID: It’s a good practice to define a serialVersionUID to ensure compatibility during deserialization. It helps avoid InvalidClassException when the class version changes.

  private static final long serialVersionUID = 1L;
  

• Custom Serialization: You can customize the serialization process by implementing the writeObject() and readObject() methods.

Conclusion

Serialization and deserialization in Java are powerful features for persisting objects and transferring data across systems. Understanding these concepts is essential for working with files, databases, and network communication. By marking classes as Serializable and using ObjectInputStream and ObjectOutputStream, you can easily convert objects to byte streams and back.

Remember to use transient and serialVersionUID wisely for control over the serialization process!