ArrayIndexOutOfBoundsException on generating maze graph with depth first search

Question

I created a program that solves a maze that reads a text file input. I managed to solve it using Depth-first Search and the result was fine on small mazes like this:

Everything was fine solving small to medium mazes but when the maze becomes larger, it gives me an ArrayIndexOutOfBoundsException error (see below).

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

My program should read automatically how many nodes are in the test2.txt (this is the large maze file) file but this error happens. The code looks like this:

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];
    }
}

In MazeGraph.java, the getNodeSize method returns an integer that is used for the constructor's parameter. To make it work, I have to take that getNodeSize method out in the constructor's parameter and instead put some larger value there like 300 for example. In stack trace, it says the problem is in the addArc method. I am trying to figure out on how to solve this problem if it works already in other mazes so that it also reads in large mazes automatically. Please, I would be grateful if someone can solve this.

This is the large file.

Have you validated the maze file? It is possible that the maze file itself has an error and not your code. — Austin D, Feb 02 '16 at 03:07
The maze file was fine if I change the number of nodes if you can see on the description. — Muhammad Catubig, Feb 02 '16 at 03:09
See my answer below. The changes work on the file you supplied above. — Austin D, Feb 02 '16 at 03:43

Austin D · Accepted Answer · 2016-02-03T01:39:45.237

Okay, the problem is in getNodeSize(String). You return setOfNodes.size(). The problem is that if a node is a singleton (i.e. it has no connecting arcs), then it will not be listed in the maze file. For instance, suppose your maze file is "9999 1", nothing else. Then your getNodeSize() method will return 2. Your code then instantiates the array of nodes as having size 2. Then you try to add an arc between 9999 and 1 but receive an ArrayIndexOutOfBoundsException because there's only two positions in the array, but you're trying to index position 9999.

Instead, you should return the largest node Id observed plus one. The following code accomplishes this:

/**
 * 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

}

Note: I removed the try-catch block and replaced it with a throws declaration.

A better approach: It is generally frowned upon to mix an array and a Collection. It may be better to use a HashMap:

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

You can access the adjacency list for any node by calling adjacencyList.get(nodeId) and your constructor can be changed to:

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();

}

What is the other version of your code for jdk 7 because currently the system that I am using for is jdk 7 so basically I couldn't make it work because I think your code is in jdk 8 if that does make sense to you. Thanks. — Muhammad Catubig, Feb 02 '16 at 23:47
Also, why did you put another boolean parameter in the constructor? Where did you use it for? I don't know where you have used it so I guess it is save to delete it. — Muhammad Catubig, Feb 03 '16 at 00:11
That was an artifact from me testing the method; you can remove it. I edited my answer accordingly. — Austin D, Feb 03 '16 at 01:41
Since you solved with jdk 8 I decided to change the source to jdk 8 and it works!! Thank you so much.. You solved my problem.. — Muhammad Catubig, Feb 03 '16 at 02:21

ArrayIndexOutOfBoundsException on generating maze graph with depth first search

1 Answers1