I know Integers are immutable in Java. But why it is designed this way?
I went through other answers before asking this question:
Is Integer Immutable
i++ still working for immutable Integer in Java?
Why are Java wrapper classes immutable?
But I couldn't find the use case which mandates the Integer to be immutable. Are there any technical reasons like there are for String?
I understand there are wrappers like AtomicInteger
for mutable.
UPDATE:
From the conversation, there is no universal reason that could mandate the Integers being immutable. However by doing immutable it provides some bonus as mentioned in the answers.
Such as this quote from Andrey
possibility to cache.
Others are reducing global state
easier multithreading
You can't alter an immutable object! A: The answer to your question is simple: once an Integer instance is created, you cannot change its value. The Integer String , Float , Double , Byte , Long , Short , Boolean , and Character classes are all examples of an immutable class.
int is immutable in nature, so we can't change or update the int data-type. As we read earlier, that immutable objects change their memory address when they get updated. We assigned some integer value to a variable.
For example, In Java, String, Integer, Double are Immutable classes, while StringBuilder, Stack, and Java array are Mutable.
Integer (and other primitive wrapper classes) are immutable.
You won't find a mandatory reason why java.lang
wrappers must be immutable. Simply because it's a design decision. They could have decided otherwise. The language designers had to choose between mutable and immutable. And they chose immutable. That's it.
There are some compelling (IMO) reasons though to make them immutable:
It's consistent with String
. The same reasoning you provided for String
to be immutable applies to Integer
etc. as well (e.g. think of a port number in a property map). This generally applies to any mutable type.
Immutable types rule out a plethora of hard to find mistakes one can make where one involuntarily changed an objects member value by modifying the value obtained through a getter. It saves a lot of defensive copying when the type is immutable. The most infamous example is java.util.Date
, which is generally a pain to use because it's mutable (API issues aside).
Also immutable types allow for the use of shared instances, like e.g. Integer
does for commonly used values (see Integer.valueOf(int)
).
Can the identity of the value 1
ever change? Can it become 2
? No. That's why Integer
and other numeric types are immutable. They're meant to model that identity.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With