Here is one way to do it. It is a "3D" array. For an array of [R][C][Other]

• the first level R is the number of rows.
• the second is C the number of columns.
• the third is the size of the array in each [r][c] cell.

int ASize = 20;
int[][][] loc = new int[5][5][2];
for (int size = 0, xy = ASize / 2; size < 5;
        size++, xy += ASize) {
    for (int size2 = 0, xy2 = ASize / 2; size2 < 5;
            size2++, xy2 += ASize) {
        loc[size][size2][0] = xy2;
        loc[size][size2][1] = xy;
    }
    
}
for (int[][] arr : loc) {
    System.out.println(Arrays.deepToString(arr));
}

Prints

[[10, 10], [30, 10], [50, 10], [70, 10], [90, 10]]
[[10, 30], [30, 30], [50, 30], [70, 30], [90, 30]]
[[10, 50], [30, 50], [50, 50], [70, 50], [90, 50]]
[[10, 70], [30, 70], [50, 70], [70, 70], [90, 70]]
[[10, 90], [30, 90], [50, 90], [70, 90], [90, 90]]

This prints as follows.

• Multiple dimensions in Java are really arrays of arrays.
• so the loop iterates over each row (which is a [5][2] array) and prints each row using Arrays.deepToString()
• Arrays.toString() is normally used to print arrays but only the first level.

Order doesn't matter, and in fact the former form is more readable:

final const int RED = 0;
final const int GREEN = 1;
final const int BLUE = 2;

int[][][] colorImage = new int[numRows][numColumns][3];
//...

int x = getSomeX();
int y = getSomeY();

int redComponent = colorImage[x][y][RED];
int greenComponent = colorImage[x][y][GREEN];
int blueComponent = colorImage[x][y][BLUE];

There are no multidimensional arrays in java - just a syntax that looks and functions similarly; in reality they are arrays of arrays, resembling a tree structure more than a multidimensional array.

When you declare a three-dimensional array e.g. int[][][] myArray, you get actually just a reference variable myArray whos type is int[][][] (thats a type, just like String or Object). The only type assignment compatible with the first dimension is then int[][] and the only type assignment compatible with the second dimension is int[] and the last dimension is int (you see the pattern that just one set of [] is remove from left to right).

In practice:

int[] array1d = { 1, 2, 3 };
int[][] array2d = { array1d, { 4, 5, 6} };
int[][][] array3d = { array2d, { { 7, 8 }, { 9, 10, 11, 12 } } };

Both references as well as compatible declarations go happily into their appropiate slots. The third line also shows that dimensions need not be of equal size (contrary to classical multidimensional arrays). They don't even need to exist:

int[][] array2d_part = { { 1, 2, 3}, null };

Thats an array containing an array { 1, 2, 3 } at index 0 and a null at index 1. Since all except the rightmost dimension are reference types, null fits (null is compatible with any reference type).