递归期间的字符串参数

Question

I want to understand functionality of following recursive code which basically print paths of a binary tree.

//Node has int val; Node left; Node right;
public List<String> printPaths(Node root) {
    List<String> paths = new ArrayList<String>();
    printPaths(root, paths, Integer.toString(root.val)); //root is not null
    return paths;
}

public void printPaths(Node root, List<String> paths, String onePath) {
    if(root.left == null && root.right == null) {
        paths.add(onePath);
    }
    if (root.left != null) {
        printPaths(root.left, paths, onePath + Integer.toString(root.left.val));
    }
    if (root.right != null) {
        printPaths(root.left, paths, onePath + Integer.toString(root.right.val));
    }
}

Now this prints proper path values, but I don't understand that since I update onePath & don't reset it how the value gets reset to root.val for each separate path? How is the onePath value getting reset to binary tree's root value for every tree path even after I append "->" + val for the previous path?

Answer 1

A String is immutable, and concatenating two Strings with the + operator creates a new String instance. The original String instances that were concatenated remain unchanged.

Therefore, each recursive method call has its own onePath local variable on the call stack, which refers to a different String instance.

When a call to printPaths(..,..,"something" + "someNumber") returns, the local onePath variable (on the stack frame of that method call) that contained somethingsomeNumber can be garbage collected, and the onePath variable that refers to the String "something" is in the current stack frame.

The only thing that changes is the current stack frame.