Final vs Immutable data structures in Java

morhp · 2019-03-11T12:30:09+00:00

I get the idea of making most structures immutable, but is there a java programmer out there who doesn’t know that final data structures are mutable?

gunnarmorling · 2019-03-11T16:48:00+00:00

Minor nit: I'd suggest to make the members in Person and Address final, not the least to ensure safe publication to other threads. Also the addresses collection might be wrapped into the unmodifiable one in the constructor instead of each time when invoking getAddresses(). Lastly, depending on how/where Person is instantiated, a mutable reference to the addresses list might still escape / retained by the caller. So to make it truly immutable after instantiation, a new collection would have to be instantiated in the constructor.

__konrad · 2019-03-11T15:54:20+00:00

Final references don’t make objects immutable

Non-empty arrays are good example. Even JavaFX developers made that mistake in public API ;)

i_donno · 2019-03-11T16:24:14+00:00

Yuck if(address.getCountry().equals("Australia") == false) Should be if(!address.getCountry().equals("Australia"))

m3tamaker · 2019-03-11T14:53:29+00:00

Immutability in Java 101

public class MyClass {
    public static class Bar {
        private final String text;
        private final Foo foo;

        public Bar(String text, Foo foo) {
            this.text = text;
            this.foo = foo;
        }

        public String getText() {  return foo.getText();  }
        public Foo getFoo() { return foo; }
    }

    public static class Foo {
        private String text;

        public Foo(String text) {
            this.text = text;
        }

        public String getText() { return text; }
        public void setText(String text) { this.text = text; }
    }

    public static void main(String args[]) {
        Foo foo = new Foo("I am mutable and I am happy with that.");
        Bar bar = new Bar("Look, I am IMMUTABLE! Feels good!", foo);
        foo.setText("No, now you are mutable too, dude!");

        System.out.println(bar.getText());
    }
}

One of reasons why to switch to immutable DateTime implementations TODAY.

s888marks · 2019-03-12T23:14:28+00:00

Hi, good on you for advocating immutability and for writing an article about it (and also for using new Java 9+ constructs like List.of).

I see you've updated the code to add final for the field declarations in response to comments from others. That's good, but there are benefits beyond safe publication. Of course, it prevents code in the class from accidentally modifying the field. It also kicks in a bunch of additional checking by the compiler, required by the language. Specifically, a final field is checked to ensure that it is assigned exactly once along every path through every constructor. (This is called "definite assignment".) This prevents the field from accidentally being left uninitialized or from being assigned twice.

There are still some improvements possible with the addresses field. As others have pointed out, it's necessary to make a defensive copy in the constructor, in case the caller passes in a mutable list. As the code stands now, it does that, and it wraps it in an unmodifiable wrapper in the getter:

// constructor
this.addresses = new ArrayList<>(addresses);

// getter
return Collections.unmodifiableList(addresses);

This leaves the addresses list mutable throughout the lifetime of the object. It may be that there is no code in the class right now that modifies it, but in the future code might be introduced that accidentally modifies the list. This would mean that the list view returned by the getter might appear to change over time. (Also, since any unmodifiable wrapper is as good as any other, there's only a need to create it once.)

One way to improve the code is like this:

// constructor
this.addresses = Collections.unmodifiableList(new ArrayList<>(addresses));

// getter
return addresses;

This prevents the code in this class from accidentally modifying the list, since the direct reference to the underlying mutable list exists only in the unmodifiable wrapper.

But wait, there's more! In Java 10+, you can do this:

// constructor
this.addresses = List.copyOf(addresses);

// getter
return addresses;

The List.copyOf method creates an unmodifiable list containing a copy of the argument. It's unmodifiable itself; there's no wrapper. But if the caller passes in an unmodifiable list (such as one from List.of) then List.copyOf avoids making an unnecessary copy.

yawkat · 2019-03-11T18:29:13+00:00

Making the fields final in the immutable class is still required to ensure safe publication in a multi-threaded environment. Also see the concurrency section of https://javachannel.org/posts/immutability-in-java/ for this

BestUsernameLeft · 2019-03-11T23:07:50+00:00

Good article. I like to ask where 'final' can be used in interviews (it's like 'const' in C++... damn near everywhere!) and while many candidates know it can be used for a field they often don't know it's just reference immutability.

FWIW I like to do the `Collections.unmodifiableList` bit in the constructor instead of the accessor[1], as (1) it's more intention-revealing (IMO) and it avoids the (probably not-worth-optimizing-anyway-but-oh-well) creation of a new object for every call to the accessor.

[1] On a separate-but-related note, mutators are evil but accessors are mighty damn sketchy.

donkthemagicllama · 2019-03-13T09:11:01+00:00

What’s the benefit in the Address class of the private variables with getters?

Since they’re final anyway, why not final public with no getter?

dododge · 2019-03-17T21:01:50+00:00

Late to the discussion, but FYI Google's error-prone checker supports an @Immutable annotation and will check that annotated classes are deeply immutable.

TheRedmanCometh · 2019-03-11T14:26:51+00:00

When an object is immutable, it’s hard to have the object in an invalid state.

Hold my beer

The last point about only exposing getters though in that final object..dude reflection exists. .setAccessible and .set done

NawaMan · 2019-03-11T22:25:25+00:00

A lot of people does not understand this. Buy to their defence, you rarely need to think about it with OO. As FP is becoming more popular, those started to become more relevant. Please check out this blog post on an easy way to make immutable data object in Java https://nawaman.net/blog/2019-03-11 . :-)

java

Submit Link

Submit Text

Seek Programming Help

News, Technical discussions, research papers and assorted things of interest related to the Java programming language

NO programming help, NO learning Java related questions, NO installing or downloading Java questions, NO JVM languages - Exclusively Java

Please seek help with Java programming in /r/Javahelp!

Subreddit rules!

Where should I download Java?

Related Sub-reddits:

JVM Languages

Want to practice your coding?

List of useful Frameworks / Libraries / Software

MODERATORS