2D array

In Java 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.

We can access an element from a 2D array using 2 indexes. And looping over a 2D can be done with nested for-loops.

Array example

To understand 2D arrays, we need to review several steps. The syntax for 2D arrays uses 2 values to address an element.

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

        // Step 1: create 2-dimensional array.
        int[][] values = new int[4][4];

        // Step 2: assign three elements in it.
        values[0][0] = 1;
        values[1][1] = 2;
        values[3][2] = 3;

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

            // Step 4: 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();
        }
    }
}
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.

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

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

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

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

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

        // Read an empty location.
        System.out.println(array[3 + (2 * 4)]); // 3, 2
    }
}
10
100
1000
0

Benchmark, flat array

Two-dimensional arrays often come with performance losses. The benchmark sets up two 10 by 10 arrays. It then does a load and a store in the 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();

        // Version 1: 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();

        // Version 2: 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);
    }
}
131 ms,  Flattened 1D array, load and store
256 ms,  2D array, load and store

We index a 2D array with a pair of coordinates. Performance suffers with 2D arrays. Often programs can be written in a clearer way with simpler collections.