immutable : Java Glossary
Not changeable. All Java variables are by default mutable. An Object is immutable
if there is no way you can change its fields after it has been constructed. Tools for creating making objects of
a class immutable:
- Using the final keyword.
- Make variables private and provide no public
accessors to the outside world to change them.
- The wrapper classes, Byte, Character, Short, Integer, Long, Float and Double are all immutable. Strings are immutable, though the references to them are mutable. StringBuffers are mutable. The only way to change the value of the number inside the object
wrapper is to create a new object and point to that instead.
An object can be immutable even if some of its primitive fields are not. There must be no public fields and no public methods that let you change fields. The
simplest tool to ensure immutability is to use the keyword final on all of the fields
and initialise them all in the constructor. You must also ensure that any objects your immutable object points
are in turn immutable. Normally you would declare references to all such objects final.
Advantages of Immutability
- You can share immutable objects between threads without danger of changes confusing the other thread. You
don’t need any locking. Two threads can both work on an immutable object at the same time without any
possibility of conflict.
- Once you check the value, you know it has to stay safe. No one can pass you a value, then
behind your back swap it to an unsafe one using a background thread. This is particularly important in high
security situations where allowing an invalid value to sneak in could compromise system integrity, e.g. a
filename. This is probably the main reason that Strings are immutable.
- You can share duplicates by pointing them to a single instance. You need only one copy, e.g. String interning. This saves RAM (Random Access Memory). With mutable
StringBuilders that were temporarily identical, you could not throw one away, and
replace it with a reference to the other, since at any moment their values could diverge again.
- You can create substrings without copying. You just create a pointer into an existing base String guaranteed never to change. Immutability is the secret behind Java’s very fast
- Immutable objects are much better suited to be Hashtable keys. If you change the
value of an object that is used as a hash table key without removing it and re-adding it you lose the
- Since String is immutable, inside each String is a
char exactly the correct length. Unlike a StringBuilder there is no need for padding to allow for growth.
Returning an Immutable Result
Let us say you wanted to return some data from your method, but you did not want the user to muck with the
original. Here are six approaches to the problem:
- Wrap the reference in an immutable wrapper class and return that.
- Give the caller his own private copy of the data he can muck with to his heart’s content. There is
high CPU (Central Processing Unit) and RAM overhead in the array copying.
- Beg or threaten the user not to modify the data in the reference you return to him.
- Return an immutable interface to the original data. You can then change fields in the object, but the
caller cannot unless he cheats by casting. You expose only the methods you want the user to have. Doing the
same with classes is trickier since a subclass must expose everything its superclass does.
- You can turn a Collection into an immutable Collection with methods like Collections.unmodifiableCollection,
Collections. unmodifiableSet, Collections. unmodifiableSortedMap or Collections. unmodifiableSortedSet.
- You can return an Iterator with a dummy remove
Of course same techniques can be used if you want to pass an Object to a method and
you don’t want the method messing with it. You declare the method with an interface parameter and pass it
an interface referenece or a reference to an object of some class implementing that interface. Essay on double vs Double.