java函数的按值传递

引言

今天在做算法课布置的题目的做完以后，重新深入了解了一下递归，在以下算法中，我需要对path在一个栈帧结束前将path进行回溯操作，我好像不知道什么像path一样需要回溯，而什么像pathLen一样不需要回溯。

    //每个节点的值加起来就是这条路径的长度
    public static List<Integer> maxPathList;
    public static int maxLen = 0;
    public static void maxPath(TreeNode root, ArrayList<Integer> path, int pathLen){
        if(root == null)
            return;
        path.add(root.val);
        pathLen += root.val;
        if(root.left == null && root.right == null){
            if(pathLen > maxLen){
                maxPathList= (List<Integer>) path.clone();
                maxLen = pathLen;
            }
        }
        maxPath(root.left, path, pathLen);
        maxPath(root.right, path, pathLen);
        path.remove(path.size()-1);
    }

根源：按值传递

普通的按值传递

对于pathLen这个int型变量，它总是按值传递，在递归调用的过程中，系统将每一次递归的状态都保存在一个栈帧里，这也就意味着每次进入函数时，pathLen的值都有着自己的状态，与别的栈帧中pathLen的值毫无关系。

因此并不需要对pathLen进行回溯的操作。

初探引用型变量的按值传递

而对于path这个ArrayList变量，它也是按值传递，但此处的“值”可能跟你想象的不一样，它并不是这个对象中所有的数据总和，而是这个对象的引用。

你可能会疑惑，那这不是按引用传递吗，怎么说是按值传递呢？因为一个引用它本身就是一个值，你可以理解为引用的值，参考以下语句：

ArrayList<Integer> list = new ArrayList<>();

Employee employee = new Employee();

这个句子我们再熟悉不过，现在再来思考，list到底是什么，employee到底是什么，它其实并不是这个对象本身，而是一个具体的employee的引用，list和employee只是一个引用而已。

深究引用型变量之按值传递

那么理清了这点以后，再回头看看前面那句话，函数传递的是什么，是一个引用的值，那我们将引用的值传进函数里，其实通俗一点就是指的传递的是原引用的副本。

你可能还是会说，那这不还是按引用传递吗？重点来了，由于你传递的是一个引用的副本，那么原引用一直指向着一个ArrayList，但传进函数的这个引用副本它可以随意的指向其他ArrayList，而不会影响原引用的指向：

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> listSrc = new ArrayList<>();
        listSrc.add(99);
        System.out.println(listSrc);
        function(listSrc);
        System.out.println(listSrc);
    }
    public static void function(ArrayList<Integer> list){
        list.set(0, 88);
        ArrayList<Integer> other = new ArrayList<>();
        other.add(1); other.add(2);
        list = other;
    }
}

[99]
[88]

参考上述案例，你应该就彻底明白了，我们将listSrc传递到function里，而函数中的list和listSrc一开始指向的是同一个ArrayList，因此它可以操控并改变listSrc所指向的ArrayList，也就是说，将ArrayList的引用传入函数时，它们俩指向的是同一片内存空间。

但函数中的list毕竟只是和listSrc拥有相同的"值"，所以当list的"值"改变时，并不会影响listSrc的"值"，这里的值就是前面说的"引用的值"。

总结

因此在本文一开始的案例中，由于path所指向的ArrayList始终是同一个对象，即便递归中的每个栈帧都有一个独立的path引用，但它们始终共享的是同一片内存空间。

所以你现在明白了吧，对于引用型变量，它们在递归的时候，往往为了确保引用型对象(比如ArrayList和int[])在每个栈帧中都有独立的不同的状态，你需要在适当的时候对其做回溯操作。