A simple ambiguity regarding the thing that in java everything is passed by copy??

[j.gohel]

Hi,

I have read that java passes-by-copy everything.But the behaviour of the following code i am not able to understand:

import java.util.*;

public class  Test1
{
	public static void main(String[] args) 
	{
		ArrayList list  = new ArrayList();
		list.add("1");
		list.add("2");
		list.add("3");
		func(list);
		System.out.println("Arr1 ---> " + list);

	}

	static void func(ArrayList arr)
	{
		arr.add("4");
		arr.add("5");
		arr.add("6");
		System.out.println("Arr2 --> " + arr);

	}
}

It o/p is:

C:\JIGNESH_GOHEL\JigneshG\JavaProgs>java Test1
Arr2 --> [1, 2, 3, 4, 5, 6]
Arr1 ---> [1, 2, 3, 4, 5, 6]

But it should be somewhat like this as per my understanding(correct me if am wrong)

Arr2 --> [4, 5, 6]
Arr1 ---> [1, 2, 3]

So can i get the explaination why this is happening??
It seems the arraylist object is passed by reference

[Belisarius]

That's a very good question. In Java, *everything* is pass-by-value (or pass-by-copy). The misconception comes from not understanding exactly what is being passed.

In Java, if you pass a primitive to a method, you pass the value as opposed to the actual reference to the variable. If you pass an Object, you pass the value of the *reference* (as opposed to the actual reference). This is a very confusing point, and regularly confuses programming experts.

Consider this code:

public class test{

  static public void main(String[] args){
     int a = 99;
     System.out.println(a);
     foo(a);
     System.out.println(a);
  }

   static public void foo(int a){
      System.out.println(a);
      a = 10;
      System.out.println(a);
   }
}

Now, the output would be:

99
99
10
99

I trust you understand why.

Now, let's look at this second example:

public class test{

  static public void main(String[] args){
     String a = "Hello";
     System.out.println(a);
     foo(a);
     System.out.println(a);
  }

   static public void foo(String a){
      System.out.println(a);
      a = "World";
      System.out.println(a);
   }
}

The output would be:

Hello
Hello
World
Hello

This is how you expected it to work, yes?

What you did in your example was actually perform operations on the ArrayList. You will find you can modify an object passed to a method to your hearts content, but you cannot modify the reference, because you are only working on a *copy* of the reference, not the *actual* reference.

Consider it this way - I create object "foo". I then pass a copy of the memory reference to a method. That method now knows where "foo" is stored in memory. I can perform all sorts of operations on that object. But when I exit the method, "foo" still references that object. I cannot destroy or manipulate that reference. It retains the changes I made to the *Object*, but doesn't reflect any changes I made to the *reference*.

Go ahead, you'll find that you cannot make that ArrayList you manipulated equal a new ArrayList from within the method. If you set it equal to a new ArrayList, when you exit the method, you'll find that "list" still equals the old ArrayList.