Java 为什么方法会更改布尔数组参数？

我有一门通过基本迷宫寻找路径的课程。迷宫沿着起始和结束位置传递到路径。我使用递归来寻找点之间的路径。路径以布尔数组的形式返回。由于某种原因，传递给Path（）的初始迷宫发生了更改。所以我尝试复制迷宫数组以避免更改任何值，但它仍然不起作用

为什么path（）要更改打开[][]？可能是C语言编程让我感到困惑

public static boolean[][] path(boolean[][] open, 
                               int start_i, int start_j, 
                               int end_i, int end_j) 
{
    int n = open.length;
    boolean[][] openCopy = new boolean[n][n]; //make a copy of open

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            openCopy[i][j] = open[i][j]; 
        }
    } 
    return findPath(openCopy, start_i, start_j, end_i, end_j);
}

public static boolean[][] findPath(boolean[][] openCopy, int start_i, int start_j, int end_i, int end_j) 
{
    boolean[][] path = new boolean[openCopy.length][openCopy[0].length];

    if(openCopy[start_i][start_j] == false) //return false if current position is not open
        return path;
    else
        openCopy[start_i][start_j] = false;  //make current position false if not (to prevent infinite backtracking)

    if(start_i == end_i && start_j == end_j) //if end found return true
    {
        path[start_i][start_j] = true;
        return path;
    }

    path = findPath(openCopy, start_i+1, start_j, end_i, end_j); // Move North
    path = findPath(openCopy, start_i, start_j+1, end_i, end_j); // Move East
    path = findPath(openCopy, start_i-1, start_j, end_i, end_j); // Move South
    path = findPath(openCopy, start_i, start_j-1, end_i, end_j); // Move West

    return path;
}

公共静态布尔[][]路径（布尔[][]打开，
int start_i，int start_j，
int end_i，int end_j）
{
int n=开放长度；
boolean[]openCopy=new boolean[n][n]；//复制open
对于（int i=0；i

我认为问题在于，您正在内部for循环中传递引用。 请尝试以下操作：

for(int j = 0; j < n; j++)
        {
            openCopy[i][j] = open[i][j]; 
        }

for（int j=0；j

这：

for（int j=0；j

---

我认为这应该会有所帮助。

我认为问题在于，您正在内部for循环中传递引用。 请尝试以下操作：

for(int j = 0; j < n; j++)
        {
            openCopy[i][j] = open[i][j]; 
        }

for（int j=0；j

这：

for（int j=0；j

---

我认为这应该会有所帮助。

我认为问题在于，您正在内部for循环中传递引用。 请尝试以下操作：

for(int j = 0; j < n; j++)
        {
            openCopy[i][j] = open[i][j]; 
        }

for（int j=0；j

这：

for（int j=0；j

---

我认为这应该会有所帮助。

我认为问题在于，您正在内部for循环中传递引用。 请尝试以下操作：

for(int j = 0; j < n; j++)
        {
            openCopy[i][j] = open[i][j]; 
        }

for（int j=0；j

这：

for（int j=0；j

---

我认为这应该会有所帮助。

事实并非如此，我知道这可能不是该方法的“合适”输入，但它证明了这一点：

public class MainForm {


public static void main(String[] args) {
    boolean[][] array = new boolean[][] {{false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}};

    boolean[] [] another = path(array, 0, 0, 3, 5);

    for (boolean[] bArray : array) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
    System.out.println("***********************");
    for (boolean[] bArray : another) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
}

public static boolean[][] path(boolean[][] open, int start_i, int start_j, int end_i, int end_j) {
    int n = open.length;
    boolean[][] openCopy = new boolean[n][n]; // make a copy of open

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            openCopy[i][j] = open[i][j];
        }
    }
    return findPath(openCopy, start_i, start_j, end_i, end_j);
}

public static boolean[][] findPath(boolean[][] openCopy, int start_i, int start_j, int end_i, int end_j) {
    boolean[][] path = new boolean[openCopy.length][openCopy[0].length];

    if (openCopy[start_i][start_j] == false) // return false if current position is not open
        return path;
    else
        openCopy[start_i][start_j] = false; // make current position false if not (to prevent infinite backtracking)

    if (start_i == end_i && start_j == end_j) // if end found return true
    {
        path[start_i][start_j] = true;
        return path;
    }

    path = findPath(openCopy, start_i + 1, start_j, end_i, end_j); // Move North
    path = findPath(openCopy, start_i, start_j + 1, end_i, end_j); // Move East
    path = findPath(openCopy, start_i - 1, start_j, end_i, end_j); // Move South
    path = findPath(openCopy, start_i, start_j - 1, end_i, end_j); // Move West

    return path;
}
}

---

显然，返回的数组和传递到path（）中的数组的内容不同，原始数组的原始值保持不变。我认为问题出在应用程序的其他地方。

事实并非如此，我知道这可能不是该方法的“适当”输入，但它证明了这一点：

public class MainForm {


public static void main(String[] args) {
    boolean[][] array = new boolean[][] {{false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}};

    boolean[] [] another = path(array, 0, 0, 3, 5);

    for (boolean[] bArray : array) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
    System.out.println("***********************");
    for (boolean[] bArray : another) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
}

public static boolean[][] path(boolean[][] open, int start_i, int start_j, int end_i, int end_j) {
    int n = open.length;
    boolean[][] openCopy = new boolean[n][n]; // make a copy of open

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            openCopy[i][j] = open[i][j];
        }
    }
    return findPath(openCopy, start_i, start_j, end_i, end_j);
}

public static boolean[][] findPath(boolean[][] openCopy, int start_i, int start_j, int end_i, int end_j) {
    boolean[][] path = new boolean[openCopy.length][openCopy[0].length];

    if (openCopy[start_i][start_j] == false) // return false if current position is not open
        return path;
    else
        openCopy[start_i][start_j] = false; // make current position false if not (to prevent infinite backtracking)

    if (start_i == end_i && start_j == end_j) // if end found return true
    {
        path[start_i][start_j] = true;
        return path;
    }

    path = findPath(openCopy, start_i + 1, start_j, end_i, end_j); // Move North
    path = findPath(openCopy, start_i, start_j + 1, end_i, end_j); // Move East
    path = findPath(openCopy, start_i - 1, start_j, end_i, end_j); // Move South
    path = findPath(openCopy, start_i, start_j - 1, end_i, end_j); // Move West

    return path;
}
}

---

显然，返回的数组和传递到path（）中的数组的内容不同，原始数组的原始值保持不变。我认为问题出在应用程序的其他地方。

事实并非如此，我知道这可能不是该方法的“适当”输入，但它证明了这一点：

public class MainForm {


public static void main(String[] args) {
    boolean[][] array = new boolean[][] {{false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}};

    boolean[] [] another = path(array, 0, 0, 3, 5);

    for (boolean[] bArray : array) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
    System.out.println("***********************");
    for (boolean[] bArray : another) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
}

public static boolean[][] path(boolean[][] open, int start_i, int start_j, int end_i, int end_j) {
    int n = open.length;
    boolean[][] openCopy = new boolean[n][n]; // make a copy of open

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            openCopy[i][j] = open[i][j];
        }
    }
    return findPath(openCopy, start_i, start_j, end_i, end_j);
}

public static boolean[][] findPath(boolean[][] openCopy, int start_i, int start_j, int end_i, int end_j) {
    boolean[][] path = new boolean[openCopy.length][openCopy[0].length];

    if (openCopy[start_i][start_j] == false) // return false if current position is not open
        return path;
    else
        openCopy[start_i][start_j] = false; // make current position false if not (to prevent infinite backtracking)

    if (start_i == end_i && start_j == end_j) // if end found return true
    {
        path[start_i][start_j] = true;
        return path;
    }

    path = findPath(openCopy, start_i + 1, start_j, end_i, end_j); // Move North
    path = findPath(openCopy, start_i, start_j + 1, end_i, end_j); // Move East
    path = findPath(openCopy, start_i - 1, start_j, end_i, end_j); // Move South
    path = findPath(openCopy, start_i, start_j - 1, end_i, end_j); // Move West

    return path;
}
}

---

显然，返回的数组和传递到path（）中的数组的内容不同，原始数组的原始值保持不变。我认为问题出在应用程序的其他地方。

事实并非如此，我知道这可能不是该方法的“适当”输入，但它证明了这一点：

public class MainForm {


public static void main(String[] args) {
    boolean[][] array = new boolean[][] {{false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}, 
            {false, false, true, false, false, false}};

    boolean[] [] another = path(array, 0, 0, 3, 5);

    for (boolean[] bArray : array) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
    System.out.println("***********************");
    for (boolean[] bArray : another) {
        for (boolean b : bArray) {
            System.out.println(b);
        }
    }
}

public static boolean[][] path(boolean[][] open, int start_i, int start_j, int end_i, int end_j) {
    int n = open.length;
    boolean[][] openCopy = new boolean[n][n]; // make a copy of open

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            openCopy[i][j] = open[i][j];
        }
    }
    return findPath(openCopy, start_i, start_j, end_i, end_j);
}

public static boolean[][] findPath(boolean[][] openCopy, int start_i, int start_j, int end_i, int end_j) {
    boolean[][] path = new boolean[openCopy.length][openCopy[0].length];

    if (openCopy[start_i][start_j] == false) // return false if current position is not open
        return path;
    else
        openCopy[start_i][start_j] = false; // make current position false if not (to prevent infinite backtracking)

    if (start_i == end_i && start_j == end_j) // if end found return true
    {
        path[start_i][start_j] = true;
        return path;
    }

    path = findPath(openCopy, start_i + 1, start_j, end_i, end_j); // Move North
    path = findPath(openCopy, start_i, start_j + 1, end_i, end_j); // Move East
    path = findPath(openCopy, start_i - 1, start_j, end_i, end_j); // Move South
    path = findPath(openCopy, start_i, start_j - 1, end_i, end_j); // Move West

    return path;
}
}

---

显然，返回的数组和传递到path（）中的数组的内容不同，原始数组的原始值保持不变。我认为问题出在应用程序的其他地方。

请查看此链接：@AKS“boolean[]]openCopy=new boolean[n][n]；“应该创建一个新数组，该数组可以在不更改原始数组的情况下进行更改。至少我这么认为。你是如何看待价值的变化的？这里的任何内容都不会影响传递到

path（）

@DHall的数组

open

，我在传递到path（）之前打印了“open”，然后再打印，结果不匹配。我将再次检查打印是否有错误。请查看此链接：@AKS“boolean[][]openCopy=new boolean[n][n]；”应创建一个新数组，该数组可以在不更改原始数组的情况下进行更改。至少我这么认为。你是如何看待价值的变化的？这里的任何内容都不会影响传递到

path（）

@DHall的数组

open

，我在传递到path（）之前打印了“open”，然后再打印，结果不匹配。我将再次检查打印是否有错误。请查看此链接：@AKS“boolean[][]openCopy=new boolean[n][n]；”应创建一个新数组，该数组可以在不更改原始数组的情况下进行更改。至少我这么认为。你是如何看待价值的变化的？这里的任何内容都不会影响传递到

path（）

@DHall的数组

open

，我在传递到path（）之前打印了“open”，然后再打印，结果不匹配。我将再次检查打印错误。请查看此链接：@AKS“boolean[][]openC