在递归调用中将数组作为参数传递时的行为

Question

I thought I understood the concept of pass by value and reference in Java. But I just found out that I don't.

Below are two methods that are being recursively called. In the first method, I am passing an array in the recursive calls, from top to bottom. When the condition is met, it prints the array and then returns. As the recursive calls return, the elements added to the array are removed with the return from each level.

But if I use an ArrayList , the additions of elements to the list is permanent, even after all the recursive calls return.

I assumed that in both cases, I am passing the array and Arraylist by reference (copy of reference) and I'm directly modifying the array. So whatever changes i make in the array, shouldn't it remain after the method returns? Please suggest, where am I getting it wrong.

I have not added the print() , I guess its evident from the output.

static void recurse(int[] list, int num) {
    if(num == 5) {  // print if condition is true
        print("Reached num = 5", list, num); 
        return;
    }
    list[num] = num;
    recurse(list,num+1);
    print("After recursive call returns ", list, num);// check elements in array
}

static void recurse(ArrayList<Integer> list, int num) {
    if(num == 5) {  // print if condition is true
        print("Reached num = 5", list); 
        return;
    }       
    list.add(num);
    recurse(list,num+1);
    print("After recursive call returns ", list); // check element of Arraylist
}
private static void print(String msg, ArrayList<Integer> list) {
    System.out.println(msg);
    System.out.println(list);       
}
private static void print(String msg, int[] list, int index) {
    System.out.println(msg);
    for(int i = 0 ; i < index; ++i)
        System.out.printf("%d ", list[i]);
    System.out.println();       
}

public static void main(String[] args) {
    ArrayList<Integer> arr1 = new ArrayList<>();
    recurse(arr1,0);
    int[] arr2 = new int[12];
    recurse(arr2,0);
}

Output from First

Reached num = 5
0 1 2 3 4 
After recursive call returns 
0 1 2 3 
After recursive call returns 
0 1 2 
After recursive call returns 
0 1 
After recursive call returns 
0 
After recursive call returns

Output from second

Reached num = 5
[0, 1, 2, 3, 4]
After recursive call returns 
[0, 1, 2, 3, 4]
After recursive call returns 
[0, 1, 2, 3, 4]
After recursive call returns 
[0, 1, 2, 3, 4]
After recursive call returns 
[0, 1, 2, 3, 4]
After recursive call returns 
[0, 1, 2, 3, 4]

Answer 1

Java only uses pass by value. That means: If you pass an int (or any other primitive) to a method, the method works on a copy of that value. The same applies to references: If you change the reference in the method, the caller doesn't care.

Now, in java int[] is a object, so, you have a reference which you pass to the method. If the method changes the content of the array, the caller sees the change. If you assign a another array to the reference, the caller doesn't see the new array reference.

Nice article about java parameter passing

Now to your problem: I think your print method uses a for loop in the array case, which then uses num as a boundary and in the array list case you use to string. But thats a guess, please post your print method(s?)

Edit :

Just as I thought: You use toString() on the list, so the whole content will be printed. Since you call that after the recursive call, the list is already populated. Since the array version of the method uses the index, you only print the content till this index. eg if index is 1 you print element at 0 where the toString() of ArrayList prints everything.

If you change your print method to use the length field instead of index you should see the same output as in the list version:

private static void print(String msg, int[] list, int index) {
    System.out.println(msg);
    for(int i = 0 ; i < list.length; ++i) {
        System.out.printf("%d ", list[i]);
    }
    System.out.println();       
}

Integer is a object wrapper for int. For your code, it doesn't make a semantic difference, but you allocate memory on the heap to store the actual int value. Use int, where possible. For the ArrayList generic (T) you cannot use int, since int is not part of the object type system (a little sloppy formulated). You have to use Integer.

Answer 2

I think maybe your problem is that you're having trouble getting your head around recursion. Join the crowd -- everybody else has the same problem, which is one reason to avoid recursion (another being not to blow up the call stack).

Try setting a breakpoint on the first line of the recurse method (either one), then step through it with the debugger to follow the actuall execution path.

What you'll find is that the basic logic is set next number set next number set next number set next number set next number print print print print print

If you remove the index from the int[] version of your print() method, you'll find that you have the same output as for the ArrayList vresion.

Answer 3

Here you are doing pass by reference only (both in the case of array and ArrayList). You are passing the reference of array from the main method which in turn is passed to every recursive call. So if you change anything in the array in each recursive call,then that change in the array will be reflected to called function. So you are correct about what you have learnt for pass by reference and pass by value.

But your print method is confusing you and making things complicated for you. In your print method that takes ArrayList as an argument, you are printing the complete arraylist each after each recursive call. But for you array you are only printing it till particular index. You need to print complete array as you did with arrayList. Therefore, you can change the function signature of print method as following

private static void print(String msg, int[] list ) {
System.out.println(msg);
for(int i = 0 ; i <5; ++i)
    System.out.printf("%d ", list[i]);
System.out.println();       

}