The Nuts and Bolts of the Java Language

Arrays and Strings

Like other programming languages, Java allows you to collect and manage multiple values through an array object. You manage data comprised of multiple characters through a String object.

Arrays

The countChars method doesn't use an array, but the Count class's main method declares an array as a parameter to main. This section shows you how to create and use arrays in your Java programs.

As for other variables, before you can use an array you must first declare it. Again, like other variables, a declaration of an array has two primary components: the array's type and the array's name. An array's type includes the data type of the elements contained within the array. For example, the data type for an array that contained all integer elements is array of integers. You cannot have a generic array--the data type of its elements must be identified when the array is declared. Here's a declaration for an array of integers:

int[] arrayOfInts;

The int[] part of the declaration indicates that arrayOfInts is an array of integers. The declaration does not allocate any memory to contain the array elements.

If your program attempted to assign or access any values to any elements of arrayOfInts before memory for it has been allocated the compiler will print an error like this one and refuse to compile your program.

testing.java:64: Variable arrayOfInts may not have been initialized.

To allocate memory for the elements of the array, you must instantiate the array. You do this using Java's new operator. (Actually, the steps you take to create an array are similar to the steps you take to create an object from a class: declaration, instantiation, and initialization. You can learn more about creating objects in the Creating Objects section of the next lesson.

The following statement allocates enough memory for arrayOfInts to contain ten integer elements.

int[] arrayOfInts = new int[10]

In general, when creating an array, you use the new operator, plus the data type of the array elements, plus the number of elements desired enclosed within square brackets ('[' and ']').

elementType[] arrayName = new elementType[arraySize]

Now that some memory has been allocated for your array, you can assign values to its elements and retrieve those values:

for (int j = 0; j < arrayOfInts.length; j ++) {
    arrayOfInts[j] = j;
    System.out.println("[j] = " + arrayOfInts[j]);
}

This example shows that to reference an array element, you append square brackets to the array name. Between the square brackets indicate (either with a variable or some other expression) the index of the element you want to access. Note that in Java, array indices begin at 0 and end at the array length minus 1.

There's another interesting element (so to speak) in the small code sample above. The for loop iterates over each element of arrayOfInts, assigning values to its elements and printing out those values. Notice the use of arrayOfInts.length to retrieve the current length of the array. length is a property provided for all Java arrays.

Let's look again at the main method that calls countChars. In particular note the use of the args array:

import java.io.*;
public class Count {
    // ... countChars method omitted ...
    public static void main(String[] args) throws Exception {
        if (args.length >= 1)
            countChars(new FileReader(args[0]));
        else
            System.err.println("Usage: Count filename"); 
    }
}

The Java runtime allocates the space for the args array, so main doesn't have to bother with it. The main method ensures that there's at least one element in the args array, and if there is, it uses the first element in the array (presumably the name of a file) to open a FileReader.

Arrays can contain any legal Java data type including reference types such as objects or other arrays. For example, the following declares an array that can contain ten String objects.

String[] arrayOfStrings = new String[10];

The elements in this array are reference types, that is, each element contains a reference to a String object. At this point, enough memory has been allocated to contain the String references, but no memory has been allocated for the Strings themselves. If you attempted to access one of arrayOfStrings elements at this point, you would get a NullPointerException because the array is empty and contains no Strings and no String objects. This is often a source of some confusion for programmers new to the Java language. You have to allocate the actual String objects separately:

for (int i = 0; i < arrayOfStrings.length; i ++) {
    arrayOfStrings[i] = new String("Hello " + i);
}

Strings

A sequence of character data is called a string and is implemented in the Java environment by the String class (a member of the java.lang package). Count's main method uses Strings in its the declaration of the args array:

String[] args

This code explicitly declares an array named args that contains String objects. The empty brackets indicate that the length of the array is unknown at compilation time because the array is passed in at runtime.

The countChars method also uses two Strings both in the form of a literal string (a string of characters between double quotation marks):

"Counted "
    . . .
" chars."

The program implicitly allocates two String objects, one for each of the two literal strings shown previously.

String objects are immutable--that is, they cannot be changed once they've been created. The java.lang package provides a different class, StringBuffer, which you can use to create and manipulate character data on the fly. The String and StringBuffer Classes covers thoroughly the use of both the String and StringBuffer classes.

String Concatenation

Java lets you concatenate strings together easily using the + operator. The countChars method uses this feature of the Java language to print its output. The following code snippet concatenates three strings together to produce its output:

"Counted " + count + " chars."

Two of the strings concatenated together are literal strings: "Counted " and " chars." The third string--the one in the middle--is actually an integer that first gets converted to a string and then is concatenated to the others.

The Nuts and Bolts of the Java Language