DZone
Java Zone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
  • Refcardz
  • Trend Reports
  • Webinars
  • Zones
  • |
    • Agile
    • AI
    • Big Data
    • Cloud
    • Database
    • DevOps
    • Integration
    • IoT
    • Java
    • Microservices
    • Open Source
    • Performance
    • Security
    • Web Dev
DZone > Java Zone > Java Immutable Objects

Java Immutable Objects

Want to learn more about immutable objects in Java?

Yogen Rai user avatar by
Yogen Rai
CORE ·
Mar. 29, 19 · Java Zone · Tutorial
Like (26)
Save
Tweet
44.79K Views

Join the DZone community and get the full member experience.

Join For Free

An object is considered immutable if its state cannot change after it is constructed. Since they cannot change state, they cannot be corrupted by thread interference or observed in an inconsistent state, making them useful in concurrent applications.

For example, String objects in Java are immutables.

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class ImmutableTest {
    @Test
    public void testImmutableObjs() {
        String firstName = "yogen";
        String lastName = "rai";

        // concatenate two strings
        String fullName = firstName.concat(" ").concat(lastName);

        assertEquals("yogen", firstName);
        assertEquals("rai", lastName);
        assertEquals("yogen rai", fullName);
    }
}


The concatenation of firstName on " " (whitespace) and lastName is not going to modify either of them, rather create a new object which will be referenced by fullName.

String- Immutables

Figure: Strings are immutables

Defining Custom Immutable Objects

The following rules define a simple strategy for creating immutable objects:

  1. Don't provide "setter" methods — methods that modify fields or objects referred to by fields.
  2. Make all fields final and private.
  3. Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A more sophisticated approach is to make the constructor private and construct instances in factory methods.
  4. If the instance fields include references to mutable objects, don't allow those objects to be changed:
    • Don't provide methods that modify the mutable objects.
    • Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.

Defining Custom Immutable Object With the Date Object

Date object in java.util.* is not thread-immutable.

It is good news that new java.time.* API after JDK 8 has Date objects as immutable objects. For example, the Student object, in the example below, is immutable even if the property dateJoined is Date object.

import java.time.LocalDate;

final class Student {
    private final String name;
    private final int age;
    private final LocalDate dateJoined;

    public Student(String name, int age, LocalDate dateJoined) {
        this.name = name;
        this.age = age;
        this.dateJoined = dateJoined;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public LocalDate getDateJoined() {
        return dateJoined;
    }
}

public class TestImmutable {
    @Test
    public void testImmutableObject() {
        Student original = new Student("Yogen", 23, LocalDate.of(2016, 5, 1));

        LocalDate modifiedLocalDate = original.getDateJoined().plusYears(2);

        Student expected = new Student("Yogen", 23, LocalDate.of(2016, 5, 1));
        assertEquals(expected, original);
    }
}


The code from the above example is available on GitHub.

Benefits of Immutable Objects

  • Immutable objects are simpler to construct, test, and use as they are side-effect free.
  • They are much easier to cache since the modification on the object is not going affect it's original state.
  • Truly immutable objects are always thread-safe
  • Identity mutability problem is avoided
  • They help to avoid temporal coupling
Object (computer science) Java (programming language)

Published at DZone with permission of Yogen Rai, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • The Best Infrastructure as Code Tools for 2022
  • How Do You Know If a Graph Database Solves the Problem?
  • Tools and Integrations to Significantly Improve Code Review in GitHub
  • Advancing Cybersecurity Using Machine Learning

Comments

Java Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • MVB Program
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends:

DZone.com is powered by 

AnswerHub logo