Understanding Reference Behaviour in Java

For primitives such as int, double, float etc, a copy of the value is made and that is passed by value:-

int x = 10; public void foo(int k){ } foo(x) 

Here k will get a copy of the value stored in x so k will now have a value of 10. However, x and y are in two different memory locations. Changing the value of x will not change the value of k.

For object references a copy of the reference is made and that is passed by value (a reference is nothing more than the address of some memory). So in essence both references will now point to the same object (that is, the same memory location).

Myobject m = new Myobject(); public void bar (Myobject j){ } bar(m) 

A copy of the value of the reference m will be made and assigned to j. Both m and j will now point to the same object.

The difference here, is that a1 and b1 are not the objects themselves but references to those objects. So, if you modify the object referenced by a1 the object referenced by b1 (which is the same object) will change too. If however you tell a1 to point to another instance (or null in this case) it will no longer reference the same object so changes to that won't effect b1.

To go into a little more detail: Java is pass by value. However when you try to pass an object (rather than a primitive value) you're actually passing the value of the reference (also sometimes called the handle). That's why it can sometimes be a bit confusing when trying to determine whether Java is pass by handle or pass by reference.

Check this image. A2/A3 are REFERENCES to bojects. In first case these are references to Set (a1 on image). When one reference modifies object second reference sees the same change

On the other hand if you just set reference = null then you "erase one arrow" from the picture. The reference stops pointing to object, but the other reference still points to it.

You just noticed that java is completly pass by value, in which even references to other objects are passed as value.

If you null an object you are actually not nulling objects, which methods would be executed on the same object. You are only nulling the value of the reference to the object.

Check this example, you are just nulling the value of the reference on list 1, while you are still able to execute the methods on the original list.

ArrayList<Integer> list1 = new ArrayList<Integer>(0); list1.add(1); list1.add(2); ArrayList<Integer> list2 = list1; list1.clear(); list1 = null; System.out.println(list2.size()); System.out.println(list1.size()); // will cause an nullpointerexception 

The calls of methods on list1 does also effect list2, but nulling the object list1 wont affect the list 1

My answer is an additional element to @I.K. answer. Primitives (copy of value) and Non-Primitives (copy of reference values) - that's the key understanding.

Look at this code where I have put the comments (hosted on IDEONE):

import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */ class Ideone { public static void main (String[] args) throws java.lang.Exception { String a1 = "blablabla"; String b1 = a1; System.out.println(b1); System.out.println(a1); System.out.println(b1.hashCode()); System.out.println(a1.hashCode()); a1 = "wow"; System.out.println(b1.hashCode()); System.out.println(a1.hashCode()); System.out.println(b1); System.out.println(a1); Set<String> a = new HashSet<String>(); Set<String> b = a; a.add("hey"); a.add("HellO"); System.out.println(b.size()); System.out.println(b.hashCode()); // e.g. 69712814 System.out.println(a.hashCode()); // same - 69712814 (It's important to know) a.clear(); System.out.println(a.size()); // same hashcode i.e. gets affected by the change. System.out.println(b.size()); 

You can see that they are effectively hashed using the same code.

String class is a bit special in Java as you probably know that they use the String pool for "Intern"ing the values. If you run the code above you can see that as soon as you do a1 = "wow"; it will create a new value "wow" in the pool and therefore, the hashCode() changes.