Java Transient | Functions of Transient Keyword in Java with Examples

java transient

Tóm Tắt

Introduction to Java Transient

Java transient is a modifier keyword that is used to mark a variable whose value is not to be serialized during Serialization. If we do not want to save the value of a specific variable during the serialisation, then we can mark a variable as transient by using the transient keyword. As the name itself, transient indicates that it last for a short time or not permanent. When the JVM encounters the transient variable, it ignores the variable’s original value and saves it by its default data type value.

Syntax:

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

The following is the declaration transient keyword.

transient private <member variable>;

private transient <member variable>;

AS above mentioned, we can see that the data member defined as transient will not be serialized because it is marked by transient keyword for not to be serialized. We can define a transient data member in two ways, the same as above in the syntax.

Note that Serialization is a process that converts the state of an object into a byte stream. During serialization, if we do not want to save a variable’s value in the file, we can declare it as transient.

Examples of Transient Keyword in Java

Next, we write the java code to understand the transient keyword more clearly with the following example where we will use a transient keyword to define a member variable of a class and make this class subclass of Serializable to perform the serialization and deserialization, as below.

Example #1

Code:

//package demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Employee implements Serializable{
private String name;
private String eid;
private int age;
//transient variable not serialized
private transient int projid = 104;
public Employee( String name, String eid, int age, int projid) {
this.age = age;
this.name = name;
this.eid = eid;
this.projid = projid;
}
@Override
public String toString() {
return "Employee ( name=" + name + ", eid=" + eid + ", age=" + age + ", projid=" + projid + ')';
}
}
public class Demo
{
public static void main(String[] args)
{
// create Employee class object which is Serializable
Employee e1 = new Employee( "John", "e106", 26, 104);
System.out.println("Employee object Before Serialization is : " + e1);
try {
FileOutputStream fw = new FileOutputStream("D:\\data.txt");
ObjectOutputStream ow = new ObjectOutputStream(fw);
ow.writeObject(e1);
System.out.println("Employee is successfully Serialized ");
// code for deserialization
FileInputStream fr = new FileInputStream("D:\\data.txt");
ObjectInputStream or = new ObjectInputStream(fr);
Employee de1 = (Employee) or.readObject();
System.out.println("Employee object successfully created from Serialized data.");
System.out.println("Employee object after deseriazliation is : " + de1);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:

Java Transient-1.1

Code Explanation: As in the above code, the employee class has created, and the project id that is projid data member of the employee class is defined as transient, so the value projid will not be serialized and while writing an employee object to the file will not save the value of a projid in the file. And later in the code, an employee object is read back from that file and deserialize an object; we can see in the output that the printing projid of the employee object is 0, which is the default value for the transient variable projid because it is serialized.

Example #2

Next, we write the java code to understand the transient keyword and show that the transient keyword does not impact the static and final variable as transient.

Code:

//package demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Employee implements Serializable{
private String name;
// Use of transient has no impact on static
private static String eid;
// Use of transient has no impact on final
private final int age;
//transient variable not serialized
private transient int projid = 104;
public Employee( String name, String eid, int age, int projid) {
this.age = age;
this.name = name;
this.eid = eid;
this.projid = projid;
}
@Override
public String toString() {
return "Employee ( name=" + name + ", eid=" + eid + ", age=" + age + ", projid=" + projid + ')';
}
}
public class Demo
{
public static void main(String[] args)
{
// create Employee class object which is Serializable
Employee e1 = new Employee( "John", "e106", 26, 104);
System.out.println("Employee object Before Serialization is : " + e1);
try {
FileOutputStream fw = new FileOutputStream("D:\\data.txt");
ObjectOutputStream ow = new ObjectOutputStream(fw);
ow.writeObject(e1);
// code for deserialization
FileInputStream fr = new FileInputStream("D:\\data.txt");
ObjectInputStream or = new ObjectInputStream(fr);
Employee de1 = (Employee) or.readObject();
System.out.println("Employee object after deseriazliation is : " + de1);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:

Java Transient-1.2

Code Explanation: As in the above code, the employee class has created, and the eid data member is declared as static and transient, the age declare as final and transient, and porjid of the employee class is declared as only transient, so only the value of projid will not be serialized and while writing an employee object to the file, but others data member value will be serialized. we can see in the output that after desterilize an object is printing, the projid of the employee object is 0, and all other data members’ values are saved because they are not serialized.

Conclusion

As simple as, the name transient meaning is lasting for a short time or not permanent the same way transient keyword is used in java. The transient is a modifier keyword that is used to mark a variable whose value is not to be serialized during Serialization.