Why it's wrong when the variable of Object[] as elements of Object[] transfrom to Object[][]

I want to use object[] as the element of object[] to transform it to Object[][], but it can't run. So I want to know why it is wrong. And how can I achieve that giving a number k, and create a array that is k dimensional.

Here is the wrong code:

public static void main(String[] args) {
         Object[] s = new Object[3];
         s[0] = new Integer[1];
         s[1] = new Integer[1];
         s[2] = new Integer[1];
         Object m = s;
         Integer[][] t = (Integer[][])m;
        
        System.out.println(Arrays.toString(t));
    }

The type Object[][] is saying that the array can only contain other Object[] instances.

But an Object[] can also contain things that are not arrays of Object.

Note that when you cast from one reference type to another, no value conversion occurs, and the actual type of the object doesn't change. All that happens is that the runtime system checks that the object's actual runtime type is assignment compatible with the type you are casting to.

To illustrate why it has to be like this, consider the following:

     Object[] s = new Object[2];
     s[0] = new Integer[1];
     Integer[][] t = (Integer[][]) s;   // ONE
     s[1] = "Hello";
     Integer[] u = t[1];                // TWO

If (hypothetically!) the cast at "ONE" is allowed to succeed, then at "TWO" we would assign a String to a variable of type Integer[].

That cannot be allowed to happen. The cast must fail.

The second part of your question is this:

> And how can I achieve that giving a number k, and create a array that is k dimensional.

It depends on what you mean:

• You can create a custom class that behaves like a K-dimensional array, though you won't be able use Java array syntax to access and update cells.

• You can construct a K-dimensional array out of Object[] objects, though you will need to do a lot of type-casting to use it. And under no circumstances will you be able to cast it to an array with a higher number of dimensions.

• You can use java.lang.reflect.Array.newInstance(Class, int...) to create an array with K dimensions. The only problem that the declared type is Object so you still need a type cast:

   Integer[][][] array = Array.newInstance(Integer.class, 3, 3, 3);
  

  However, if you want K to be a parameter, then

   int[] dimensions = new int[K];
   for (int i = 0; i < K; i++) {
       dimensions[i] = 2;
   }
   Object array = Array.newInstance(Integer.class, dimensions);
  

  The problem is that when K is a parameter, you cannot declare a variable whose Java type is a K-dimensional array of Integer. If you want to subscript the array using [], you will need to resort to something like this:

   switch (K) {
   case 1:
      Integer[] oneD = (Integer[]) array;
      oneD[1] = 42;
      break;
   case 2:
      Integer[][] twoD = (Integer[][]) array;
      twoD[1][1] = 42;
      break;
   // etcetera
   }
  

To answer the part

> And how can I achieve that

You can do the below transform

Integer[][] t = Arrays.stream((Object[])m).map(Integer[].class::cast).toArray(Integer[][]::new);