使用深度优先搜索生成迷宫图时的 ArrayIndexOutOfBoundsException [重复]答案

【问题标题】：ArrayIndexOutOfBoundsException on generating maze graph with depth first search [duplicate]使用深度优先搜索生成迷宫图时的 ArrayIndexOutOfBoundsException [重复]
【发布时间】：2016-02-02 02:54:06
【问题描述】：

我创建了一个程序来解决读取文本文件输入的迷宫问题。我设法使用深度优先搜索来解决它，结果在这样的小迷宫上很好：

解决中小型迷宫的一切都很好，但是当迷宫变大时，它会给我一个 ArrayIndexOutOfBoundsException 错误（见下文）。

Enter maze file: test2.txt
Enter start node: 0
Enter goal node: 1
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 207
    at MazeGraph.addArc(MazeGraph.java:95)
    at MazeGraph.<init>(MazeGraph.java:51)
    at MazeSystem.<init>(MazeSystem.java:25)
    at MazeSystem.main(MazeSystem.java:37)
Java Result: 1

我的程序应该会自动读取 test2.txt（这是大迷宫文件）文件中有多少节点，但发生了这个错误。代码如下所示：

MazeGraph.java

import java.io.*;
import static java.lang.System.out;
import java.util.*;

/**
 * This class creates a representation of Maze as a Graph by reading from a text
 * file.
 *
 * @author Muhammad
 */
public class MazeGraph {

    final int node; //For declaring constant value of a node.
    int arc;
    List<Integer>[] adjacencyList;
    static Set<Integer> setOfNodes = new HashSet<>();
    private static Scanner scanNodeSize;

    /**
     * This constructors takes an integer parameter for reading node indexes in
     * a list of adjacent nodes.
     *
     * @param node - integer parameter for passing the nodes value from the file
     * and create a list of adjacent nodes.
     */
    MazeGraph(int node) {
        this.node = node;
        this.arc = 0;//initialise to empty arcs
        adjacencyList = (List<Integer>[]) new List[node];
        for (int index = 0; index < node; index++) {
            adjacencyList[index] = new LinkedList<Integer>();
        }
    }

    /**
     * The main constructor that takes a String parameter for reading maze file.
     *
     * @param mazeFile
     */
    public MazeGraph(String mazeFile) {
        this(getNodeSize(mazeFile));
        Scanner scan;
        try {
            //Scan maze file.
            scan = new Scanner(new File(mazeFile));
            /*loop when it has next integer then read two nodes from the file and add arc for it.*/
            while (scan.hasNextInt()) {
                int node1 = scan.nextInt();
                int node2 = scan.nextInt();
                addArc(node1, node2);
            }
        } catch (FileNotFoundException ex) {
            out.println(ex.getMessage());
        }
    }

    /**
     * This method returns a size of the set of nodes by taking a String
     * parameter which the name of the maze file.
     *
     * @param mazeFile - String parameter for reading maze file for scanning the
     * size of the nodes.
     * @return - returns an integer value for the size of the set of nodes.
     */
    public static int getNodeSize(String mazeFile) {

        try {
            scanNodeSize = new Scanner(new File(mazeFile));
            while (scanNodeSize.hasNextInt()) {
                int node1 = scanNodeSize.nextInt();
                int node2 = scanNodeSize.nextInt();
                setOfNodes.add(node1);
                setOfNodes.add(node2);
            }
            return setOfNodes.size();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return setOfNodes.size();

    }

    /**
     * This method adds an arc by adding two different nodes in array of list
     * called adjacency list.
     *
     * @param node1 - first node.
     * @param node2 - next node.
     */
    private void addArc(int node1, int node2) {
        arc++; //Increase arc by one whenever this addArc method is called.
        adjacencyList[node1].add(node2);
        adjacencyList[node2].add(node1);

    }

    //Print the nodes and its arcs by looping through the adjacency list.
    public void print() {
        out.println(node + " Nodes, " + arc + " Arcs \n");
        for (int fromNode = 0; fromNode < node; fromNode++) {
            out.print(fromNode + " connected to ");
            for (int arcNode : adjacencyList[fromNode]) {
                out.print(arcNode + " ");
            }
            out.println();
        }
    }

    /**
     * This method returns a list of nodes to allow objects to be the target for
     * "for-each" statement in order to iterate through the nodes.
     *
     * @param nodes - an Integer parameter for getting the number of nodes in a
     * list.
     * @return - returns a list of nodes.
     */
    public Iterable<Integer> getAdjacencyList(int nodes) {
        return adjacencyList[nodes];
    }
}

在 MazeGraph.java 中，getNodeSize 方法返回一个整数，用于构造函数的参数。为了使它工作，我必须在构造函数的参数中取出那个 getNodeSize 方法，而是在那里放一些更大的值，例如 300。在堆栈跟踪中，它说问题出在 addArc 方法中。如果它已经在其他迷宫中工作，我试图弄清楚如何解决这个问题，以便它也可以自动在大型迷宫中读取。请，如果有人能解决这个问题，我将不胜感激。

这是大文件。

【问题讨论】：

您是否验证了迷宫文件？可能是迷宫文件本身有错误，而不是您的代码。
如果你可以在描述中看到，我可以更改节点数，迷宫文件就可以了。
你能把大迷宫文件贴在某个地方吗？
我已经在我的描述中添加了。检查上面。谢谢。
在下面查看我的答案。这些更改适用于您在上面提供的文件。

标签： java artificial-intelligence depth-first-search undirected-graph

【解决方案1】：

好的，问题出在getNodeSize(String)。你返回setOfNodes.size()。问题是如果一个节点是一个单例（即它没有连接弧），那么它不会在迷宫文件中列出。例如，假设您的迷宫文件是“9999 1”，仅此而已。然后您的getNodeSize() 方法将返回 2。然后您的代码将节点数组实例化为大小为 2。然后您尝试在 9999 和 1 之间添加一个弧，但收到一个 ArrayIndexOutOfBoundsException，因为数组中只有两个位置，但是您正在尝试索引位置 9999。

相反，您应该返回观察到的最大节点 ID 加一。下面的代码实现了这一点：

/**
 * This method returns a size of the set of nodes by taking a String
 * parameter which the name of the maze file.
 *
 * @param mazeFile - String parameter for reading maze file for scanning the
 * size of the nodes.
 * @return - returns an integer value for the size of the set of nodes.
 * @throws FileNotFoundException if the mazeFile could not be found
 */
public static int getNodeSize(String mazeFile) throws FileNotFoundException{
        scanNodeSize = new Scanner(new File(mazeFile));
        while (scanNodeSize.hasNextInt()) {
            int node1 = scanNodeSize.nextInt();
            int node2 = scanNodeSize.nextInt();
            setOfNodes.add(node1);
            setOfNodes.add(node2);
        }

        //Changes begin here
        Integer max = setOfNodes.stream().reduce(Integer::max).get();
        return max+1;
        //Changes end here

}

注意：我删除了 try-catch 块并将其替换为 throws 声明。

更好的方法：通常不赞成将数组和Collection 混合使用。使用HashMap 可能会更好：

HashMap<Integer,List<Integer>> adjacencyList = new HashMap<>();

您可以通过调用adjacencyList.get(nodeId) 访问任何节点的邻接列表，并且您的构造函数可以更改为：

public MazeGraph(String mazeFile) {
    adjacencyMap = new HashMap<>();
    Scanner scan;
    try {
        //Scan maze file.
        scan = new Scanner(new File(mazeFile));
        /*loop when it has next integer then read two nodes from the file and add arc for it.*/
        while (scan.hasNextInt()) {
            int node1 = scan.nextInt();
            int node2 = scan.nextInt();
            List<Integer> node1AdjList = adjacencyMap.getOrDefault(node1,new LinkedList<Integer>());
            List<Integer> node2AdjList = adjacencyMap.getOrDefault(node2,new LinkedList<Integer>());
            node1AdjList.add(node2);
            node2AdjList.add(node1);
            adjacencyMap.put(node1, node1AdjList);
            adjacencyMap.put(node2, node2AdjList);
        }
    } catch (FileNotFoundException ex) {
        out.println(ex.getMessage());
    }
    node = adjacencyMap.keySet().parallelStream().reduce(Integer::max).get();

}

【讨论】：

你的 jdk 7 代码的另一个版本是什么，因为目前我使用的系统是 jdk 7，所以基本上我无法让它工作，因为我认为你的代码在 jdk 8 中，如果这对你来说很有意义。谢谢。
另外，你为什么要在构造函数中放另一个布尔参数？你把它用在什么地方了？不知道你在哪里用过，估计是保存删除吧。
那是我测试方法的产物；你可以删除它。我相应地编辑了我的答案。
既然你用 jdk 8 解决了，我决定将源代码更改为 jdk 8 并且它可以工作！！非常感谢..你解决了我的问题..