array : Java Glossary

Allocating an Array of Primitives

Here is how you would allocate an array of primitives:

ArrayIndexOutOfBoundsException is the exception that will be thrown if you use an index outside the range 0..N-1 where N is the allocated size of the array.

Allocating an Array of Objects

The key thing to understand is initialising is a two step process:

1. Allocate some RAM (Random Access Memory) 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.

Newbies tend to ignore one of those two steps, both of which you must do explicitly.

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

You can initialise an array to a list of values this way:

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

You can also do it with Arrays.fill

import java.util.Arrays;
...
int[] numbers = new int[ 50 ];
Arrays.fill( numbers, 149 );

Passing Arrays

Methods can return arrays. Usually the callee allocates them. However, the caller could allocate them and pass them as parameters.

Returning Arrays

Here are some ways from simple to complex that you can return an array of Strings from a method.

Copying and Cloning Arrays

Array to List to Collection and Back

Array Initialisation Gotchas

An array is a fixed length block of primitives or references. If you need something that will grow automatically, see ArrayList or Vector or some other Collection. Java never stores blocks of repeating structures or objects. It always creates contiguous blocks of references to separately stored objects. Novices make two common errors: failing to allocate space for the array and failing to allocate objects for each cell. Java automatically initialises arrays of primitives to 0 and arrays of references to null. However, it won’t create any objects for you automatically. Here is how you would allocate an array of primitives:

// 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 Comparison

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 3 × 5 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 3 × 4 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;
      }
   }

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}};

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 (Java Virtual Machine) 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()] );

System.arraycopy will copy element by element casting each as necessary. That allows you to convert an Object[] to a String[]. You can do the same yourself in a for loop. Surprisingly, the for loop technique often generates faster code than arraycopy. In the latest Java, arraycopy is faster except for moves of only one or two characters. arraycopy will not grow an array to hold the new elements.

You might imagine a cast from Dog[] to Dalmatian[] should be allowed if the array currently contains only Dalmatian 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

Array methods you might find useful include:

• 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.deepEquals: compare arrays element by element.
• Arrays.fill: fill all or part of an array with some value.
• Arrays.sort: sort

Gotchas

• An array of n elements is indexed 0..n-1. Why? In a simple CPU (Central Processing Unit), an array of bytes is indexed by adding the index to the base address. It then more convenient to use 0 for the first slot since it is at offset 0 from the base. When C was designed as a sort of portable assembler, this mode of thinking was built-in. Java copied C. FØRTRAN indexes arrays 1..n. In such languages, most of the time the compiler can make the necessary adjustment to the base address at compile time, giving no extra run time overhead. Starting indexing with 0 sometimes allows indexes to be stored in one fewer bit. Indexing with 0 is more friendly when you do any sort of modulus work. After years of working with both, I have come to prefer the 0 method. It may help to realise that, in France, the floor above the ground floor is called la premiere étage — the first floor. They count Java style.
• 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 with a parameter of type int[]. You won’t get an error message, just a nonsensical result.

Array Of Pairs

Often you want to pass an array of pairs to a constructor. Here is a trick to do that easily.

Learning More