Why can I not set java.lang.Integer?

You can't "set" a `java.lang.Integer` object directly in the way you might intend due to its immutability. In Java, `Integer` is a wrapper class for the primitive type `int`. Once an `Integer` object is created, its internal value, the wrapped `int`, cannot be changed. This behavior is a core concept of immutable objects in Java.

Here's a breakdown of why and what you can do instead:

1. Immutability:

- Immutable objects, like `Integer`, are designed to be thread-safe. Once created, their state remains constant. This prevents issues that might occur when multiple threads try to modify the same object concurrently.

- If you could directly modify the internal value of an `Integer`, it could lead to unpredictable and buggy behavior, especially in multi-threaded environments.

2. What Happens When You Attempt to Modify?

- When you "modify" an `Integer`, what's actually happening is that you are creating a brand new `Integer` object. The old one is left unchanged, and the variable is updated to point at the new `Integer`.

3. Example:

Let's illustrate with a code example: Integer num = 5;
num = 10;

- In this example, you're not modifying the original `Integer` object that held the value 5. Instead, you're assigning a new `Integer` object (with the value 10) to the variable `num`. The `Integer` object with the value 5 is unchanged, and may be garbage collected later by the JVM, if there are no other references to it.

4. How to "Change" an Integer Value:

- To "change" the integer value, you should do not modify the `Integer`, but re-assign the new value to the same variable as shown in the example above.

5. Alternative:

- If you need a mutable wrapper around an `int`, you can create a custom class or use third-party libraries, but it's rarely necessary in Java.

6. Understanding the Use-case:

- If you are dealing with the concept of value and you need to change the value, in that case, what you change is not a value of the existing object, but the object itself by reassigning a new object to the same variable

In summary, `java.lang.Integer` is immutable to ensure thread safety and predictability. You cannot directly alter its value after it's created, but you can reassign the variable to a new `Integer` object containing the desired value.

Learn more about this