Mutable vs Immutable Java

Mutable objects have fields that can be modified; the immutable objects have no fields that can be changed after the object is created. Immutable objects are objects whose state can not change after they have been created. Mutable and Immutable are two categories of objects in java. In this article, we will see the differences between mutable and immutable objects in java. Also, we will see java code examples showing differences between mutable and immutable class in java.

ADVERTISEMENT Popular Course in this category JAVA MASTERY - Specialization | 78 Course Series | 15 Mock Tests

Head to Head Comparison between Mutable vs Immutable Java (Infographics)

Below are the top 6 differences between Mutable vs Immutable Java:

Key Differences between Mutable vs Immutable Java

Following are key differences between mutable and immutable objects in Java:

• Mutable objects are objects in which we can make changes to an object’s state without creating a new object. That is, a mutable object can be modified after its creation. In the case of immutable objects, whenever the state of an object is changed, we get a new object. While dealing with immutable objects, we are not allowed to change an object’s state after its creation.
• Mutable objects, in general cases, provide methods through which objects’ contents can be changed, whereas immutable objects do not provide any method for changing their contents.
• In mutable java classes, getter and setter methods are present, whereas, in immutable classes, only getter methods are available and not setter methods.
• Mutable classes may or may not be thread-safe, whereas immutable classes are by default thread-safe.
• Examples of mutable classes in java are java.util.Date, StringBuffer, StringBuilder, etc., whereas java legacy classes, wrapper classes, String class are examples of immutable classes in java.

Mutable vs Immutable Java Comparison Table

Let us discuss the top comparison between Mutable vs Immutable Java:

 Mutable

Mutable	Immutable
Java Mutable object can be modified after its creation.	Java Immutable object cannot be modified after its creation.
No new object is formed when changes are made to an existing object.	Whenever an existing object is changed, a new object is formed.
It provides methods to change the content of an object.	It does not provide methods for changing the content of an object.
Getter and setter methods are present in mutable classes.	Only getter methods are present and not setter methods.
Mutable classes may or may not be thread-safe.	Immutable classes are thread-safe by default.
Some common examples of mutable classes in java are StringBuffer, StringBuilder, and java.util.Date.	All Legacy classes, Wrapper classes, String class, are common examples of Immutable classes in java.

Immutable

Java Mutable object can be modified after its creation.

Java Immutable object cannot be modified after its creation.

No new object is formed when changes are made to an existing object.

Whenever an existing object is changed, a new object is formed.

It provides methods to change the content of an object.

It does not provide methods for changing the content of an object.

Getter and setter methods are present in mutable classes.

Only getter methods are present and not setter methods.

Mutable classes may or may not be thread-safe.

Immutable classes are thread-safe by default.

Some common examples of mutable classes in java are StringBuffer, StringBuilder, and java.util.Date.

All Legacy classes, Wrapper classes, String class, are common examples of Immutable classes in java.

Mutable and Immutable Java with Examples

Mutable and Immutable Java with Examples are given below:

Example #1 – Mutable Class in Java

Now we will see java code examples showing the creation of mutable and immutable classes in java.

Code:

package com.edubca.mutabledemo;
public class MutableDemo {
private String studentName;
private int rollNumber;
MutableDemo (String studentName, int rollNumber) {
this.studentName = studentName;
this.rollNumber = rollNumber;
}
public String getStudentName() {
return studentName;
}
// this setter can modify the name
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public int getRollNumber() {
return rollNumber;
}
// this setter can modify roll number
public void setRollNumber(int rollNumber) {
this.rollNumber = rollNumber;
}
public static void main(String[] args) {
MutableDemo obj = new MutableDemo ("John" , 100);
System.out.println("Original Name is " + obj.getStudentName());
System.out.println("Original Roll Number is " + obj.getRollNumber());
// update the name, and roll number as  is mutable
obj.setStudentName("James");
obj.setRollNumber(102);
System.out.println("Modified Name is " + obj.getStudentName());
System.out.println("Modified Roll Number is " + obj.getRollNumber());
}
}

Output:

The above code shows the creation of a mutable class in java with getters and setters.

Example #2 – Immutable Class in Java

Now we will see how we can create immutable classes in Java.

Code:

package com.edubca.immutabledemo;
public final class ImmutableDemo {
final String studentName;
final int rollNumber;
public ImmutableDemo  (String studentName, int rollNumber) {
this.studentName = studentName;
this.rollNumber = rollNumber;
}
public String getStudentName() {
return studentName;
}
public int getRollNumber() {
return rollNumber;
}
public static void main(String[] args) {
ImmutableDemo obj = new ImmutableDemo  ("John" , 100);
// Since no getters are available contents cannot be modified.
// Also as variables are declared final they cannot be modified
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
}
}

Output:

The above code shows the creation of the java immutable class. The following points are to be kept in mind while creating an immutable class:

• An immutable class must be final as it should not be inherited.
• All fields of an immutable class should be made final.
• If any mutable object is used as a field in an immutable class, then special handling has to be implemented so as to prevent its contents from being modified.
• A public constructor should be present.
• Getter methods for all the variables should be defined.
• Setter methods should not be present for any variables.

Conclusion

From the above discussion, we clearly understand the differences between mutable and immutable in java. Also, we have seen java examples showing how mutable and immutable classes are created. It is important to note that immutable classes are by default thread-safe, whereas mutable classes may or may not be thread-safe.

The above is the detailed content of Mutable vs Immutable Java. For more information, please follow other related articles on the PHP Chinese website!