DEV Community

Cover image for Java mutability and immutability: Understanding the difference between the two.
Mercy
Mercy

Posted on

5 2 2 2 1

Java mutability and immutability: Understanding the difference between the two.

Understanding immutability and mutability in Java is essential for effective programming, particularly when considering data integrity and thread safety. This overview of the concepts will help you gain a thorough understanding.

What is Immutability?

An immutable object is one whose state cannot be modified after it has been created. This means that once an immutable object is instantiated, its data fields cannot be changed. A common example of an immutable class in Java is the String class.

Key Characteristics of Immutable Objects:

  • Final Fields: All fields are declared as final, meaning they can only be assigned once.
  • No Setters: Immutable classes do not provide setter methods that would allow changing the state.
  • Defensive Copies: If the class contains mutable objects, it should return copies instead of references to ensure immutability.

Example of an Immutable Class

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}
Enter fullscreen mode Exit fullscreen mode

In this example, ImmutablePoint cannot be modified after its creation. The x and y coordinates can only be set via the constructor, and no setters are provided.

What is Mutability?

In contrast, a mutable object can have its state changed after it has been created. This means you can modify its properties or fields at any time.

Key Characteristics of Mutable Objects:

  • Non-final Fields: Fields are not declared as final, allowing changes.
  • Setters Available: Mutable classes typically provide setter methods to change the object's state.

Example of a Mutable Class

public class MutablePoint {
    private int x;
    private int y;

    public MutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}
Enter fullscreen mode Exit fullscreen mode

In the MutablePoint class, you can change the values of x and y using the provided setter methods.

Comparison of Immutability and Mutability

Image description

Conclusion
Choosing between mutable and immutable objects depends on your application's requirements. Immutable objects provide benefits such as simplicity and safety in concurrent environments, while mutable objects can offer performance advantages by avoiding unnecessary object creation. Understanding these concepts will help you design better Java applications that are robust and maintainable.

Image of Timescale

Timescale – the developer's data platform for modern apps, built on PostgreSQL

Timescale Cloud is PostgreSQL optimized for speed, scale, and performance. Over 3 million IoT, AI, crypto, and dev tool apps are powered by Timescale. Try it free today! No credit card required.

Try free

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more

👋 Kindness is contagious

Please leave a ❤️ or a friendly comment on this post if you found it helpful!

Okay