两个不同的对象打印属性相同的值

Question

我正在写一个程序，其中我有一个板（3 x 3矩阵），我必须交换特定的行和列中的值与其相邻的行和列逻辑，如果我在[0,0] 0值，那么我想有两个板。一个在[0,1]和[0,1] s处的值为[0,0]处具有0值并且另一个板处于[1,0]和[1,0] s处的值为[0， 0]。但是在执行下面的代码之后，我有两个具有相同值的板，我无法理解这些错误值的任何解释。

编辑：下面我有两个相关的类和相关的方法。问题在于Board类的邻居方法。看起来，当我在邻居方法中创建一个电路板时，它并没有做它应该做的事情。

Board类

public final class Board { 
private final int dimen; 
private final int[][] blocks; 

public Board(int[][] blocks)   // construct a board from an N-by-N array of blocks 
    // (where blocks[i][j] = block in row i, column j) 
{ 
    this.dimen = blocks.length; 
    this.blocks = new int[dimen][dimen]; 
    for (int i = 0; i < dimen; ++i) { 
     for (int j = 0; j < dimen; ++j) { 
      this.blocks[i][j] = blocks[i][j]; 
      System.out.println (this.blocks[i][j]); 
     } 
    } 
... 
... 

public Iterable<Board> neighbors()  // all neighboring boards 
{ 
    Stack<Board> neighborStack = new Stack <Board>(); 
    int x = 0, y = 0; 
    outer : for (int i = 0; i < dimen; ++i){ 
     for (int j = 0; j < dimen; ++j) { 
      if (this.blocks[i][j] == 0) { 
       x = i; 
       y = j; 
       break outer;   
      } 
     } 
    } 

    if (x == 0) 
    { 
     if (y == 0) { 
      int tmpBlocks1[][] = Arrays.copyOf (this.blocks, this.blocks.length); 
      int tmpBlocks2[][] = Arrays.copyOf (this.blocks, this.blocks.length); 

      tmpBlocks1[0][0] = tmpBlocks1[0][1]; 
      tmpBlocks1[0][1] = 0; 

      tmpBlocks2[0][0] = tmpBlocks2[1][0]; 
      tmpBlocks2[1][0] = 0; 

      Board tmpBoard1 = new Board (tmpBlocks1); 
      neighborStack.push (tmpBoard1); 

      Board tmpBoard2 = new Board (tmpBlocks2);    
      neighborStack.push (tmpBoard2); 

} 

求解器类：

public final class Solver { 

private MinPQ <SearchNode> pqOriginal; 
private MinPQ <SearchNode> pqTwin; 
Stack <Board> shortestBoardSequence = null; 
int moves = 0; 

public Solver(Board initial)   // find a solution to the initial board (using the A* algorithm) 
{ 
    pqOriginal = new MinPQ<SearchNode>(); 
    pqTwin = new MinPQ<SearchNode>(); 
    pqOriginal.insert(new SearchNode (moves, initial, null)); 
    pqTwin.insert(new SearchNode (moves, initial.twin(), null)); 
} 

public boolean isSolvable()    // is the initial board solvable? 
{ 
    SearchNode originalNode = null; 
    SearchNode twinNode = null; 
    Stack <Board> neighborBoards = null; 
    while (!pqOriginal.isEmpty() || !pqTwin.isEmpty()) { 

     originalNode = pqOriginal.delMin(); 
     // shortestBoardSequence.push(originalNode.board); 

     neighborBoards = (Stack<Board>)originalNode.board.neighbors(); 
... 
} 
... 
} 
... 
public static void main(String[] args) // solve a slider puzzle (given below) 
{ 
    // create initial board from file 
    In in = new In(args[0]); 
    int N = in.readInt(); 
    int[][] blocks = new int[N][N]; 
    for (int i = 0; i < N; i++) 
     for (int j = 0; j < N; j++) 
     blocks[i][j] = in.readInt(); 
    Board initial = new Board(blocks); 

    // solve the puzzle 
    Solver solver = new Solver(initial); 

    // print solution to standard output 
    if (!solver.isSolvable()) // SEE THE ISSOLVABLE 
     StdOut.println("No solution possible"); 
    .. 
} 

Answer 1

这可能是因为你有一个二维数组，你只复制一个维度。

这样做：

int tmpBlocks1[][] = Arrays.copyOf (blocks, blocks.length); 

你实际上只复制行的引用，而不是行数据。你是做等价的：

int[] row0 = {0,0,0}; 
int[] row1 = {0,0,0}; 
int[] row2 = {0,0,0}; 
int[][] blocks = {row0, row1, row2}; 
int[][] tmpBlocks1 = {row0, row1, row2}; 

等tmpBlocks持有相同的行为blocks。

你需要做的是数组的所谓deep copy。

实施例的代码来演示该问题：

public final class Test<T> { 
    int[][] blocks = {{0,1,2},{10,11,12},{20,21,22}}; 
    int[][] copyOfBlocks = Arrays.copyOf(blocks, blocks.length); 
    int[][] deepCopyOfBlocks = { 
    Arrays.copyOf(blocks[0], blocks[0].length), 
    Arrays.copyOf(blocks[1], blocks[1].length), 
    Arrays.copyOf(blocks[2], blocks[2].length) 
    }; 

    public void test() { 
    System.out.println("Before"); 
    System.out.println("Blocks: "+Arrays.deepToString(blocks)); 
    System.out.println("Shallow Copy: "+Arrays.deepToString(copyOfBlocks)); 
    System.out.println("Deep Copy: "+Arrays.deepToString(deepCopyOfBlocks)); 

    // Change blocks and copy and deep copy. 
    blocks[0][0] = 99; 
    copyOfBlocks[0][0] = 88; 
    deepCopyOfBlocks[0][0] = 77; 

    System.out.println("After"); 
    System.out.println("Blocks: "+Arrays.deepToString(blocks)); 
    System.out.println("Shallow Copy: "+Arrays.deepToString(copyOfBlocks)); 
    System.out.println("Deep Copy: "+Arrays.deepToString(deepCopyOfBlocks)); 
    } 

    public static void main(String[] args) throws InterruptedException { 
    try { 
     Test test = new Test(); 
     test.test(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
    } 
} 

打印：

Before 
Blocks: [[0, 1, 2], [10, 11, 12], [20, 21, 22]] 
Shallow Copy: [[0, 1, 2], [10, 11, 12], [20, 21, 22]] 
Deep Copy: [[0, 1, 2], [10, 11, 12], [20, 21, 22]] 
After 
Blocks: [[88, 1, 2], [10, 11, 12], [20, 21, 22]] 
Shallow Copy: [[88, 1, 2], [10, 11, 12], [20, 21, 22]] 
Deep Copy: [[77, 1, 2], [10, 11, 12], [20, 21, 22]] 

注意到99的变化是由变化重写到88说明该复制是指的行原版的。使用77时，只有深拷贝受到影响。