**I just announced the new *** Learn Spring * course, focused on the fundamentals of Spring 5 and Spring Boot 2:

*Learn Spring*course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Last modified: January 4, 2019

Creating a multidimensional *ArrayList* often comes up during programming. In many cases, there is a need to create a two-dimensional *ArrayList* or a three-dimensional *ArrayList*.

In this tutorial, we’ll discuss how to create a multidimensional *ArrayList* in Java.

Suppose we want to represent a graph with 3 vertices, numbered 0 to 2. In addition, let’s assume there are 3 edges in the graph (0, 1), (1, 2), and (2, 0), where a pair of vertices represents an edge.

**We can represent the edges in a 2-D ArrayList by creating and populating an ArrayList of ArrayLists.**

First, let’s create a new 2-D *ArrayList*:

int vertexCount = 3; ArrayList<ArrayList<Integer>> graph = new ArrayList<>(vertexCount);

Next, we’ll initialize each element of *ArrayList* with another *ArrayList*:

for(int i=0; i < vertexCount; i++) { graph.add(new ArrayList()); }

Finally, we can add all the edges (0, 1), (1, 2), and (2, 0), to our 2-D *ArrayList*:

graph.get(0).add(1); graph.get(1).add(2); graph.get(2).add(0);

Let us also assume that our graph is not a directed graph. So, we also need to add the edges (1, 0), (2, 1), and (0, 2), to our 2-D *ArrayList*:

graph.get(1).add(0); graph.get(2).add(1); graph.get(0).add(2);

Then, to loop through the entire graph, we can use a double for loop:

int vertexCount = graph.size(); for (int i = 0; i < vertexCount; i++) { int edgeCount = graph.get(i).size(); for (int j = 0; j < edgeCount; j++) { Integer startVertex = i; Integer endVertex = graph.get(i).get(j); System.out.printf("Vertex %d is connected to vertex %d%n", startVertex, endVertex); } }

In the previous section, we created a two-dimensional *ArrayList.* Following the same logic, let’s create a three-dimensional *ArrayList*:

Let’s assume that we want to represent a 3-D space. **So, each point in this 3-D space will be represented by three coordinates, say, X, Y, and Z.**

In addition to that, let’s imagine each of those points will have a color, either Red, Green, Blue, or Yellow. Now, each point (X, Y, Z) and its color can be represented by a three-dimensional *ArrayList.*

For simplicity, let’s assume that we are creating a (2 x 2 x 2) 3-D space. It will have eight points: (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), and (1, 1, 1).

Let’s first initialize the variables and the 3-D *ArrayList*:

int x_axis_length = 2; int y_axis_length = 2; int z_axis_length = 2; ArrayList<ArrayList<ArrayList<String>>> space = new ArrayList<>(x_axis_length);

Then, let’s initialize each element of *ArrayList* with *ArrayList<ArrayList<String>>*:

for (int i = 0; i < x_axis_length; i++) { space.add(new ArrayList<ArrayList<String>>(y_axis_length)); for (int j = 0; j < y_axis_length; j++) { space.get(i).add(new ArrayList<String>(z_axis_length)); } }

Now, we can add colors to points in space. Let’s add Red color for points (0, 0, 0) and (0, 0, 1):

space.get(0).get(0).add(0,"Red"); space.get(0).get(0).add(1,"Red");

Then, let’s set Blue color for points (0, 1, 0) and (0, 1, 1):

space.get(0).get(1).add(0,"Blue"); space.get(0).get(1).add(1,"Blue");

And similarly, we can continue to populate points in the space for other colors.

Note that a point with coordinates (i, j, k), has its color information stored in the following 3-D *ArrayList* element:

space.get(i).get(j).get(k)

As we have seen in this example, the *space* variable is an *ArrayList*.** Also, each element of this ArrayList is a 2-D ArrayList** (similar to what we saw in section 2).

**Note that the index of elements in our space ArrayList represents the X coordinate, while each 2-D ArrayList, present at that index, represents the (Y, Z) coordinates.**

In this article, we discussed how to create a multidimensional *ArrayList* in Java. We saw how we can represent a graph using a 2-D *ArrayList*. Moreover, we also explored how to represent 3-D space coordinates using a 3-D *ArrayList*.

The first time, we used an *ArrayList* of *ArrayList,* while the second time, we used an *ArrayList* of 2-D *ArrayList*. Similarly, **to create an N-Dimensional ArrayList, we can extend the same concept.**

The full implementation of this tutorial can be found on GitHub.

Ok. Simple and do the basic job.

What about using a graph library like guava common.graph. Just an idea 😉

We wanted to focus on a core Java approach for this post.

Thanks for the suggestion!