Multi Dimensional ArrayList in Java

Last updated: January 8, 2026

Written by: baeldung

Reviewed by: Kevin Gilmore

Java List

Java List Basics

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

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.

2. Two-Dimensional ArrayList

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

3. Three-Dimensional ArrayList

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.

4. Conclusion

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 code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.