Java String Immutability storage when String object is changed

Question

I understood that if a String is initialized with a literal then it is allotted a space in String Pool and if initialized with the new Keyword it create a String's object. But I am confused with a case which is written below.

My question is what if a String is created with the new keyword and then it value is updated with a literal?

E.g.

String s = new String("Value1");  -- Creates a new object in heap space

then what if write the next statement as below.

s = "value2";

So my question is,

1 Will it create a String literal in a String Pool or it will update the value of that object?

2 If it creates a new literal in String Pool what will be happened to the currently existed object? Will it be destroyed or it will be there until the garbage collector is called.

This is a small string if the string is say of the thousands of characters then I am just worried about the space it uses. So my key question is for the space.

Will it immediately free the space from the heap after assigning the literal?

Can anyone explain what what value goes where from the first statement to the second and what will happened to the memory area (heap and String Pool).

Answer 1

Modifying Strings

The value is not updated when running

s = "value2";

In Java, except for the primitive types, all other variables are references to objects. This means that only s is pointing to a new value.

Immutability guarantees that the state of an object cannot change after construction. In other words, there are no means to modify the content of any String object in Java. If you for instance state s = s+"a"; you have creates a new string, that somehow stores the new text.

Garbage collection

This answer already provides an in-depth answer. Below a short summary if you don't want to read the full answer, but it omits some details.

By default new String(...) objects are not interned and thus the normal rules of garbage collection apply. These are just ordinary objects.

The constant strings in your code, which are interned are typically never removed as it is likely that eventually you will refer back to these.

There is however a side-note in the answer that sometimes classes are dynamically (un)loaded, in which case the literals can be removed from the pool.

---

To answer your additional questions:

Will it immediately free the space from the heap after assigning the literal?

No, that would not be really efficient: the garbage collector needs to make an analysis about which objects to remove. It is possible that you shared the references to your old string with other objects, so it is not guaranteed that you can recycle the object. Furthermore there is not much wrong with storing data no longer useful, as long as you don't need to ask additional memory to the operating system (compare it with you computer, as long as you can store all your data on your hard disk drive, you don't really have to worry about useless files, from the moment you would have to buy an additional drive, you will probably try to remove some files first). The analysis requires some computational effort. In general a garbage collector only runs when it (nearly) runs out of memory. So you shouldn't worry much about memory.

Can anyone explain what what value goes where from the first statement to the second and what will happened to the memory area (heap and String Pool).

Your first string:

String s = new String("Value1");

is a reference to the heap. If you call the command, it will allocate space on the heap for the string.

Now if you call:

s = "value2";

"value2" is an element of the String Pool, it will remain there until your program ends.

Since you don't have a reference to your old string (value1), anymore. That object is a candidate for collection. If the garbage collector later walks by, it will remove the object from the heap and mark the space as free.