Java 无法在没有引用的情况下复制ArrayList

我正在尝试做一个基本的国际象棋AI。我有一个“Schach”类，它存储白色数字和黑色数字的数组列表。当轮到人工智能做出一个动作时，我首先添加所有动作，下一步我想删除那些使自己处于受控状态的动作。但出于某种原因，人工智能只是执行它所拥有的每一个可能的动作。我甚至没有更新主类中的列表，问题在于列表总是引用AI类中的列表

---

另外我已经尝试了clone（）方法，但没有成功。有什么建议吗

public class Ai {

    public static final Ai ai = new Ai();

    private static int maxY = 8;
    private static int maxX = 7;
    private static int minY = 1;
    private static int minX = 0;

    private static ArrayList<Entity> whiteFigures;
    private static ArrayList<Entity> blackFigures;
    private static ArrayList<Move> moves;

    public void processMoves() {

        moves = new ArrayList<Move>();

        resetLists();

        for (Entity e : blackFigures) {
            moves.addAll(calcMoves(e.getFigure(), blackFigures, whiteFigures));
        }

        System.out.println(moves.size());

        //removeCheckMoves();

        System.out.println(moves.size());

        executeMove(moves.get((int) (Math.random() * moves.size())));

        resetLists();

        Schach.turn = true;

    }

    private void removeCheckMoves() {

        Figure king = null;

        for (Entity e : blackFigures) {
            if (e.getFigure().type == Figure.king) {
                king = e.getFigure();
                break;
            }
        }

        ArrayList<Move> legalMoves = new ArrayList<Move>();
        for (Move m : moves) {
            resetLists();
            executeMove(m);
            if(!isLegal(king)) {
                legalMoves.add(m);
            }
        }
        
        moves = legalMoves;

    }
    
    private boolean isLegal(Figure king) {
        
        boolean check = false;
        for (Entity w : whiteFigures) {
            for (Move move : Utils.calcMoves(w.getFigure(), whiteFigures, blackFigures)) {
                if (Utils.numToPos(move.to).x == king.x && Utils.numToPos(move.to).y == king.y) {
                    check = true;
                    break;
                }
            }
            if(check) break;
        }
        return check;
        
    }

    private void executeMove(Move m) {
        for (Entity e : blackFigures) {
            if (e.getFigure().x == Utils.numToPos(m.from).x && e.getFigure().y == Utils.numToPos(m.from).y) {
                e.getFigure().x = Utils.numToPos(m.to).x;
                e.getFigure().y = Utils.numToPos(m.to).y;
                e.gotoSquare(Utils.posToNum(e.getFigure()) - 8);
                for (Entity w : whiteFigures) {
                    if (w.getFigure().x == e.getFigure().x && w.getFigure().y == e.getFigure().y) {
                        whiteFigures.remove(w);
                        break;
                    }
                }
                break;
            }
        }
    }

    private void resetLists() {
        
        whiteFigures = new ArrayList<Entity>();
        whiteFigures.clear();
        whiteFigures.addAll(Schach.whiteFigures);
        blackFigures = new ArrayList<Entity>();
        blackFigures.clear();
        blackFigures.addAll(Schach.blackFigures);

    }

//calcMoves function (works fine no reference here for sure)

}

公共类Ai{
公共静态最终Ai=新Ai（）；
专用静态int maxY=8；
私有静态int maxX=7；
私有静态int minY=1；
私有静态int minX=0；
私有静态数组列表白色数字；
私有静态数组列表黑数；
私有静态数组列表移动；
public void processMoves（）{
moves=newarraylist（）；
重置列表（）；
对于（实体e：黑色数字）{
addAll（calcMoves（例如getFigure（），blackFigures，whiteFigures））；
}
System.out.println（moves.size（））；
//移除复选框（）；
System.out.println（moves.size（））；
executeMove（moves.get（（int）（Math.random（）*moves.size（））；
重置列表（）；
Schach.turn=true；
}
私有void removeCheckMoves（）{
Figure king=null；
对于（实体e：黑色数字）{
if（e.getFigure（）.type==Figure.king）{
king=e.getFigure（）；
打破
}
}
ArrayList legalMoves=新的ArrayList（）；
for（移动m:移动）{
重置列表（）；
executeMove（m）；
如果（！isLegal（国王））{
立法动议。添加（m）；
}
}
移动=法律移动；
}
私有布尔isLegal（图王）{
布尔检查=假；
对于（实体w：白色数字）{
for（移动：Utils.calcMoves（w.getFigure（），白色数字，黑色数字））{
if（Utils.numToPos（move.to）.x==king.x&&Utils.numToPos（move.to）.y==king.y）{
检查=正确；
打破
}
}
如果（检查）断裂；
}
退货检查；
}
私有void executeMove（移动m）{
对于（实体e：黑色数字）{
if（e.getFigure（）.x==Utils.numToPos（m.from）.x&&e.getFigure（）.y==Utils.numToPos（m.from）.y）{
e、 getFigure（）.x=Utils.numToPos（m.to）.x；
e、 getFigure（）.y=Utils.numToPos（m.to）.y；
e、 gotoSquare（Utils.posToNum（e.getFigure（））-8）；
对于（实体w：白色数字）{
如果（w.getFigure（）.x==e.getFigure（）.x&&w.getFigure（）.y==e.getFigure（）.y）{
白色数字。删除（w）；
打破
}
}
打破
}
}
}
私有无效重置列表（）{
whiteFigures=新的ArrayList（）；
白色数字；
whiteFigures.addAll（Schach.whiteFigures）；
blackFigures=新的ArrayList（）；
黑色数字；
黑数字。addAll（Schach.blackFigures）；
}
//calcMoves函数（工作正常此处无参考）
}

---

编辑

通过这种设置，人工智能根本不应该执行移动，只需计算它们

---

编辑2

---

resetLists函数是主要问题（我猜）

好吧，所以我自己解决了它。如果将来有人需要它，这里是我的解决方案：D

public static ArrayList<Entity> cloneList (ArrayList<Entity> array){
        ArrayList<Entity> arr = new ArrayList<Entity>();
        for(Entity e : array) {
            arr.add(cloneEntity(e));
        }
        return arr;
    }
    
    public static Entity cloneEntity(Entity e) {
        Entity entity = new Entity(e.getPosition(), [etc...]);
        return entity;
    }

公共静态ArrayList克隆列表（ArrayList数组）{
ArrayList arr=新的ArrayList（）；
for（实体e:数组）{
arr.add（克隆性（e））；
}
返回arr；
}
公共静态实体克隆性（实体e）{
实体=新实体（如getPosition（），[etc..]）；
返回实体；
}

您的列表被声明为类成员。你知道后果吗？不知道。。。你什么意思？@TimothyTruckle你是说它们是静态的？我知道这一点，也希望如此。但我不认为这会阻止人工智能做它的工作。基本上，我只想把Schach的静态列表复制到AI中的静态列表，而不让它们相互连接。“我知道，而且我支持这样。”——你的知识是错误的。特别是对于变量，只有在有充分理由这样做的情况下，才应使用

static

关键字。