Published on: September 19, 2000
Last Updated: September 19, 2000


Published on: September 19, 2000
Last Updated: September 19, 2000

Most of the necessary introduction to arrays is in the last section of Chapter 4, which shows how you define and initialize an array.

Holding objects is the focus of this chapter, and an array is just one way to hold objects. But there are a number of other ways to hold objects, so what makes an array special?

There are two issues that distinguish arrays from other types of collections: efficiency and type.

The array is the most efficient way that Java provides to store and access a sequence of objects (actually, object handles).

The array is a simple linear sequence, which makes element access fast, but you pay for this speed: when you create an array object, its size is fixed and cannot be changed for the lifetime of that array object.

You might suggest creating an array of a particular size and then, if you run out of space, creating a new one and moving all the handles from the old one to the new one.

This is the behavior of the Vector class, which will be studied later in the chapter. However, because of the overhead of this size flexibility, a Vector is measurably less efficient than an array.

The vector class in C++ does know the type of objects it holds, but it has a different drawback when compared with arrays in Java: the C++ vector’s operator[] doesn’t do bounds checking, so you can run past the end.

(It’s possible, however, to ask how big the vector is, and the at( ) method does perform bounds checking.) In Java, you get bounds checking regardless of whether you’re using an array or a collection – you’ll get a Runtime Exception if you exceed the bounds.

As you’ll learn in Chapter 9, this type of exception indicates a programmer error and thus you don’t need to check for it in your code.

As an aside, the reason the C++ vector doesn’t check bounds with every access is speed – in Java you have the constant performance overhead of bounds checking all the time for both arrays and collections.

The other generic collection classes that will be studied in this chapter, Vector, Stack, and Hashtable, all deal with objects as if they had no specific type.

That is, they treat them as type Object, the root class of all classes in Java. This works fine from one standpoint: you need to build only one collection, and any Java object will go into that collection.

(Except for primitives – these can be placed in collections as constants using the Java primitive wrapper classes, or as changeable values by wrapping in your own class.)

This is the second place where an array is superior to the generic collections: when you create an array, you create it to hold a specific type.

This means that you get compile-time type checking to prevent you from putting the wrong type in, or mistaking the type that you’re extracting.

Of course, Java will prevent you from sending an inappropriate message to an object, either at compile-time or at run-time.

So it’s not as if it’s riskier one way or the other, it’s just nicer if the compiler points it out to you, faster at run-time, and there’s less likelihood that the end user will get surprised by an exception.

For efficiency and type checking it’s always worth trying to use an array if you can. However, when you’re trying to solve a more general problem arrays can be too restrictive.

After looking at arrays, the rest of this chapter will be devoted to the collection classes provided by Java.

Arrays Are First-class Objects

Regardless of what type of array you’re working with, the array identifier is actually a handle to a true object that’s created on the heap.

The heap object can be created either implicitly, as part of the array initialization syntax, or explicitly with a new expression.

Part of the heap object (in fact, the only field or method you can access) is the read-only length member that tells you how many elements can be stored in that array object. 

The ‘ []’ syntax is the only other access that you have to the array object. The following example shows the various ways that an array can be initialized, and how the array handles can be assigned to different array objects.

It also shows that arrays of objects and arrays of primitives are almost identical in their use.

The only difference is that arrays of objects hold handles while arrays of primitives hold the primitive values directly. (See page 97 if you have trouble executing this program.)

// Initialization & re-assignment of arrays
package c08;

class Weeble {} // A small mythical creature

public class ArraySize {
  public static void main(String[] args) {
    // Arrays of objects:
    Weeble[] a; // Null handle
    Weeble[] b = new Weeble[5]; // Null handles
    Weeble[] c = new Weeble[4];
    for(int i = 0; i < c.length; i++)
      c[i] = new Weeble();
    Weeble[] d = {
      new Weeble(), new Weeble(), new Weeble()
    // Compile error: variable a not initialized:
    //!System.out.println("a.length=" + a.length);
    System.out.println("b.length = " + b.length);
    // The handles inside the array are 
    // automatically initialized to null:
    for(int i = 0; i < b.length; i++)
      System.out.println("b[" + i + "]=" + b[i]);
    System.out.println("c.length = " + c.length);
    System.out.println("d.length = " + d.length);
    a = d;
    System.out.println("a.length = " + a.length);
    // Java 1.1 initialization syntax:
    a = new Weeble[] {
      new Weeble(), new Weeble()
    System.out.println("a.length = " + a.length);

    // Arrays of primitives:
    int[] e; // Null handle
    int[] f = new int[5];
    int[] g = new int[4];
    for(int i = 0; i < g.length; i++)
      g[i] = i*i;
    int[] h = { 11, 47, 93 };
    // Compile error: variable e not initialized:
    //!System.out.println("e.length=" + e.length);
    System.out.println("f.length = " + f.length);
    // The primitives inside the array are
    // automatically initialized to zero:
    for(int i = 0; i < f.length; i++)
      System.out.println("f[" + i + "]=" + f[i]);
    System.out.println("g.length = " + g.length);
    System.out.println("h.length = " + h.length);
    e = h;
    System.out.println("e.length = " + e.length);
    // Java 1.1 initialization syntax:
    e = new int[] { 1, 2 };
    System.out.println("e.length = " + e.length);
} ///:~ 

Here’s the output from the program:

b.length = 5
c.length = 4
d.length = 3
a.length = 3
a.length = 2
f.length = 5
g.length = 4
h.length = 3
e.length = 3
e.length = 2 

The array a is initially just a null handle, and the compiler prevents you from doing anything with this handle until you’ve properly initialized it.

The array b is initialized to point to an array of Weeble handles, but no actual Weeble objects are ever placed in that array.

However, you can still ask what the size of the array is, since b is pointing to a legitimate object.

This brings up a slight drawback: you can’t find out how many elements are actually in the array, since length tells you only how many elements can be placed in the array; that is, the size of the array object, not the number of elements it actually holds.

However, when an array object is created its handles are automatically initialized to null so you can see whether a particular array slot has an object in it by checking to see whether it’s null.

Similarly, an array of primitives is automatically initialized to zero for numeric types, null for char, and false for boolean.

Array c shows the creation of the array object followed by the assignment of Weeble objects to all the slots in the array.

Array d shows the “aggregate initialization” syntax that causes the array object to be created (implicitly with new on the heap, just like for array c) and initialized with Weeble objects, all in one statement.

The expressiona = d;shows how you can take a handle that’s attached to one array object and assign it to another array object, just as you can do with any other type of object handle.

Now both a and d are pointing to the same array object on the heap.Java 1.1 adds a new array initialization syntax, which could be thought of as a “dynamic aggregate initialization.”

The Java 1.0 aggregate initialization used by d must be used at the point of d’s definition, but with the Java 1.1 syntax you can create and initialize an array object anywhere. For example, suppose hide( ) is a method that takes an array of Weeble objects.

You could call it by saying:hide(d);but in Java 1.1 you can also dynamically create the array you want to pass as the argument:hide(new Weeble[] { new Weeble(), new Weeble() });This new syntax provides a more convenient way to write code in some situations.

The second part of the above example shows that primitive arrays work just like object arrays except that primitive arrays hold the primitive values directly.

Collections Of Primitives

Collection classes can hold only handles to objects. An array, however, can be created to hold primitives directly, as well as handles to objects.

It is possible to use the “wrapper” classes such as Integer, Double, etc. to place primitive values inside a collection, but as you’ll see later in this chapter in the example, the wrapper classes for primitives are only somewhat useful anyway.

Whether you put primitives in arrays or wrap them in a class that’s placed in a collection is a question of efficiency.

It’s much more efficient to create and access an array of primitives than a collection of wrapped primitives.

Of course, if you’re using a primitive type and you need the flexibility of a collection that automatically expands when more space is needed, the array won’t work and you’re forced to use a collection of wrapped primitives.

You might think that there should be a specialized type of Vector for each of the primitive data types, but Java doesn’t provide this for you. Some sort of templatizing mechanism might someday provide a better way for Java to handle this problem. 

Returning An Array

Suppose you’re writing a method and you don’t just want to return one thing, but a whole bunch of things.

Languages like C and C++ make this difficult because you can’t just return an array, only a pointer to an array.

This introduces problems because it becomes messy to control the lifetime of the array, which easily leads to memory leaks.

Java takes a similar approach, but you just “return an array.” Actually, of course, you’re returning a handle to an array, but with Java you never worry about responsibility for that array – it will be around as long as you need it, and the garbage collector will clean it up when you’re done.As an example, consider returning an array of String:

// Returning arrays from methods

public class IceCream {
  static String[] flav = {
    "Chocolate", "Strawberry",
    "Vanilla Fudge Swirl", "Mint Chip",
    "Mocha Almond Fudge", "Rum Raisin",
    "Praline Cream", "Mud Pie" 
  static String[] flavorSet(int n) {
    // Force it to be positive & within bounds:
    n = Math.abs(n) % (flav.length + 1);
    String[] results = new String[n];
    int[] picks = new int[n];
    for(int i = 0; i < picks.length; i++)
      picks[i] = -1;
    for(int i = 0; i < picks.length; i++) {
      while(true) {
        int t =
          (int)(Math.random() * flav.length);
        for(int j = 0; j < i; j++)
          if(picks[j] == t) continue retry;
        picks[i] = t;
        results[i] = flav[t];
    return results;
  public static void main(String[] args) {
    for(int i = 0; i < 20; i++) {
        "flavorSet(" + i + ") = ");
      String[] fl = flavorSet(flav.length);
      for(int j = 0; j < fl.length; j++)
        System.out.println("\t" + fl[j]);
} ///:~ 

The method flavorSet( ) creates an array of String called results. The size of this array is n, determined by the argument you pass into the method.

Then it proceeds to choose flavors randomly from the array flav and place them into results, which it finally returns.

Returning an array is just like returning any other object – it’s a handle. It’s not important that the array was created within flavorSet( ), or that the array was created anyplace else, for that matter.

The garbage collector takes care of cleaning up the array when you’re done with it, and the array will persist for as long as you need it.

As an aside, notice that when flavorSet( ) chooses flavors randomly, it ensures that a random choice hasn’t been picked before.

This is performed in a seemingly infinite while loop that keeps making random choices until it finds one that’s not already in the picks array.

(Of course, a String comparison could also have been performed to see if the random choice was already in the results array, but String comparisons are inefficient.)

If it’s successful it adds the entry and breaks out to go find the next one ( i gets incremented).

But if t is a number that’s already in picks, then a labeled continue is used to jump back two levels, which forces a new t to be selected.

It’s particularly convincing to watch this happen with a debugger.main( ) prints out 20 full sets of flavors, so you can see that flavorSet( ) chooses the flavors in a random order each time.

It’s easiest to see this if you redirect the output into a file. And while you’re looking at the file, remember, you’re not really hungry. (You just want the ice cream, you don’t need it.)

Stay on top of the latest technology trends — delivered directly to your inbox, free!

Subscription Form Posts

Don't worry, we don't spam

Written by Bobby

Bobby Lawson is a seasoned technology writer with over a decade of experience in the industry. He has written extensively on topics such as cybersecurity, cloud computing, and data analytics. His articles have been featured in several prominent publications, and he is known for his ability to distill complex technical concepts into easily digestible content.