Initializing and processing arrays of primitives



An array is an indexed table of like values. While they can exist in more than one dimension, we are only interested in one-dimensional arrays as depicted by the following:

Index (offset) Value










This array consists of five elements where each is an integer value (217, 138, 92, 12, and 168).

To access a particular element within an array, its corresponding index (offset) is used. For example, the integer value at index location 3 within this array is 12. Notice that the indexes are zero based because the offset of the first element is always zero (you don't have to skip over any other elements to get there).

While all programming languages include the ability to process arrays, Java provides enhanced integrity and other features not found in other languages.


Java arrays

You may NEVER have elements with different data types in the same array. This restriction guarantees that each element occupies the same amount of memory and helps the compiler calculate the location of each element based upon its index.

data-type[] identifier = new data-type[n];


data-type identifier[] = new data-type[n];

where identifier is the array (object) reference and n is an integer expression that specifies how many elements are in the array. The first form is preferred. The second form is similar to the array definition technique used in C++.

For example, to create a 5 element array of int values a programmer might code

int[] myArray = new int[5];

Alternatively, a programmer may split the definition of the array reference and the instantiation of the array into two statements as follows:

int[] myArray;
myArray = new int[5];

Using either technique, it is important to understand what is created. The following diagram may help:


Heap space









The array reference (myArray) can be thought of as pointing to the array whose elements reside on the memory heap.


  1. At the time an array reference is declared, it initially contains null (it doesn't point to anything). It doesn't receive a value until an array is assigned to it.

  2. An array reference can only be assigned an array of the correct type. In the above example, myArray is declared to be a reference to an int array, so only an array of int values can ever be assigned to it. To attempt otherwise will result in a compile error.

  3. An array reference may be reused to point to a different array (of the appropriate type). Like all objects, however, an array that can no longer be referenced will be garbage collected.

  4. When instantiated, all array elements are automatically initialized to binary zeros. This means all elements of numeric arrays will be zero, all elements of boolean arrays will be false, and all elements of char arrays will be the null character.

char[] chars = {'a', 'b', 'c'};

which creates a three element array of characters. The first element is initialized to 'a', the second is initialized to 'b', and the third is initialized to 'c'.


  1. The number of elements in the array is determined by the number of values in the list and the new keyword isn't coded.

  2. When a value list is used, it can only be coded in the statement that declares the array reference. In other words, the following will not compile:

char[] chars;
chars = {'a', 'b', 'c'};

int[] numbers = {12, 15, 3, 8};

the following expression will reference the third element (an int with a value of 3)



  1. An index must be int or able to be widened to int to avoid a compile error. It may not be boolean, long, float, or double.

  2. If an index is negative of exceeds the maximum valid index for the array, a runtime error occurs. The JVM will throw an ArrayIndexOutOfBoundsException. Catching and processing such exceptions is a topic in advanced Java.

For example, the following small program creates an array, loads it with some random numbers, and displays the array's contents:

public class App {
  public static void main(String[] args) {
    double[] values = new double[10];
    for (int i = 0; i < values.length; i++) {
      values[i] = Math.random();
    for (int i = 0; i < values.length; i++) {


  1. In an array object, length is a field and NOT a method. A common mistake is to code length() as you would with a String or StringBuffer object and get a compile error.

  2. Because the for loops are limited by the length of the array, the code is very flexible. Changing the number of elements in the array declaration is all that is needed to work with a different sized array.


Sample program

The following program allows a user to specify the number of elements and the actual element values for an array of double variables. After the values have been entered, the array is displayed along with summary information about its contents. The user is then asked if they want to do another array.

public class App {
  public static void main(String[] args) {

    // Loop control variable.

    char again = 'y';

    // Main loop. One array is entered and processed in each iteration.


    while (again == 'Y' || again =='y') {

      // Local variables for performing array processing.

      double[] numbers;
      int noElements;
      double total;
      double largest;
      double smallest;

      // Prompt for and read how many numbers the array is to contain.

      Utility.separator(40, '=');
      System.out.print("How many numbers will you enter? " );
      noElements = Keyboard.readInt();

      // If the number of elements is invalid, display an error message
      // and continue the main loop from the beginning.

      if (noElements <= 0) {
        System.out.println("\tInvalid number of elements");
        continue another;

      // Instantiate the array and loop to load its elements with values
      // entered by the user.

      numbers = new double[noElements];
      for (int i = 0; i < noElements; i++) {
        System.out.print("Element (" + i + "): ");
        numbers[i] = Keyboard.readDouble();

      // Display a message saying that loading is complete.

      System.out.println("\tLoading is complete");
      System.out.println("\tThe array contains:");

      // Prepare to display the array and gather array statistics. Prior
      // to looping, the largest and smallest values are assumed to be
      // the first element and the total is set ot zero.

      largest = numbers[0];
      smallest = numbers[0];
      total = 0;

      // Loop through the entire array to display the value of each
      // element. Along the way, the total of all elements is
      // accumulated and the largest and smallest element values
      // are found.

      for (int i = 0; i < noElements; i++) {
        System.out.println("\t\t" + numbers[i]);
        total += numbers[i];

        // If beyond the first element, test for a new largest and
        // smallest element and save them if found.

        if (i != 0) {
          if (numbers[i] > largest) {
            largest = numbers[i];
          if (numbers[i] < smallest) {
            smallest = numbers[i];

      // Display the array statistics.

      System.out.println("\t Largest: " + largest);
      System.out.println("\tSmallest: " + smallest);
      System.out.println("\t Average: " + total/numbers.length);
      System.out.println("\t   Total: " + total);

      // Ask the user if they want to do it again and repeat the loop as
      // requested.

      Utility.separator(40, '=');
      System.out.print("Again? (Y/N): ");
      again = Keyboard.readChar();


Looking ahead

In this lesson, each array element was of a primitive data type. Java also permits object arrays in which each element is an object (such as a String or StringBuffer object). You can also pass an array to a method and receive an array from a method. These topics will be covered in the next few lessons.


Lab exercise for Ferris students

E-mail your answers to this assignment no later than the due date listed in the class schedule.


Review questions

  1. Assuming that all unseen code is correct, what will result from attempting to compile and execute the following code? The line numbers are for reference purposes only.

long[] array;
array = new long[5];
System.out.println("Value is: " + array[4]);
  1. Compilation will fail at line 1

  2. Compilation will fail at line 2

  3. Compilation will fail at line 3

  4. Compilation will succeed but a runtime error will occur

  5. Compiles and runs to display "Value is: 0"

  6. Compiles and runs to display an unpredictable value

  1. Assuming that all unseen code is correct, what will result from attempting to compile and execute the following code? The line numbers are for reference purposes only.

double[] x = {2.1, 3.7, -1.8};
System.out.println("Value is: " + x[3]);
  1. Compilation will fail at line 1

  2. Compilation will fail at line 2

  3. Compilation will succeed but a runtime error will occur

  4. Compiles and runs to display "Value is: -1.8"

  5. Compiles and runs to display "Value is: 0.0"

  6. Compiles and runs to display an unpredictable value

  1. What will result from an attempt to compile and execute the following statement?

char z = {'x', 'y', 'z'};

  1. The statement will not compile

  2. The statement will compile and execute to create an array having 3 elements

  3. z[1] will have a value of 'x'

  4. z[2] will have a value of 'z'

  5. both B and D

  1. True or False: If someArray references an array of int variables, the following expression represents the number of elements in the array.


  1. True

  2. False