Question

I read that Java is passed by value . So lets say we have this code and say that the HashMap somehashMap has a longer life time than foo . So foo is not allowed to be garbage collected even though it has done its work simply because we put foo inside the Map and then forgot to remove from it . Now going by the logic of the answer in the post that I linked to we are actually passing a copy of the reference of foo to the method put() right ?In that case putting the foo into the HashMap shouldn’t prevent it from getting garbage collected . Can you please help me understand what is going on here ? What am I missing exactly ?

 public void someMethod(){
     Foo foo  = new Foo();
     somehashMap.put(fooKey,foo); 
  }

Answer 1

Garbage collection isn’t applicable to references but to actual objects which reside in heap. When you put foo in the Map, you are basically helping it “escape” out of its current scope and putting it in the same scope/life-time as somehashMap.

References in Java are handled transparently behind the scenes. When you put the foo reference in the map, a copy of the reference is actually passed to the put method call but the underlying object i.e. new Foo() is the same for both the original and the copied references. Let’s look at the below snippet:

public void doIt() {
  Object f1 = new Object();
  Object f2 = f1;
  Object f3 = f2;
}

In the above snippet, how many objects are garbage collected after execution of doIt completes? It’s just the single new Object() which we created. Rest all are simply references or aliases which are used to point to the same object.