Java multidimensional array concept

A two dimentional array is simply an array whose elements are arrays themselves.

If you initiaze your xyz array with int[][] xyz = new int[2][3];, you create an array of two elements and each element is an int array of 3 elements.

There's nothing stopping you from later assigning an int array of 4 elements to xyz[0], just like there's nothing stopping you from assigning a 6 element int array to y. An array variable can hold a reference to any array of the same element type.

In Java, a multi-dimensional array is an array of arrays, and an array is just a reference. So if you say

int[][] xyz = new int[2][3];

what you will get is an array with two references. Each reference will initially be a reference to an array of three integers. But those references all have type int[], meaning they're just references to arrays of integers; there's nothing in Java that says they must always have length 3. You can replace the reference with any int[], i.e. a reference to any other array of integers--or you can replace it with null.

Basically, multi-dimensional arrays in Java are "ragged arrays", and the elements can all have different lengths (or be null). Even if you initialize them all to the same length, they don't have to stay that way.

Like @Eran said, when you do int xyz[][] = new int [2][3]; you are basically creating an array that looks like this:

• xyz[0] and xyz[1] are both int[3]
• xyz[0][0], xyz[0][1] and xyz[0][2] are all 0 (default value of int)
• xyz[1][0], xyz[1][1] and xyz[1][2] are all 0 (default value of int)

So it looks like this:

xyz = {
    { 0, 0, 0 },
    { 0, 0, 0 }
};

When you are doing xyz[0] = {18,9,10,6,12,15,3}, you are assigning the xyz[0] from int[3] to a int[7], which changes the multidimensional-array to:

• xyz[0] is int[7]
• xyz[1] is still int[3]
• xyz[0][0] is 18; xyz[0][1] is 9; xyz[0][2] is 10; xyz[0][3] is 6; xyz[0][4] is 12; xyz[0][5] is 15; xyz[0][6] is 3
• xyz[1][0], xyz[1][1] and xyz[1][2] are still 0

And now it looks like this:

xyz = {
    { 18, 9, 10, 6, 12, 15, 3 },
    { 0, 0, 0 }
};

Can please somebody explain me how it is allowing to store 4 elements when the size is 3?

This is because when you declared int xyz[][]= new int [2][3];, you are merely creating an array of size 2 and each of the 2 elements holds an array of 3 elements.

Visually looks like this (of course it can also be deemed as 3 rows 2 cols too):

{0, 0, 0},
{0, 0, 0}

The key concept here is that, 2D array in Java means an array of arrays. Since it is an array of array, each "row" holds an array itself. Hence, you can assign any new array for each "row".

This causes the possible occurrence of irregular arrays in Java.

{0},
{0, 0},
{0, 0, 0}

1D array of int

{0, 0, 0}  //An array of int

2D array of int

{ {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} }  //An array of (1D array of int)

At first, an array is an object in Java. A variable name is a reference to array and you can get the elements of array using the indexes.

Multidimensional array is an array of arrays. See more.

In multidimensional array, you can declare array of arrays. In your example, it has been created int multidimensional array: int xyz[][] = new int[2][3]; 2-by-3 means you have 2 arrays and both arrays can keep 3 int numbers.

When we initialize the array, Java provides us with the default value(s) inside the array. These default values depend on the type of array. In your example, when you access the element, for example, xyz[1][1] or whatever element you want in the scope of the length of the array, you will get 0 because the type of array is int and the default value of int is zero. So, you have 2 arrays which are situated in xyz and both 2 arrays have 3 zero-valued elements before assigning values by you.

When you declare and instantiate like int xyz[][] = new int[2][3]; Java will automatically initialize xyz array with the default values like following

xyz[0] = {0,0,0}; 

xyz[1] = {0,0,0};

Then, you defined a new single dimensional array named y;

int[] y = {18,9,10,6,12,15,3};

and after creating y you assigned it to the zero-indexed (xyz[0]) array of xyz. xyz[0]=y; // xyz[0] = {18,9,10,6,12,15,3}; this means reassigning. Because, when you created xyz array, Java automatically initializes the elements of arrays, on the other words, assigns the default values for arrays inside xyz then you reassign first array of xyz with y. This looks like reassigning of variables, you can create

int a = 10;

and then you can reassign the number to a variable a like this:

a = 45;

So array assignment is the similar. First Java assigns values, then you reassign. First Java assigns default values, 0s, then you create a single dimensional array and reassign y to xyz[0]. That’s why you are allowed to define different sizes of arrays despite of fix-sized elements.

In 2d array basically assume xyz[row][col] is a matrix so in a matrix the total number of elements are equal to row*col since you have taken xyz[2][3] total number of elements are going to be 2*3=6 . you are storing four elements rest two of the elements are null . There you can store total 6 elements. Eg xyz[4][2] = total items that can be stored 4*2=8.