我在Arraylist中遇到了一个问题，它覆盖了我添加到Arraylist中的最后一个对象（称为 "Queen"）。

Question

    public class Queen {

    static int QueenPos[];
    public int her;
    int N;

     public Queen() {

     }
    public Queen(int[] queenPos) {
        this.QueenPos=queenPos;
        this.her = getHer();
        this.N=getQueenPos().length;
    }

    public static int[] getQueenPos() {
      return QueenPos;
    }

    public static void setQueenPos(int queenPos[]) {
      QueenPos = queenPos;
    } 

在这个函数中，我在Arraylist中添加了Queen对象，但在Arraylist中出现了覆盖问题。

  public static ArrayList<Queen> GenarateQueen (Queen q,int col){
    ArrayList<Queen> gen=new ArrayList<Queen>() ;


    for (int i = 0; i < q.QueenPos.length; i++) {
        int g [] = q.getQueenPos();
        g[col]=i;
        gen.add(i,new Queen(g));
        int a[]=gen.get(i).QueenPos;
        int r=0;
    }


    for (int i = 0; i < gen.size(); i++) {
        for (int k = 0; k < gen.get(i).QueenPos.length; k++) {
          System.out.print(" | "+gen.get(i).QueenPos[k]+" | ");
        }
        System.out.println();
    }               
    return gen;
  }

Answer 1

这种覆盖发生的原因是，你在相同的 QueenPos[] 对象 Queen 每次都有对象。

例子:

First Iteration :

你在 g[]中获取了 queenPos[]，它是 {0,1,2,0}，然后它被更新为 {0,1,2,0}。

Second Iteration

g[] = QueenPos[] = {0,1,2,0} 然后它被更新为{1,1,2,0} 。

由于g[]参考QueenPos[]，所以无论你在g[]中做了什么改变，它们都会反映到QueenPos[]中（g[]是QueenPos[]的浅层拷贝）。

所以，在第一次迭代之后，你的QueenPos[]被修改为{1,1,2,0}，因为你存储的是 g[] 这在你的数组列表中是间接的queenPos[]。gen 并且它被改为{1,1,2,0}。所以，这个值会在数组列表的0和1处更新。

因此，为了解决这个问题，你可以创建一个新的（深度）副本，这个副本是 QueenPos[] 每个 for 循环迭代的方法之一。联系

下面是他更新的代码，用于做同样的事情。

代码 :

 public static ArrayList<ExpressionTree> GenarateQueen (ExpressionTree q,int col){
            ArrayList<ExpressionTree> gen=new ArrayList<ExpressionTree>() ;


            for (int i = 0; i < q.QueenPos.length; i++) {
                int g[] = new int[q.QueenPos.length];
                System.arraycopy(q.QueenPos, 0, g, 0, 4); 
                g[col]=i;
                gen.add(i,new ExpressionTree(g));
                int a[]=gen.get(i).QueenPos;
                int r=0;
            }


            for (int i = 0; i < gen.size(); i++) {
                for (int k = 0; k < gen.get(i).QueenPos.length; k++) {
                  System.out.print(" | "+gen.get(i).QueenPos[k]+" | ");
                }
                System.out.println();
            }               
            return gen;
   }

Ouput

 | 0 |  | 1 |  | 2 |  | 0 | 
 | 1 |  | 1 |  | 2 |  | 0 | 
 | 2 |  | 1 |  | 2 |  | 0 | 
 | 3 |  | 1 |  | 2 |  | 0 | 

通过这条线 System.arraycopy(q.QueenPos, 0, g, 0, 4); 我正在创建新的数组 g 每每 queenPos[]，而不是以同样的方式修改 queenPos[].

而且，根据评论，你还可以移除 static 字段，也是你的构造函数。. 所以更新后的Queen对象应该是:

public class Queen{


            int QueenPos[];
            int her;
            int N;


            public ExpressionTree(int[] queenPos) {
                this.QueenPos=queenPos;
                this.her = getHer();
                this.N=getQueenPos().length;
            }

            public ExpressionTree() {

            }

            public int getHer() {
                return her;
            }

            public int[] getQueenPos() {
              return QueenPos;
            }

            public  void setQueenPos(int queenPos[]) {
              QueenPos = queenPos;
            } 
}