KotlinJava

# Multidimensional Arrays

int[][] pixels = new int[32][32];
for (int i = 0; i < pixels.length; i++) {
for (int j = 0; j < pixels[i].length; j++) {
pixels[i][j] = i + j;
}
}
System.out.println(pixels[8][18]);

This is another extremely exciting lesson. Because now, we’ll learn how to work with even more data. We’ll break free from our linear shackles into full multi-dimensional splendor. Let’s get started!

## Debugging PracticeDebugging Practice

But first, let’s get a bit more debugging practice!

## Multidimensional DataMultidimensional Data

So far we’ve worked with single data values, arrays of values, and `String`s—which on some level or just character arrays with features. But all of the plural data that we’ve worked with so far has been linear. We’ve learned how to put things in order. But just try linearizing this guy:

It turns out that a lot of the data around us is multidimensional. Photos are just one example.

## Multidimensional ArraysMultidimensional Arrays

Of course Java has a way to work with multidimensional data. And, in many ways, it’s a straightforward extension of what we’ve already seen.

Here’s our first multidimensional array:

int[][] values = new int[8][8];

The syntax is similar to what we saw with single-dimensional arrays. But instead of a single `[]` in the variable declaration, we have two, indicating a two-dimensional array. How would we do three?

int[][][] values = new int[8][88][8];

Same idea. Also note that on the right side of the initial assignment we can specify sizes for each of the dimensions. The 3-d array shown above has size 8 in the first dimension, 88 in the second dimension, and 8 in the third dimension.

Array indexing in multidimensional arrays works just the same as we’ve seen in the past:

int[][][] values = new int[8][4][2];
System.out.println(values[4][2][1]);
values[2][2][1] = 10;
System.out.println(values[2][2][1]);

And we can still have problems with our bounds if we’re not careful:

int[][][] values = new int[8][4][2];
System.out.println(values[4][2][2]);

### Forget Rows and ColumnsForget Rows and Columns

A bi-yearly rant. Forget about rows and columns. Do you want to work with spreadsheets your entire life? This limited mental model will utterly fail you when you need it most!

int[][] samples = new int[2][64];

### Arrays of Arrays of ArraysArrays of Arrays of Arrays

Let’s explore how multidimensional arrays in Java actually work. Specifically, we’ll talk about why something like this works:

int[][] twod = new int[2][];
int[] oned = new int[8];
twod[1] = oned;
twod[0] = new int[4];
System.out.println(twod.length);
System.out.println(twod[0].length);
System.out.println(twod[1].length);
int[][] twod = new int[4][];

### Non-Rectangular ArraysNon-Rectangular Arrays

Note one important consequence of the fact that Java arrays are arrays of arrays. They do not need to be rectangular! Specifically, an innermost array can have a different size at each index. Some may even be `null`! Let’s look at how.

int[][] nonrectangular = new int[8][];

If this doesn’t make perfect sense to you, don’t worry. Next we’ll show you patterns that you can use below to work with any array, rectangular or non.

### Multidimensional Array LiteralsMultidimensional Array Literals

These exist, but they are awful. We’ll never do this to you:

// Holy terrible syntax, Batman!
int[][][] values = new int[][][] {new int[][] {new int[] {1, 2}, new int[] {3}}};
System.out.println(values[0][1][0]);

## Multidimensional Array Programming PatternsMultidimensional Array Programming Patterns

Just like single-dimensional arrays, we can develop similar programming patterns for working with multidimensional arrays. Let’s look at an example together.

int[] values = {1, 2, 4};

## More Practice

Need more practice? Head over to the practice page.