# Java 2D Array Examples, Jagged Arrays

These Java examples use 2D arrays and jagged arrays. They initialize arrays, assign elements and display the arrays.

## 2D arrays. Not all elements come in linear order, one after another.

Some have spatial relationships on a two-dimensional plane, a grid. We use 2D arrays to represent this.

Initializers. The syntax of 2D arrays is often complex. Two integer indexes locate a point in a 2D array. And with initializers, we quickly create these arrays.

Array example. We introduce a two-dimensional array of width 4 and height 4—a little square. I assign some elements with the array at indexes (two are required, an X and a Y).

Loop: In the nested for-loops we iterate over each element. Each row contains a subarray.

And: We use the subarrays like a one-dimensional array containing int values. We have an array of equal-length arrays.

Int

```Based on:

Java 7

Java program that uses 2D array

public class Program {
public static void main(String[] args) {

// Create new 2-dimensional array.
int[][] values = new int[4][4];

// Assign three elements within it.
values[0][0] = 1;
values[1][1] = 2;
values[3][2] = 3;

// Loop over top-level arrays.
for (int i = 0; i < values.length; i++) {

// Loop and display sub-arrays.
int[] sub = values[i];
for (int x = 0; x < sub.length; x++) {
System.out.print(sub[x] + " ");
}
System.out.println();
}
}
}

Output

1 0 0 0
0 2 0 0
0 0 0 0
0 0 3 0```

Array initializers. With these, we fill a newly-declared array with constant values. Here I create another little square, this time 2 by 2, with the values one through 4 in it.

Note: This syntax requires just one line. It is easier to type and review for humans.

```Java program that uses 2D array initializer

public class Program {
public static void main(String[] args) {

// Use initialize syntax.
int[][] values = { { 1, 2 }, { 3, 4 } };
System.out.println(values[0][0]);
System.out.println(values[1][0]);
System.out.println(values[0][1]);
System.out.println(values[1][1]);
}
}

Output

1
3
2
4```

Jagged array. This is like a 2D array but with irregular subarray lengths. Its lengths are not even—they are jagged. Here we create a jagged array of two String arrays.

And: The first subarray has two elements. The second one has three String elements. We loop over all these values.

Strings

```Java program that uses jagged array

public class Program {
public static void main(String[] args) {

// Create an array of String arrays: a jagged array.
String[][] values = new String[2][];

// Fill first row with 2-element array.
values[0] = new String[2];
values[0][0] = "cat";
values[0][1] = "dog";

// Use 3-element array for second row.
values[1] = new String[3];
values[1][0] = "fish";
values[1][1] = "bird";
values[1][2] = "lizard";

// Display rows and elements.
for (String[] array : values) {
for (String element : array) {
System.out.print(element);
System.out.print(" ");
}
System.out.println();
}
}
}

Output

cat dog
fish bird lizard```

3D array. Usually two dimensions is enough, but we can use three dimensions in an array. And even more are supported. It is rare to need a 3D array.

Tip: Three-dimensional arrays can often be replaced with lesser-dimensioned arrays. This would likely be faster.

```Java program that creates 3D array

public class Program {
public static void main(String[] args) {

// Create space cube with 9 points.
byte[][][] space = new byte[3][3][3];
space[0][0][0] = 10;
space[1][1][1] = 20; // Middle of the cube.
space[2][2][2] = 30;

// Display points in our space-cube.
System.out.println(space[0][0][0]);
System.out.println(space[1][1][1]);
System.out.println(space[2][2][2]);
}
}

Output

10
20
30```

Flattened 2D arrays. A compiler transforms a 2D array indexing operation into multiplication and addition. So to a compiler, a 2D array is similar to a 1D array with an indexing function.

Here: I develop a flattened 2D array, which uses a multiply and add to locate elements in a 1D array.

Indexes: We add the X coordinate to the Y coordinate multiplied by the number of rows. Two indexes are combined into one.

```Java program that uses flattened 2D array

public class Program {
public static void main(String[] args) {

// Create 4 by 4 one-dimension array.
// Can access 0, 0 through 3, 3 with multiplication.
int[] array = new int[4 * 4];

// Assign locations in the flattened array.
array[0 + (1 * 4)] = 10; // 0, 1
array[3 + (3 * 4)] = 100; // 3, 3
array[2 + (2 * 4)] = 1000; // 2, 2

System.out.println(array[0 + (1 * 4)]);
System.out.println(array[3 + (3 * 4)]);
System.out.println(array[2 + (2 * 4)]);

System.out.println(array[3 + (2 * 4)]); // 3, 2
}
}

Output

10
100
1000
0```

Flat array benchmark. Two-dimensional arrays often come with performance losses. Here I benchmark a flattened array (a 2D array stored as a 1D array) against a real 2D array.

Description: The benchmark sets up two 10 by 10 arrays. It then does a load and a store in the two arrays at two positions.

Result: The program shows the performance advantage of 1D arrays over 2D arrays. A flat array is nearly twice as fast.

```Java program that benchmarks flat, 2D arrays

public class Program {
public static void main(String[] args) {

int[] flat = new int[10 * 10]; // Flattened 10 x 10 array.
flat[0 + (4 * 10)] = 1;

int[][] two = new int[10][10]; // 10 x 10 two-dimensional array.
two[0][4] = 1;

long t1 = System.currentTimeMillis();

// ... Read, assign flattened array.
for (int i = 0; i < 100000000; i++) {
int value = flat[0 + (4 * 10)];
flat[9 + (9 * 10)] = value;
}

long t2 = System.currentTimeMillis();

// ... Read, assign 2D array.
for (int i = 0; i < 100000000; i++) {
int value = two[0][4];
two[9][9] = value;
}

long t3 = System.currentTimeMillis();

// ... Times.
System.out.println(t2 - t1);
System.out.println(t3 - t2);
}
}

Output

131 ms,  Flattened 1D array, load and store
256 ms,  2D array, load and store```

Alternatives. We can use alternative data structures to replace a 2D array. A HashMap can store ArrayLists in its keys: we can look up collections by any index value.

A syntax form. 2D arrays use a convenient syntax form for storing data with 2D spatial relationships. We index a 2D array with a pair of coordinates.

Drawbacks. Performance suffers with 2D arrays—using 1D arrays may prove worthwhile. And often programs can be written in a clearer way with simpler collections.