如何检查2D对象数组是否包含某个对象？ （Java）

Question

public class Maze {
    private static final int Max_Maze_Row=20;
    private static final int Max_Maze_Column=50;
    public static Entity[][] maze =new Entity[Max_Maze_Row][Max_Maze_Column];


    public Maze(){

    }

    public static void create(String filename) throws FileNotFoundException{
        Scanner fileinput=new Scanner(new FileInputStream(filename));
        fileinput.useDelimiter("");

        while(fileinput.hasNextLine()){
            for(int row=0;row<Max_Maze_Row;row++){
                String line_content=fileinput.nextLine();
                for(int col=0;col<Max_Maze_Column;col++){
                    if(line_content.charAt(col)=='*'){
                        maze[row][col]=new Wall('*',row,col);
                    }
                    if(line_content.charAt(col)==' '){
                        maze[row][col]=new Space(' ',row,col);
                    }
                }    
            }
        }
}
public abstract class Entity {
    protected char symbol;
    protected int row;
    protected int col;

    Entity(char symbol, int row, int col){
        this.symbol=symbol;
        this.row=row;
        this.col=col;
    }

    public abstract void create();

    public char Entity_put(char newEntity, int newRow, int newCol){
        char oldEntity=this.symbol;
        this.symbol=newEntity;
        this.row=newRow;
        this.col=newCol;
        System.out.println(oldEntity);
        return oldEntity;
    }

}
public class Wall extends Entity{
    public Wall(char symbol,int row,int col){
        super(symbol,row,col);
    }
    public void create(){

    }

}

我还有一个继承自Entity超类的Space类。 其本质上是''。 因此，发生的情况是该程序从文本文件读取，然后创建具有特定行，列和字符值的墙和空间实体。 这些实体存储在Entity [] []迷宫中。 但是，如何引用这些对象？ 例如，如何知道迷宫阵列中有多少个墙对象？ 基本上，我想做的事情大致如下：随机选择一个不是墙的实体（即空间实体）。 做一点事。

Answer 1

您可以使用它们的索引引用多维数组中的对象，然后可以使用instanceof标识它们是Wall还是Space .....您可以编写如下内容。 下面是一个代码，用于计算迷宫多维数组中“墙”和“空间”的数量。

public static void count(Maze[][] maze) {
    int wallCount = 0;

    int spaceCount = 0;

    if (maze != null)

        for (int i = 0; i < maze.length; i++) {

            if (maze[i] != null)
                for (int j = 0; j < maze[i].length; j++) {

                    if (maze[i][j] instanceof Wall)
                        wallCount++;
                    if (maze[i][j] instanceof Space)
                        spaceCount++;
                }

        }

}

Answer 2

编辑：我认为您可以在Entity类中具有另一个抽象函数，例如performAction ，并在每个子类中覆盖此方法，在这种情况下，即Wall和Space 。 以后遍历数组时，您可以

Entity entity = maze[row][col];
entity.performAction();

Java将确定在运行时使用哪个子类的performAction 。

================================================== =========================一种选择是将两个额外的ArrayList作为字段存储。 例如，

List<Entity> walls;
List<Entity> spaces;

在构造函数中初始化它们。

public Maze() {
    this.walls = new ArrayList<Entity>();
    this.spaces = new ArrayList<Entity>();
}

在Maze.create()的最内层循环中，您可以使用它们来跟踪墙壁和空间。

for(int col = 0; col < Max_Maze_Column; col++){
    if (line_content.charAt(col) == '*') {
        maze[row][col] = new Wall('*', row, col);
        this.walls.add(maze[row][col]);
    } 

    if (line_content.charAt(col) == ' ') {
        maze[row][col] = new Space(' ', row, col);
        this.spaces.add(maze[row][col]);
    }
}

您可以通过索引访问获得所有墙和空间。 对于大小，只需调用walls.size()和spaces.size() 。 对于随机访问，您可以使用

// int max = walls.size() or spaces.size()
Random seed = new Random();
// Generate a random integer from 0 to (max - 1)
int index = seed.nextInt(max);

当您稍后遍历数组时，第二个选项可能是使用instanceof运算符。 例如，

Entity entity = maze[row][col];

if (entity instanceof Wall) {
    Wall wall = (Wall) entity;
    // do something with wall

} else if (entity instanceof Space) {
    Space space = (Space) entity;
    // do something with space
}