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).

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.

static String[][][] School= new String[1000][20][5]; 

Consider figure which has 3 Dimension.

So when you insert School[0][0][0]="A1" it means you have entered element at 0,0,0 position.

From 0,0,0 this will move upto the position 1000,20,5.

You can insert like this But you have so many elements.

School[0][0][0]="A1"
School[0][0][1]="A2"
School[0][0][2]="A3"
.....
School[0][1][0]="B1"
School[0][1][1]="B2"
School[0][1][2]="B3"
......

In 3D array elements look like

int[3][4][2] array3D
// means Three (4x2) 2 Dimensional Arrays 

 int[4][2]
 //means Four 1 dimensional arrays.

Now how to add elements in 3D array?

At Start you can directly use

int[][][] threeDArray = 
    {  { {1,   2,  3}, { 4,  5,  6}, { 7,  8,  9} },
       { {10, 11, 12}, {13, 14, 15}, {16, 17, 18} },
       { {19, 20, 21}, {22, 23, 24}, {25, 26, 27} } };

This is very tedious task in your case as you want to insert details at every position. As you have 1000 records.

Your array will have elements like this

NOTE:It's not recommended to use 3D array for this purpose.

Suggestion:Declare a class with three Strings create constructor with this three parameters and put getter and setters to get and set values via Objects