在 Java 中克隆一个列表

Question

我正在处理对象中的一个函数，该函数将对象列表作为参数并将其内容克隆到自己的列表中。修改新的 List 应该不会影响传入的 List。我知道 List 会通过引用传递，但是列表中的对象是通过引用还是值传递？ （对不起，如果这听起来很愚蠢）

我正在传递一个扩展 Piece 类的棋子列表（棋子、车等）。我正在考虑在 Piece 类中创建一个 clonePiece() 函数，但我不知道如何去做。这是我目前所拥有的：

    public void copyPieces(List<Piece> whitePieces, List<Piece> blackPieces){
    for (int i = 0; i < whitePieces.size(); i++){
        this.whitePieces.add(whitePieces.get(i).clonePiece());
    }
    for (int i = 0; i < blackPieces.size(); i++){
        this.whitePieces.add(blackPieces.get(i).clonePiece());
    }

您将如何在一个抽象类中实现一个 clonePiece() 函数来创建其继承类的新实例？

编辑：

public abstract class Piece {
private int color;
private int x;
private int y;

public Piece (int color, int x, int y){
    this.color = color;
    this.y = y;
    this.x = x;
}

public int getColor(){
    return this.color;
}
public int getX(){
    return this.x;
}
public int getY(){
    return this.y;
}

public void move(int x, int y, Board board){
    board.getGameTiles()[this.x][this.y].setToUnoccupied();
    this.x = x;
    this.y = y;
}

public abstract ArrayList<Move> getMoves(Board board);

public Piece clonePiece(){
    return this;
}

}

public class Rook extends Piece{

int x, y, color;
private ArrayList<Move> moves;

public Rook(int color, int x, int y) {
    super(color, x, y);
    this.x = x;
    this.y = y;
    this.color = color;
    moves = new ArrayList<>();
}

@Override
public ArrayList<Move> getMoves(Board board) {

    //moves right
    int a = 1;
    while(UtilFunctions.isInBoundaries(x+a, y)){
        if(!board.getGameTiles()[x+a][y].isTileOccupied()){
            //add move type 0 for passive move
            moves.add(new Move(x, y, x+a, y, 0));
        }
        else{
            if(board.getGameTiles()[x+a][y].getPiece().getColor() != this.color){
                //add move type 1 for attack move
                moves.add(new Move(x, y, x+a, y, 1));
            }
            break;
        }
        a++;
    }

    //moves left
    a = -1;
    while(UtilFunctions.isInBoundaries(x+a, y)){
        if(!board.getGameTiles()[x+a][y].isTileOccupied()){
            //add move type 0 for passive move
            moves.add(new Move(x, y, x+a, y, 0));
        }
        else{
            if(board.getGameTiles()[x+a][y].getPiece().getColor() != this.color){
                //add move type 1 for attack move
                moves.add(new Move(x, y, x+a, y, 1));
            }
            break;
        }
        a++;
    }

    //moves up
    a = 1;
    while(UtilFunctions.isInBoundaries(x, y+a)){
        if(!board.getGameTiles()[x][y+a].isTileOccupied()){
            //add move type 0 for passive move
            moves.add(new Move(x, y, x, y+a, 0));
        }
        else{
            if(board.getGameTiles()[x][y+a].getPiece().getColor() != this.color){
                //add move type 1 for attack move
                moves.add(new Move(x, y, x, y+a, 1));
            }
            break;
        }
        a++;
    }

    //moves down
    a = -1;
    while(UtilFunctions.isInBoundaries(x, y+a)){
        if(!board.getGameTiles()[x][y+a].isTileOccupied()){
            //add move type 0 for passive move
            moves.add(new Move(x, y, x, y+a, 0));
        }
        else{
            if(board.getGameTiles()[x][y+a].getPiece().getColor() != this.color){
                //add move type 1 for attack move
                moves.add(new Move(x, y, x, y+a, 1));
            }
            break;
        }
        a++;
    }

    return moves;
}

}

Answer 1

让片段返回它自己的#copy 方法（或使用Clonable）：

public abstract class Piece {

    public Piece copy() {
        //return copy
    }
}

这可以类似地用在子类中：

public class Rook extends Piece {

    @Override
    public Rook copy() {
        //return copy
    }
}

然后，当您拥有Piece 对象列表时，您只需在对象上调用#copy 并替换列表中的引用。例如：

List<Piece> pieces = /* some list */;
List<Piece> copy = new ArrayList<>(pieces);
copy.replaceAll(Piece::copy); //replace references with copies

Answer 2

您的子类不应有任何超出父类 Piece 的字段。在这个级别上没有什么本质上的不同。从子类中删除其他字段，然后授予对父 Piece 类字段的访问权限。

abstract class Piece {

    Piece(boolean white, int x, int y){
        //set fields
        ...
    }

    public abstract Piece copyPiece();
}

然后在所有子类中实现方法copyPiece()。然后调用：

public void copyPieces(List<Piece> whitePieces, List<Piece> blackPieces){
    for (Piece whitePiece : whitePieces){
        this.whitePieces.add(whitePiece.copyPiece());
    }
    for (Piece blackPiece : blackPieces){
        this.blackPieces.add(blackPiece.copyPiece());
    }
}

发布代码后编辑：

由于发布的代码，我的原始答案不适合。相应修改。

我觉得有些事情很奇怪。首先，颜色可以是布尔值white，因为只有两种颜色。接下来，您的 Rook 类无法设置对父 Piece 类的 x 和 y 字段的访问权限似乎很奇怪。

您的 clonePiece 类除了返回自身之外什么都不做，这根本不是克隆。克隆将是：return new Piece(this.color, this.x, this.y);

接下来，您的move(x, y, board) 方法不正确。首先，考虑不要传入board，而是让使用 move 方法的类来操作它。如果您不想走这条路线，则必须在棋盘上设置棋子的新位置，而不仅仅是删除旧位置。

Answer 3

首先，Clonable 是 commonly recommended to be avoided，因此我建议您改为实现复制构造函数或您自己的复制方法。

这是我建议的实现：

为了从polymorphism中受益，在Piece中添加一个抽象方法来制作deep copies

public abstract Piece deepCopy();

以及子类中的对应实现

@Override
public Rook deepCopy() {
    Rook rook = new Rook(this.getColor(), this.getX(), this.getY());
    for (Move m : this.moves) {
        rock.addMove(new Move(m));
    }
    return rook;
}

color、x 和 y 都是原始类型，这意味着在赋值时，值会被复制。但是，Rook 还包含字段move，它是引用类型Move 的列表。这意味着为了能够进行深层复制，Move 类也需要包含复制构造函数或复制方法。前者在这里显示。

public Move(Move move) {
    this(move.x, move.y);
}

最后，以 Java 7 方式复制您的片段列表：

List<Piece> newList = new ArrayList<>();
for (Piece p : oldList) {
    newList.add(p.deepCopy());
}

或 Java 8 方式（如 Darshan Mehta 之前建议的那样）：

List<Piece> newList = whitePieces.stream()
    .map(p -> p.deepCopy())
    .collect(Collectors.toList());

Answer 4

EDIT更新了示例以支持继承

您可以使Piece 类实现Cloneable 接口并覆盖impl 类中的克隆方法。 Piece 和 Rook 类将如下所示：

abstract class Piece implements Cloneable{
    int x;
    int y;

    protected void copy(Piece p){
        p.x = this.x;
        p.y = this.y;
    }
}

class Rook extends Piece{
    int z;

    @Override
    public Object clone(){
        Rook rook = new Rook();
        super.copy(rook);
        rook.z = this.z;
        return rook;
    }
}

完成后，您可以在任何片段对象上调用此方法并获取深度克隆的实例。以下是深度克隆片段列表的 Java 8 流示例：

List<Rook> pieces = new ArrayList<>();

List<Piece> cloned = pieces.stream()
                     .map(p -> (Piece) p.clone())
                     .collect(Collectors.toList());

}