Serialization and Deserialization in Java

Serialization is changing the state of Object into binary stream or byte stream. Deserialization is the reverse process where byte stream changes into java object.

The byte stream created is platform-independent. So, the object serialized on one platform can be deserialized on a different platform.

To make a Java object serializable we implement the java.io.Serializable interface.

java.io.Serializable interface

⫸ Serializable is a marker interface (has no data member and method). It is used to "mark" Java classes so that the objects of these classes may get a certain capability. The Cloneable and Remote are also marker interfaces.

⫸ It must be implemented by the class whose object you want to persist.

⫸ The String class and all the wrapper classes implement the java.io.Serializable interface by default.

Advantages of Serialization

• To save/persist state of an object.
• To travel an object across a network.

A Serializable class can declare its own UID explicitly by declaring a field name.It must be static, final and of type long.

Example

1. /**
2.  * @author javalearning
3.  */
4. class Test implements java.io.Serializable {
5. public int a;
6. public String b;
7. /**
8. * Constructor
9. * @param a
10. * @param b
11. */
12. public Test(int a, String b) 
13. { 
14. this.a = a; 
15. this.b = b; 
16. }
17. }
18. /**
19.  * @author javalearning
20.  */
21. class Main {
22. public static void main(String[] args) {
23. Test test = new Test(1, "Hello world");
24. String filename = "xyz.ser";
25. /**
26. * Serialization
27. */
28. try {
29. /**
30. * Saving of object in a file
31. */
32. FileOutputStream file = new FileOutputStream(filename);
33. ObjectOutputStream out = new ObjectOutputStream(file);
34. /**
35. * Method for serialization of object
36. */
37. out.writeObject(test);
38. out.close();
39. file.close();
40. System.out.println("Object serialized");
41. }
42. catch (IOException ex) {
43. System.out.println("IOException");
44. }
45. Test test1 = null;
46. /**
47. * Deserialization
48. */
49. try {
50. /**
51. * Reading the object from a file
52. */
53. FileInputStream file = new FileInputStream(filename);
54. ObjectInputStream in = new ObjectInputStream(file);
55. /**
56. * Method for deserialization of object
57. */
58. test1 = (test) in.readObject();
59. in.close();
60. file.close();
61. System.out.println("Object has been deserialized ");
62. System.out.println("a: " + test1.a);
63. System.out.println("b: " + test1.b);
64. }
65. catch (IOException ex) {
66. System.out.println("IOException");
67. }
68. catch (ClassNotFoundException ex) {
69. System.out.println("ClassNotFoundException");
70. }
71. }
72. }

ObjectInputStream class

An ObjectInputStream deserializes objects and primitive data written using an ObjectOutputStream.