Java: Convert Mutable to Immutable

In Java, mutable objects can have their state changed after creation, which can lead to unexpected behavior, especially in multi-threaded environments. Immutable objects, on the other hand, have a fixed state once created, offering advantages such as thread-safety, easier debugging, and better security. Converting mutable objects to immutable ones is a crucial skill for Java developers. This blog post will guide you through the core concepts, typical usage scenarios, common pitfalls, and best practices of converting mutable to immutable objects in Java.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Code Examples
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

Mutable Objects#

A mutable object in Java is an object whose state can be changed after it is created. For example, ArrayList, StringBuilder, and Date are mutable classes. If you have an ArrayList, you can add, remove, or modify elements in it.

Immutable Objects#

An immutable object has a fixed state that cannot be changed after creation. If you try to modify an immutable object, a new object is created instead. Examples of immutable classes in Java include String, Integer, and LocalDate.

Conversion Process#

Converting a mutable object to an immutable one involves creating a new immutable object and copying the state from the mutable object. This process should ensure that the original mutable object's state does not affect the new immutable object in the future.

Typical Usage Scenarios#

Thread-Safety#

In multi-threaded applications, mutable objects can cause race conditions. By converting mutable objects to immutable ones, you can eliminate the need for synchronization and make your code thread-safe. For example, if multiple threads need to access a list, using an immutable list can prevent data corruption.

Data Integrity#

When you want to ensure that the data in an object remains unchanged throughout its lifecycle, converting it to an immutable object is a good choice. For instance, in a financial application, once a transaction record is created, you may want to make it immutable to prevent accidental or malicious modifications.

Caching#

Immutable objects are ideal for caching because their state never changes. You can cache an immutable object and reuse it without worrying about its state being modified.

Code Examples#

Converting a Mutable List to an Immutable List#

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class MutableToImmutableList {
    public static void main(String[] args) {
        // Create a mutable list
        List<String> mutableList = new ArrayList<>();
        mutableList.add("apple");
        mutableList.add("banana");
 
        // Convert the mutable list to an immutable list
        List<String> immutableList = Collections.unmodifiableList(mutableList);
 
        // Try to modify the immutable list (this will throw an exception)
        try {
            immutableList.add("cherry");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the immutable list: " + e.getMessage());
        }
 
        // Print the immutable list
        System.out.println("Immutable list: " + immutableList);
    }
}

In this example, we first create a mutable ArrayList. Then we use Collections.unmodifiableList() to convert it to an immutable list. Any attempt to modify the immutable list will result in an UnsupportedOperationException.

Creating an Immutable Class from a Mutable Class#

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
// Mutable class
class MutablePerson {
    private String name;
    private List<String> hobbies;
 
    public MutablePerson(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = new ArrayList<>(hobbies);
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public List<String> getHobbies() {
        return hobbies;
    }
 
    public void setHobbies(List<String> hobbies) {
        this.hobbies = new ArrayList<>(hobbies);
    }
}
 
// Immutable class
final class ImmutablePerson {
    private final String name;
    private final List<String> hobbies;
 
    public ImmutablePerson(MutablePerson mutablePerson) {
        this.name = mutablePerson.getName();
        this.hobbies = Collections.unmodifiableList(new ArrayList<>(mutablePerson.getHobbies()));
    }
 
    public String getName() {
        return name;
    }
 
    public List<String> getHobbies() {
        return hobbies;
    }
}
 
public class MutableToImmutableClass {
    public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("reading");
        hobbies.add("swimming");
        MutablePerson mutablePerson = new MutablePerson("John", hobbies);
 
        ImmutablePerson immutablePerson = new ImmutablePerson(mutablePerson);
 
        // Try to modify the original mutable person
        mutablePerson.setName("Mike");
        mutablePerson.getHobbies().add("running");
 
        // The immutable person remains unchanged
        System.out.println("Immutable person name: " + immutablePerson.getName());
        System.out.println("Immutable person hobbies: " + immutablePerson.getHobbies());
    }
}

In this example, we have a mutable MutablePerson class and an immutable ImmutablePerson class. The ImmutablePerson constructor takes a MutablePerson object and copies its state to create an immutable object.

Common Pitfalls#

Shallow Copy vs. Deep Copy#

When converting a mutable object to an immutable one, a shallow copy may not be sufficient. A shallow copy only copies the references to the objects, while a deep copy creates new objects. If the mutable object contains other mutable objects, a shallow copy may still allow the state of the "immutable" object to be changed.

Incorrect Immutability#

It's easy to make mistakes when creating an immutable class. For example, if you expose a mutable field directly or provide methods that can modify the object's state, the class is not truly immutable.

Best Practices#

Use Immutable Collections#

Java provides several immutable collection classes, such as Collections.unmodifiableList(), Collections.unmodifiableSet(), and Collections.unmodifiableMap(). Use these methods to convert mutable collections to immutable ones.

Make Classes Final#

To ensure that a class cannot be subclassed and its behavior cannot be changed, make the class final.

Use Deep Copy#

When converting a mutable object that contains other mutable objects, use a deep copy to ensure true immutability.

Conclusion#

Converting mutable objects to immutable ones in Java is an important technique that offers many benefits, including thread-safety, data integrity, and better caching. By understanding the core concepts, typical usage scenarios, and common pitfalls, and following the best practices, you can effectively convert mutable objects to immutable ones in your Java applications.

FAQ#

Q1: Can I convert an immutable object back to a mutable one?#

A1: In general, you cannot directly convert an immutable object back to a mutable one. However, you can create a new mutable object and copy the state from the immutable object.

Q2: Are all Java wrapper classes immutable?#

A2: Most Java wrapper classes, such as Integer, Double, and Boolean, are immutable. However, you should always check the documentation to be sure.

Q3: Does converting a mutable object to an immutable one have a performance impact?#

A3: There is usually a performance cost associated with creating a new object and copying the state. However, in many cases, the benefits of immutability, such as reduced synchronization overhead, can outweigh the performance cost.

References#

2025-10