幕后的Java不可变性

Question

So, I'm new to Java and am trying to get my head around how immutable objects are implemented, and why they can appear to be mutable nonetheless. A lot of the sources I've looked at seem to 'suggest' what goes on under the hood, but I'd just like clarification as to whether I'm on the right track.

Using the following trivial example:

import java.math.*;

class BIMutability {

   public static void main(String args[]) {

      BigInteger biValue = new BigInteger("2");

      for (int i=1; i<10; i++) {
         System.out.println(i + ". biValue = " + biValue);
         biValue = biValue.multiply(biValue);
      }
   }
}

which, when run, produces:

1. biValue = 2
2. biValue = 4
3. biValue = 16
4. biValue = 256
5. biValue = 65536
6. biValue = 4294967296
7. biValue = 18446744073709551616
8. biValue = 340282366920938463463374607431768211456
9. biValue = 115792089237316195423570985008687907853269984665640564039457584007913129639936

On the surface, it would appear that biValue is, in fact, mutable after all. I know that that's not the case.

My understanding is thus: biValue is essentially a pointer variable. Upon instantiation at runtime, heap is allocated for an object of class BigInteger, its constructor is called which (among other things) initializes the object's value according to the literal value "2", and biValue is finally assigned a pointer to the object space. (Is this correct?)

Subsequently, on each successive iteration of the loop, the multiply method allocates additional heap for a new object instantiation to contain the resulting immutable value (eg heap for the result of the 4th iteration is allocated and the new object assigned the value 256) and biValue is assigned a pointer which references the new object. (Is this also correct?)

(As an aside, from what I gather then, the previous objects' heap space are just orphaned? Or is garbage collection performed right away? If not, it just seems like you could quickly run out of heap under certain circumstances.)

So am I seeing this correctly, or am I missing important details, or...?

Thanks!

Answer 1

You are right about how multiply creates a new BigInteger object each time you call it, and that biValue 's value changes in each iteration.

When we say immutability, we mean that objects can't be mutated, not variables . A variable that can't be mutated can be declared using the final modifier.

And yes, many immutable classes might "seem" to be mutable. In such cases, the seemingly mutating methods will create a new object.

Regarding the fate of the BigInteger objects in the previous iterations of the loop, yes they will be garbage collected. However, the time that this happens is non-deterministic. Note that it probably will fill up the heap not because GC didn't collect the unused objects, but because the number is too big.