Question

我有一个有这些私人成员的班级：

private ArrayList<ArrayList<ArrayList<CustomStuff>>> listOfPaths;
private int currentIndex;

我用这样的方法填充数组：

listOfPaths.get(currentIndex).add(path); //path is ArrayList<CustomStuff>

到目前为止，一切都很好检查：

System.out.println(listOfPaths.get(currentIdx).get(listOfPaths.get(currentIdx).size() - 1).size());

提供合适的尺寸。

现在：方法完成后。 ArrayList<ArrayList<ArrayList<CustomStuff>>>

中每个叶子中只剩下一个对象

所以System.out.println(listOfPaths.get(anyValidIdx).get(anyValidIdx).size());永远是1！

顺便说一下：listOfPaths.size()和listOfPaths.get(anyValidIdx).size()给出正确的尺寸！

因此，只有数组的第三维似乎缩小为单个对象。

出了什么问题？

背景故事：我在矩阵上有点。开始和结束标记。在那些标记之间我有路径。路径由步骤组成。所以：
- 路径为ArrayList<Step> - 相同开始/结束标记的不同路径的集合是：ArrayList<ArrayList<Step>> - 矩阵上的所有集合都是ArrayList<ArrayList<ArrayList<Step>>>。

我从一对标记开始，查找所有可用路径。搜索时，我添加了所有找到的路径：listPaths.get(currentIndex).add(pathBetweenStartAndEnd)
因此，当我完成为一对标记获取路径时，我增加currentIndex并移动到下一对标记，依此类推......

完整代码：

import java.util.ArrayList;

public class Solver {

    protected GameBoard board;

    private static ArrayList<ArrayList<ArrayList<BoardCell>>> listOfPaths;
    private int currentPair;

    public GameBoard getSolvedBoard() {
        solve();
        return board;
    }

    public void setBoard(GameBoard board) {
        this.board = board;
    }

    public Solver(GameBoard board)
    {
        super();

        this.board = board;
    }


    protected void solve()
    {
        listOfPaths = new ArrayList<ArrayList<ArrayList<BoardCell>>>();
        currentPair = 0;

        for(CellPair pair : board.getPairs())
        {
            System.out.printf("Getting paths for %d:\n", pair.getFirstCell().getValue());

            ArrayList<BoardCell> path = new ArrayList<BoardCell>();
            path.add(pair.getFirstCell());

            listOfPaths.add(new ArrayList<ArrayList<BoardCell>>());

            DFS(pair.getFirstCell(), pair.getSecondCell(), new ArrayList<BoardCell>(), path);

            System.out.println("--------------------------------------------------");

            ++currentPair;
        }

        System.out.println(listOfPaths.get(0).get(0).size());
        //System.out.println(listOfPaths.get(2).get(205).get(1));
    }

    protected static ArrayList<BoardCell> getSonsForCellOnBoard(BoardCell cell, GameBoard board)
    {
        int row     = cell.getRow(),
            column  = cell.getColumn();

        ArrayList<BoardCell> neighbors = new ArrayList<BoardCell>();

        if(row > 0)
            neighbors.add(board.getCellAtIndex(row - 1, column));
        if(row < board.getNumberOfRows() - 1)
            neighbors.add(board.getCellAtIndex(row + 1, column));
        if(column > 0)
            neighbors.add(board.getCellAtIndex(row, column - 1));
        if(column < board.getNumberOfColumns() - 1)
            neighbors.add(board.getCellAtIndex(row, column + 1));

        return neighbors;
    }

    private void DFS(   BoardCell source, 
                        BoardCell target, 
                        ArrayList<BoardCell> visited, 
                        ArrayList<BoardCell> path   )
    {
        if(source.getRow() == target.getRow() && source.getColumn() == target.getColumn())
        {
            System.out.printf("PATH: %d: ", path.size());
            System.out.println(path);

            ArrayList<BoardCell> temp = new ArrayList<BoardCell>();
            temp = path;

            listOfPaths.get(currentPair).add(temp);

            System.out.println(listOfPaths.get(currentPair).get(listOfPaths.get(currentPair).size() - 1).size());

            return; 
        }

        for(BoardCell son : Solver.getSonsForCellOnBoard(source, board))
        {
            if(visited.contains(son))
                continue;

            if(son != target &&
                    son.getType() == BoardCell.BoardCellType.BoardCell_AnchorCell)
                continue;

            path.add(son);
            visited.add(son);

            DFS(son, target, visited, path);

            visited.remove(son);
            path.remove(path.size() - 1);
        }
    }
}

Answer 1

在Java中，非基本类型（存储在路径中的列表中的列表）通过引用而不是值传递。

致电时：

DFS(son, target, visited, path);

最终在递归结束时，您将路径存储在listOfPaths。

中

但是在你做完之后：

visited.remove(son);
path.remove(path.size() - 1);

由于路径作为参考传递，因此对它的任何更改都会影响存储在listOfPaths中的路径。

所以替换它（在这种情况下，temp是多余的btw）：

ArrayList<BoardCell> temp = new ArrayList<BoardCell>();
temp = path;

listOfPaths.get(currentPair).add(temp);

这样（只是复制路径列表）：

ArrayList<BoardCell> temp = new ArrayList<BoardCell>(); 
for (BoardCell bc : path)   
     temp.add(bc);

listOfPaths.get(currentPair).add(temp);

在代码中寻找更多类似问题的地方。

对象消失了ArrayList

1 个答案: