Allocating an Array Of Primitives

Allocating an Array of Objects

1. Allocate some RAM to hold N indexable pointers, and initialise that RAM with null pointers.
2. Fill those slots with references to some real Objects, perhaps newly allocated Objects, perhaps pre-existing ones. The slots may all point to different Objects, or some slots may point to the same Object. Java does not automatically allocate a new Object for each slot.

Here is how you would allocate an array of objects using Java’s short hand syntax:

String[] fruits =
{
   "banana" , "pear" , "orange" , null, favouriteFruit()
};

If your array type is declared abstract, you can still do stage 1. However, for stage 2, you need to populate with actual Objects derived from that abstract type.

Initialising

fruits = new String []
{
   "banana" , "pear" , "orange" , null, favouriteFruit()
};

Passing Arrays

Returning Arrays

Copying and Cloning Arrays Arrays

Array to List to Collection and Back

Array Initialisation Gotchas

// note how you never specify the array's size in its type declaration.
int[]v;
// allocate space for the array
v =new int [100];
for ( int i=0;i<v.length;i++ )
   {
   v[i] = i*2 + 999;
   }

Cell[] v = new Cell [100];
for ( int i=0; i<v.length; i++ )
   {
   v[i] = new Cell( i, 999 );
   }

long[] a;

long[] a = new long[100];

long[] a;
// then later initialise it with:
a = new long [100];

int[] array = {
   11, 12 , 13, 21, 22, 21, 31, 32, 33
};

BigDate[] dates = {
   new BigDate( 1999, 1,   1 ),
   new BigDate( 1999, 12, 31 )
};

array = {
   11, 12, 13, 21, 22, 21, 31, 32, 33
};

array = new int[] {
   11, 12 , 13, 21, 22 , 21, 31, 32 , 33
};

array = new int[] {
   11,
   12,
   13,
   21,
};

Array Comparision

Matrix Initialisation

Under the hood, to find an element, you first index by row into a contiguous block of pointers. That points you to the start of one of another contiguous block of pointers. You index into that block by column, which points you to associated object. If you had a 3x5 matrix of objects you would have 1+3+(3*5)=19 separate allocation regions for the matrix and its objects.

Here is the generalized way you would use declare and initialize a 3x5 rectangular matrix.

// This is the usual shorthand way to initialise a matrix.
int[][] mat = new int[3][5];
for ( int i=0; i<3; i++ )
   {
   for ( int j=0; j<5; j++ )
      {
      mat[i][j] = i*j+100;
      }
   }

// Using length instead of hard-coded constants
static final int NUM_ROWS = 3;
static final int NUM_COLS = 5;
int[][] mat = new int [NUM_ROWS][NUM_COLS];
for ( int i=0; i<mat.length; i++ )
   {
   for ( int j=0; j<mat[i].length; j++ )
      {
      mat[i][j] = i*j+100;
      }
   }

Cell[][] mat = new Cell[3][5];
for ( int i=0; i<3; i++ )
   {
   for ( int j=0; j<5; j++ )
      {
      mat[i][j] = new Cell( i, j, 100 );
      }
   }

int[][] mat = { { 11 , 12, 13} , { 21, 22 , 21} , { 31 , 32, 33}};

mat = { { 11, 12, 13} , { 21, 22, 21} , { 31, 32, 33}};

mat = new int [][] { { 11 , 12, 13} , { 21, 22 , 21} , { 31 , 32, 33}};

For serious matrix work you need a matrix package such as MTJ.

ArrayStoreException

1. The declared type of the array variable. e.g. Dog[] dogs;
2. The type of the array object, e.g. Dog[] dogs = new Dalmatian[ 10 ];
3. The type of the array element, e.g. dogs[ 0 ] = new DarkDalmatian();

Arrays are like virgins. They are very careful about what they allow in themselves. When you construct an array you declare what sorts of Object you are going to allow into the array. You cannot violate that sacred trust:

For example:

Dog[] mutts = new Dalmatian[20];
mutts[2] = new PitBull(); /* Prang!! */

This will get you an ArrayStoreException since the array, as constructed, only allows Dalmatians (or their subclasses) in it, even though the declaration says it will allow any Dog in.

however this:

Dog[] mutts = new Dog [20];
mutts[2] = new PitBull(); /* is perfectly ok */

Whenever you store an Object into an array, at run time, the JVM checks to make sure the object is of a compatible type. There are a few cases where this check is not necessary, e.g. if Dog had no subclasses.

A common error is to have an Object[] returned from Vector in which all the elements actually are Strings. You can cast the elements individually from Object to String, but you can’t cast the entire array object, Object[] to String[], even if all the individual elements currently happen to be Strings. You could only cast Object[] to String[] if the array Object actually were created as a String[]. To get around this problem, to ensure Vector gives you an array of Strings instead of an array of Objects, use code like this to extract arrays from Vectors:

String[] strArray = ( String[])v.toArray( new String [v.size()] );

You might imagine a cast from Dog[] to Dalmatian[] should be allowed if the array currently contains only Dalamatian elements. It would be an expensive check. Further, you would then have two references to the array. There would be nothing to stop you from later adding some PitBull elements via the Dog[] reference, violating the consistency requirement of the Dalmatian[] reference. That’s why the ArrayStore gotcha has to be there.

Array Methods

• System.arraycopy: copy elements from one array to another. Note it is spelled arraycopy not arrayCopy as you might expect.
• Arrays.binarySearch: search for an element in a sorted array.
• Arrays.copyOf: copy an array with changed length.
• Arrays.copyRangeOf: copy part of an array to a new array.
• Arrays.fill: fill all or part of an array with some value.
• Arrays.sort: sort

Gotchas

• Arrays.asList produces a fixed-sized List, however if you change the values of the elements of the list, they write-through to change the backing array values as well.
• Beware of using Arrays.asList( int[] )! You won’t get an error message, just utterly useless and silly results.

Learning More