Which are the objects are garbage collected?

Question

String strMsg = "PM";
float price = 7.50f;
price = 8.50f;
strMsg = "AM";
strMsg = "MN";
price = 9.50f;;

Also, why are they collected?

Answer 1

You have to ask yourself first how many objects are created. At your code snippet three String objects are created. Since you created them with "" they are part of the String pool. However, after your code has run, all those three objects are ELIGBLE to be collected by the garbage collector. Note that this does not guarantee that they are actually collected.

Answer 2

Heap and Stringpool

strMsg are not in Heap, it will be in Stringpool. So you dont know when it will collected.

When you create a String like

 String input = new string("Hai");

You are using the new operator to create the object. When ever you are creating new String() with new operator it will create in Heap memory.

By using legacy code like

String input = "Hai";

It will not create in Heap memory. It will created in Stringpool.

Garbage Collection:

   If the String will not have any reference, then it will be collected.  

Why they are collected?

   Because of memory optimization. Unwanted memory occupation will be releaved by using Garbage Collection, upto your program will stops.

If you create two String having same value like

   String s  = "Sample";
   String s1 = "Sample";

Both the s and s1 will point the same reference. Because Stringpool is like constants, it checks every time the upcoming value may exist or not. If it available then it take the old address and assigns to the new variable. If you change the value of the variable then it creates a new String in Stringpool.

Answer 3

Edit: It seems that my explanation about strings is accurate only if you create a string using the String constructor (e.g. String str = new String("cat");). There are a few small issues that my explanation doesn't cover about strings. For more general information about strings, take a look at @newuser 's answer. My explanation should work for the majority of Java objects.

In Java, variables are actually references to other objects. (In other languages, references are called "pointers".) For example, if a variable s is created by String s = "hello", s doesn't actually contain "hello". s contains a reference to hello. The distinction is subtle, but important. This means that if later in your code you do s = "bye", the variable s now points to "bye", not "hello". However, the string object "hello" is still floating around in memory somewhere, but you have no references to it. So now you can't access the "hello" object. The garbage collector realizes this and deletes the "hello" object for you to save memory. So in your example, "PM", "AM" are garbage collected since there are no references to those objects (no variables point to those objects).

Here is a more graphical representation of what I'm trying to explain:

String strMsg = "PM";

strMsg ------> "PM"

---

strMsg = "AM";

strMsg        "PM"
     |
     --------> "AM"

---

strMsg = "MN";

strMsg         "PM"
     |
     |         "AM"
     |
     ---------> "MN"

---

As it turns out, primitive types (e.g. int, float, double, char, etc) are actually stored in the variable. This means that if you do float x = 10.3, the variable x actually contains 10.3. So if you later do x = 8.9, the variable x has actually been changed from 10.3 to 8.9. This is different from changing a reference, which changes where the variable points. So in the case of primitive types, there is no need for garbage collection. In your example, none of the float values you set to price are garbage collected.

float price = 7.50f;

price  | 7.50f |

---

price = 8.50f;

price  | 8.50f |

---

price = 9.50f;

price  | 9.50f |