java - 简单地改变一个变量的值会改变我链表中节点的值吗？这不应该发生

Question

所以，我正在用 Java 制作一个国际象棋引擎。给定当前的棋盘配置，AI 应该计算出它可以做出的每一个可能的移动，将其添加到所有可能移动的链表中，然后返回该列表。目前我正在测试以下电路板配置:

/*bRbNbBbQbKbBbNbR
  bPbPbPbPbPbPbPbP
  NuNuNuNuNuNuNuNu
  NuNuNuwRNuNuNuNu
  NuNuNuNuNuNuNuNu
  NuNuNuNuNuNuNuNu
  wPwPwPwPwPwPwPwP
  NuwNwBwQwKwBwNwR*/

“bR”表示黑车，“bN”表示黑马，等等。“Nu”表示空或没有棋子。在此配置中，我将左下角的白车移到了棋盘的中间。

我的 Mobility 类中的以下方法 possibleMoves() 应该生成并返回所有可能的棋盘配置的链表。每个索引 i 对应于棋盘上从左边开始的棋子。在这种情况下，AI 是白色的，所以 0 是最左边的白色棋子，7 是最右边的白色棋子，8 是现在位于棋盘中央的白车，9 是另一个白车，等等。现在我'只测试车，所以其他条件为空。 nonPawnBoardGen() 返回可能的棋盘配置子列表。

public LL possibleMoves(){
    LL children = new LL();
    /*
     * check each piece
     */
    for(int i = 0; i < 16; i++){
        if(i < 8){//pawns

        }
        else if(i < 10){//rooks
            children.joinWith(nonPawnBoardGen(i, 0, -1)); //positions to the left
            children.joinWith(nonPawnBoardGen(i, 0, 1)); //right
            children.joinWith(nonPawnBoardGen(i, -1, 0)); //up
            children.joinWith(nonPawnBoardGen(i, 1, 0)); //down
        }
        else if(i < 12){
        //  checkKnight(r, c, int dR, int dC)
        }
        else if(i < 14){//bishops

        }
        else{ //king, queen

        }
    }
    return children;
}

joinWith()，在我的 LL 类中，将一个子列表与总子链表连接起来。

public void joinWith(LL newList){
    if(newList.isEmpty())
        return;
    if(this.isEmpty()){
        first = newList.getFirst();
        last = newList.getLast();
    }
    else{
        last.next = newList.getFirst();
        last = newList.getLast();
    }
}

以下函数 nonPawnBoardGen() 是我的 Mobility 中的另一个函数，它传递了一 block index 和一个单位 vector 。所以，如果我想检查棋盘中央的车所有可能的左移动，我会调用 nonPawnBoardGen(8, 0, -1) 因为车是索引 8，它将保留在同一行中，并将遍历左侧的列。该函数调用应返回涉及该车的所有可能棋盘配置的子列表，因为我仍然需要检查车当前位置的右侧、上方和下方的所有内容。

private LL nonPawnBoardGen(int index, int vecR, int vecC){
    LL boardSubLst = new LL();
    int sR, sC; //source row and col
    if(turn == true){//white
        //last 16 coords are white pieces
        if(coords[index + 16] == null){//if piece does not exist, return
            return null;
        }
        sR = coords[index + 16].getRow(); //each coord is an object containing a row and col value
        sC = coords[index + 16].getCol();
    }
    else{//black
        //first 16 coords are black pieces
        if(coords[index] == null){
            return null;
        }
        sR = coords[index].getRow();
        sC = coords[index].getCol();
    }
    int curR = sR; //current row
    int curC = sC; //current col
    curR+=vecR; //iterate by unit vector
    curC+=vecC;
    while(curR > -1 && curR < 8 && curC > -1 && curC < 8){ //while in range of board
        if(turn == true){//white
            if(board[curR][curC].charAt(0) != 'w'){ //if space is free or opposite color, valid move
                coords[index + 16].setRow(curR); //move rook to new position
                coords[index + 16].setCol(curC);
                if(board[curR][curC].charAt(0) == 'b'){ //if space contains piece of opposite color,
                    int r, c;                           //piece needs to be removed
                    for(int j = 0; j < 16; j++){ //iterate through 16 opponent pieces
                        r = coords[j].getRow();
                        c = coords[j].getCol();
                        if(curR == r && curC == c){ //check which opponent's piece's coords match
                            coords[j] = null;       //the rook's current coords, then remove opp's piece
                            boardSubLst.insert(coords); //add board config to sublist
                            break;
                        }
                    }
                    break;
                }
                else{ //if the space is null, simply add board config to sublist
                    boardSubLst.insert(coords);
                }
            }
            else{ //if space is same color, break
                break;
            }
        }
        else{//black
            if(board[curR][curC].charAt(0) != 'b'){
                coords[index].setRow(curR);
                coords[index].setCol(curC);
                if(board[curR][curC].charAt(0) == 'w'){
                    int r, c;
                    for(int j = 0; j < 16; j++){
                        r = coords[j + 16].getRow();
                        c = coords[j + 16].getCol();
                        if(curR == r && curC == c){
                            coords[j + 16] = null;
                            boardSubLst.insert(coords);
                            break;
                        }
                    }
                    break;
                }
                else{
                    boardSubLst.insert(coords);
                }
            }
            else{
                break;
            }
        }
        curR+=vecR;
        curC+=vecC;
    }
    return boardSubLst;
}

长话短说，在 nonPawnBoardGen() 中，每次我获得新的有效棋盘配置时，我都会编辑棋盘坐标(在本例中为白色):

coords[index + 16].setRow(curR);
coords[index + 16].setCol(curC);

并将它们添加到电路板配置列表中:

boardSubLst.insert(coords);

但是，每次我编辑 coords 时，boardSubList 链表中的每个值都会更改为 coords 的当前值。为什么会这样？

编辑:我想我可以通过让 nonPawnBoardGen() 只生成并返回一组坐标来避免这个问题。迭代器可以保存在类中而不是本地保存在函数中。返回的每组坐标都可以直接添加到 possibleMoves() 中的子项列表中。我会试试这个，看看会发生什么......

Answer 1

当你打电话时

boardSubLst.insert(coords);

您正在将相同的引用传递给 coords 数组。我认为您会发现最简单的解决方案是复制数组，例如使用 Arrays.copyOf(T[] original, int newLength)

boardSubLst.insert(Arrays.copyOf(coords, coords.length));

或者，假设坐标是 Coord[] 类型，您可以使用 System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Coord[] coords2 = new Coord[coords.length];   
System.arraycopy(coords, 0, coords2, 0, coords.length);
boardSubLst.insert(coords2);