Serialization in Java is the process of converting an object into a stream of bytes so that it can be saved to a file or sent over a network. Deserialization is the reverse process, where the stream of bytes is converted back into an object. Serialization is often used in Java when saving and restoring the state of an object, or when transferring data between different systems.
To serialize an object in Java, the class must implement the Serializable interface. This interface does not contain any methods but is used as a marker to indicate that the object can be serialized.
Here’s an example of how to serialize an object in Java:
import java.io.*;
public class SerializationDemo {
public static void main(String[] args) {
try {
// Create an object to serialize
Person person = new Person("John", 30);
// Serialize the object
FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(person);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in person.ser");
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}In this example, we create a Person object and serialize it to a file named “person.ser”. To do this, we first create a FileOutputStream object and pass it the name of the file we want to create. We then create an ObjectOutputStream object and pass it to the FileOutputStream object. We call the writeObject method on the ObjectOutputStream object to serialize the Person object. Finally, we close both streams.
To deserialize the object, we can use the following code:
import java.io.*;
public class DeserializationDemo {
public static void main(String[] args) {
try {
// Deserialize the object
FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person person = (Person) in.readObject();
in.close();
fileIn.close();
// Print the deserialized object
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}In this example, we create a FileInputStream object and pass it the name of the serialized file. We then create an ObjectInputStream object and pass it to the FileInputStream object. We call the readObject method on the ObjectInputStream object to deserialize the Person object. Finally, we close both streams and print the values of the deserialized Person object.
Serialization in Java is a powerful tool for saving and restoring the state of objects, and for transferring data between different systems. However, it’s important to note that serialization can also have security implications, as deserializing untrusted data can potentially lead to code execution. It’s therefore important to carefully consider the security implications of serialization in your applications.