What does it mean to share internals with an immutable object in Java?

Question

I have been reading Effective Java and I have come across the statement that not only can you share immutable objects, but you can share their internals. But, I am struggling to figure out what that really means and an example would surely help as no example is given in the book. I already know that immutable objects can't be changed, such as a String.

Answer 1

Read the book further:

The BigInteger class uses a sign-magnitude representation internally. The sign is represented by an int and the magnitude is represented by an int array. The negate method produces a new BigInteger of like magnitude and opposite sign. It does not need to copy the array; the newly created BigInteger points to the same internal array as original.

Answer 2

For example if you have a class

public class Vector2d { 
  private final BigDecimal a;
  private final BigDecimal b;
}

Then a and b are the "internals" of that class. Since this are instance of BigDecimal they are immutable. If you implement an operation like setBToZero() you can simply reuse your instance of a and don't have to recreate a new one. For example

public Vector2d setBToZero() { 
  return new Vector2d(a, 0);
}

You share your internal a and since it is immutable you don't have to worry about changes of your shared state. This is especially useful, when it comes to large objects. If you use interfaces you can implement some operations only by using proxy objects.