Last Updated on July 29, 2024

Immutability in Java refers to the concept of creating objects whose state cannot be modified after they are created. Once an immutable object is instantiated, its internal data remains constant throughout its lifetime. 

This characteristic brings several advantages, including thread safety, improved predictability, and enhanced code reliability.

To achieve immutability, a class should be declared as final, all fields should be private and final, and the class should not provide any methods to modify the object’s state. 

By adhering to these principles, developers can create objects that are inherently thread-safe and resistant to accidental modifications, leading to more robust and maintainable code.

Advantages of Immutability

Immutability might seem restrictive at first, but its benefits in terms of thread safety, code simplicity, and performance optimization make it a valuable concept in Java programming.

Thread Safety

Since the state of an immutable object remains constant, it eliminates the possibility of race conditions and data corruption, common pitfalls in concurrent programming. 

This characteristic makes immutable objects ideal for sharing across threads without the need for synchronization, improving performance and reducing development complexity.

Code Simplicity and Predictability

Without the risk of unexpected state changes, reasoning about object behavior becomes easier. This leads to more reliable and maintainable code.

Immutable objects are also inherently functional in nature, aligning with functional programming paradigms and enabling a more declarative style of programming.

Caching and Memoization

Since immutable objects are identical if their fields are equal, they can be effectively cached, improving application performance. Additionally, immutable objects can be used as keys in hash-based collections without the need for custom equality and hashCode implementations.

Testing and Debugging

Immutable objects are easier to test as their behavior is consistent and predictable. Debugging is also simplified because the state of an immutable object remains constant, making it easier to isolate issues.

Creating an Immutable Class in Java

When creating immutable classes in Java, a common challenge arises when dealing with fields that reference mutable objects (like ArrayList, HashMap, etc.). To maintain immutability, it’s essential to perform defensive copying.

Steps to create an immutable class :

1. Declare the class as final: Prevent subclassing.
2. Make all fields private and final: Ensure data encapsulation.
3. Perform deep copying in the constructor: Create copies of mutable fields to prevent external modifications.
4. Provide getters that return defensive copies: If the returned object is mutable, create a copy before returning it.

Example:

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public final class ImmutablePerson {
    private final String name;
    private final List<String> addresses;

    public ImmutablePerson(String name, List<String> addresses) {
        this.name = name;
        this.addresses = new ArrayList<>(addresses); // Defensive copy
    }

    public String getName() {
        return name;
    }

    public List<String> getAddresses() {
        return Collections.unmodifiableList(new ArrayList<>(addresses)); // Defensive copy in getter
    }

It is important to make defensive copy of mutable object, otherwise the object wont be immutable and can be changed.

Examples of Immutable Objects in the JDK

Primitive Wrapper Classes

Primitive wrapper classes in Java (Integer, Long, Byte, Short, Float, Double, Character, Boolean) are designed to be immutable.

These classes encapsulate primitive data types and are immutable. Any operations that appear to modify their value actually create a new object

String Class

String immutability helps prevent security vulnerabilities. Since string contents cannot be altered, it becomes difficult for malicious code to modify sensitive data like passwords, connection strings, or user information embedded in strings.

Sensitive String values, like usernames and passwords, cannot be mistakenly changed during execution even if we pass references to different methods

Collections

While collections like List and Map are mutable, you can create immutable views of them using methods like Collections.unmodifiableList and Collections.unmodifiableMap.

However, these methods return wrappers that prevent modifications to the underlying collection, but don’t guarantee immutability of the elements within the collection.

Records

Java Records are a language feature introduced in Java 17 to simplify the creation of immutable data classes. They are a significant step towards achieving immutability with minimal boilerplate code.

All record components are implicitly final, preventing modification after object creation. The compiler automatically generates equals, hashCode, and toString methods based on record components, ensuring correct object comparison and representation.

Example:

public record Person(String name, int age) {}

While records provide a strong foundation for immutability, they don’t guarantee complete immutability. If a record contains mutable fields (e.g., lists, maps), you still need to perform defensive copying to ensure immutability.

Conclusion

Immutable objects offer a powerful tool for building reliable and thread-safe Java applications. By understanding the principles of immutability and following best practices, you can significantly improve the quality and maintainability of your code.

While creating immutable objects might initially seem restrictive, the long-term benefits in terms of code correctness, concurrency, and testability often outweigh the initial effort.

By embracing immutability, you can write cleaner, safer, and more efficient Java code.