Trouble with primitive arrays and casting, lesson 521

Question

hi everyone!
there is a problem i discovered right now - after years with java where was no necessity to do this.....
and i'm shure this must have been the topic already, but i couldn't find any helpful resource :-/
right here we go:
1. an array is a (special) kind of object.
2. there are "primitive" arrays and such containing references to objects. of course - and i imagine why - they are treated differently by the VM.
3. then both are - somehow - subclasses of Object. whereas primitive types are not really, primitive-arrays are. this is hidden to the programmer....
4. any array can be "pointed" at via local Object variable, like this:
Object xyz = new int[6];
5. arrays of Objects (with different dimensions) can be casted, like this:
  Object pointer = null;
  Object[]   o  = new SomeClass[42] ;
  Object[][] oo = new OtherClass[23] [2] ;
  Object[][][] ooo = new OtherClass[23] [2] [9] ;
  o = oo = ooo;     // this is save to do,
                               //because "n-dimensional" object-arrays
                              // are just arrays of  other arrays, down to simple array
pointer = o;         // ok, we are referencing o via Object "pointer"6. but, you cannot do this with primitive types:
  int[]  i1 = new int [99] ;
  int[][] i2 = new int [1] [3] ;
  i1 = i2                  // terror: impossible. this is awful, if you ask me.
                               // ok, one could talk about "special cases" and
                               // "the way the VM works", but this is not of interest to me as
                               // a programmer. i'm not happy with that array-mess!
  pointer = i2;       // now this is completely legal. i2, i1 etc is an object!7. after the preparation, let's get into my main trouble (you have the answer, i know!) :
suppose i have a class, with methods that should process ANY kind of object given. and - i don't know which. i only get it at runtime from an unknown source.
let's say: public void BlackBox( Object x );
inside, i know that there might be regular objects or arrays, and for this case i have some special hidden method, just for arrays... now try to find it out:
public void BlackBox( Object x )
  if ( x == null)
       return;
   Class c = x.getClass();
   if ( c.isArray() )
          // call the array method if it's an array.........
          BlackBoxes(     (Object [] )  x );         // wait: this is a cast! and it WILL throw an exception, eventually!
          return;
   else
           DoSpecialStuffWith( x );
}ok ? now, to process any kind of array, the special method you cannot reach from outside:
private void BlackBoxes( Object[] xs )
   if ( xs != null )
        for ( Object x : xs )
             BlackBox( x );
// this will end up in some kind of recursion with more than one array-dimension, or when an Object[] has any other array as element!this approach is perfectly save when processing any (real) Object, array or "multi-dimensional" arrays of Objects.
but, you cannot use this with primitive type arrays.
using generics wouldn't help, because internally it is all downcasted to Object.
BlackBox( new Integer(3) ) ---- does work, using a wrapper class
BlackBox( new Integer[3] ) ----- yep!
BlackBox( 3 ) ---- even this!
BlackBox( new int[42] ) ---- bang! ClassCastException, Object[] != int[]
i'm stuck. i see no way to do this smoothly. i could write thousands of methods for each primitive array - BlackBox( int[] is ) etc. - but this wouldn't help. because i can't cast an int[][] to int[], i would also have to write countless methods for each dimension. and guess, how much there are?
suppose, i ultimately wrote thousands of possible primitive-type methods. it would be easy to undergo any of it, writing this:
BlackBox( (Object) new int[9] [9] );
the method-signature would again only fit to my first method, so the whole work is useless. i CAN cast an int[] to Object, but there seems no convenient way to get the real array out of Object - in a generic way.
i wonder, how do you write a serialisation-engine? and NO, i can't rely on "right usage" of my classes, i must assume the worst case...
any help appreciated!

Answer 1

thanks, brigand!
your code looks weird to me g and i think there's at least one false assumption: .length of a multidimensional array returns only the number of "top-level" subarrays. that means, every length of every subarray may vary. ;)
well i guess i figured it out, in some way:
an int is no Object;
int[ ] is an Object
the ComponentType of int [ ] is int
so, the ComponentType of an Object int[ ] is no Object, thus it cannot be casted to Object.
but the ComponentType of int [ ] [ ] IS Object, because it is int [ ] !
so every method which expects Object[], will work fine with int[ ] [ ] !!
now, you only need special treatment for 1-dimensional primitive arrays:
i wrote some code, which prints me everything of everything:
    //this method generates tabs for indentation
    static String Pre( int depth)
         StringBuilder pre = new StringBuilder();
         for ( int i = 0; i < depth; i++)
              pre.append( "\t" );
         return pre.toString();
    //top-level acces for any Object
    static void Print( Object t)
         Print ( t, 0);
    //the same, but with indentation depth
    static void Print( Object t, int depth)
        if ( t != null )
             //be shure it is treated exactly as the class it represents, not any downcast
             t = t.getClass().cast( t );
            if ( t.getClass().isArray() )
                 //special treatment for int[]
                 if ( t instanceof int[])
                      Print( (int[]) t, depth);
                 // everything else can be Object[] !
                 else
                      Print( (Object[]) t, depth );
                 return;
            else
                System.out.println( Pre(depth) + " [ single object:] " + t.toString() );
        else
            System.out.println( Pre(depth) + "[null!]");
    // now top-level print for any array of Objects
    static void Print( Object [] o)
         Print( o, 0 );
    // the same with indentation
    static void Print( Object [] o, int depth)
        System.out.println( Pre(depth) + "array object " + o.toString() );
        for ( Object so : o )
                Print( so, depth + 1 );
    //the last 2 methods are only for int[] !
    static void Print( int[] is)
         Print( is, 0 );
    static void Print( int[] is, int depth)
        System.out.println( Pre(depth) + "primitive array object " + is.toString() );
        // use the same one-Object method as every other Object!
        for ( int i : is)
             Print ( i, depth + 1 );
        System.out.println( "-----------------------------" );
    }now, calling it with
Print ( (int) 4 );
Print ( new int[] {1,2,3} );
Print( new int[][] {{1,2,3}, {4,5,6}} );
Print( new int[][][] {{{1,2,3}, {4,5,6}} , {{7,8,9}, {10,11,12}}, {{13,14,15}, {16,17,18}} } );
Print( (Object) (new int[][][][] {{{{99}}}} ) );
produces this fine array-tree:
[ single object:] 4
primitive array object [I@9cab16
      [ single object:] 1
      [ single object:] 2
      [ single object:] 3
array object [[I@1a46e30
     primitive array object [I@3e25a5
           [ single object:] 1
           [ single object:] 2
           [ single object:] 3
     primitive array object [I@19821f
           [ single object:] 4
           [ single object:] 5
           [ single object:] 6
array object [[[I@addbf1
     array object [[I@42e816
          primitive array object [I@9304b1
                [ single object:] 1
                [ single object:] 2
                [ single object:] 3
          primitive array object [I@190d11
                [ single object:] 4
                [ single object:] 5
                [ single object:] 6
     array object [[I@a90653
          primitive array object [I@de6ced
                [ single object:] 7
                [ single object:] 8
                [ single object:] 9
          primitive array object [I@c17164
                [ single object:] 10
                [ single object:] 11
                [ single object:] 12
     array object [[I@1fb8ee3
          primitive array object [I@61de33
                [ single object:] 13
                [ single object:] 14
                [ single object:] 15
          primitive array object [I@14318bb
                [ single object:] 16
                [ single object:] 17
                [ single object:] 18
array object [[[[I@ca0b6
     array object [[[I@10b30a7
          array object [[I@1a758cb
               primitive array object [I@1b67f74
                     [ single object:] 99
-----------------------------and i'll have to write 8 methods or so for every primitive[ ] type !
sounds like a manageable effort... ;-)