Chapter 3. Fundamental Programming Structures in Java

At this point, we are assuming that you successfully installed the JDK and were able to run the sample programs that we showed you in Chapter 2. It’s time to start programming. This chapter shows you how the basic programming concepts such as data types, branches, and loops are implemented in Java.

Unfortunately, in Java you can’t easily write a program that uses a GUI—you need to learn a fair amount of machinery to put up windows, add text boxes and buttons that respond to them, and so on. Introducing the techniques needed to write GUI-based Java programs would take us too far away from our goal of covering the basic programming concepts, so the sample programs in this chapter are “toy” programs designed to illustrate a concept. All these examples simply use a terminal window for input and output.

Click here to view code image

public class FirstSample
{
   public static void main(String[] args)
   {
      System.out.println("We will not use 'Hello, World!'");
   }
}

It is worth spending all the time you need to become comfortable with the framework of this sample; the pieces will recur in all applications. First and foremost, Java is case sensitive. If you made any mistakes in capitalization (such as typing Main instead of main), the program will not run.

Now let’s look at this source code line by line. The keyword public is called an access modifier; these modifiers control the level of access other parts of a program have to this code. We have more to say about access modifiers in Chapter 5. The keyword class reminds you that everything in a Java program lives inside a class. Although we will spend a lot more time on classes in the next chapter, for now think of a class as a container for the program logic that defines the behavior of an application. As mentioned in Chapter 1, classes are the building blocks with which all Java applications and applets are built. Everything in a Java program must be inside a class.

Following the keyword class is the name of the class. The rules for class names in Java are quite generous. Names must begin with a letter, and after that, they can have any combination of letters and digits. The length is essentially unlimited. You cannot use a Java reserved word (such as public or class) for a class name. (See Appendix A for a list of reserved words.)

The standard naming convention (which we follow in the name FirstSample) is that class names are nouns that start with an uppercase letter. If a name consists of multiple words, use an initial uppercase letter in each of the words. (This use of uppercase letters in the middle of a word is sometimes called “camel case” or, self-referentially, “CamelCase”.)

You need to make the file name for the source code the same as the name of the public class, with the extension .java appended. Thus, you must store this code in a file called FirstSample.java. (Again, case is important—don’t use firstsample.java.)

If you have named the file correctly and not made any typos in the source code, then when you compile this source code, you end up with a file containing the bytecodes for this class. The Java compiler automatically names the bytecode file FirstSample.class and stores it in the same directory as the source file. Finally, launch the program by issuing the following command:

java FirstSample

(Remember to leave off the .class extension.) When the program executes, it simply displays the string We will not use 'Hello, World!' on the console.

When you use

java ClassName

to run a compiled program, the Java virtual machine always starts execution with the code in the main method in the class you indicate. (The term “method” is Javaspeak for a function.) Thus, you must have a main method in the source file for your class for your code to execute. You can, of course, add your own methods to a class and call them from the main method. (We cover writing your own methods in the next chapter.)

Notice the braces { } in the source code. In Java, as in C/C++, braces delineate the parts (usually called blocks) in your program. In Java, the code for any method must be started by an opening brace { and ended by a closing brace }.

Brace styles have inspired an inordinate amount of useless controversy. We follow a style that lines up matching braces. As whitespace is irrelevant to the Java compiler, you can use whatever brace style you like. We will have more to say about the use of braces when we talk about the various kinds of loops.

For now, don’t worry about the keywords static void—just think of them as part of what you need to get a Java program to compile. By the end of Chapter 4, you will understand this incantation completely. The point to remember for now is that every Java application must have a main method that is declared in the following way:

Click here to view code image

public class ClassName
{
   public static void main(String[] args)
   {
      program statements
   }
}

Click here to view code image

{
   System.out.println("We will not use 'Hello, World!'");
}

Braces mark the beginning and end of the body of the method. This method has only one statement in it. As with most programming languages, you can think of Java statements as sentences of the language. In Java, every statement must end with a semicolon. In particular, carriage returns do not mark the end of a statement, so statements can span multiple lines if need be.

The body of the main method contains a statement that outputs a single line of text to the console.

Here, we are using the System.out object and calling its println method. Notice the periods used to invoke a method. Java uses the general syntax

object.method(parameters)

as its equivalent of a function call.

In this case, we are calling the println method and passing it a string parameter. The method displays the string parameter on the console. It then terminates the output line, so that each call to println displays its output on a new line. Notice that Java, like C/C++, uses double quotes to delimit strings. (You can find more information about strings later in this chapter.)

Methods in Java, like functions in any programming language, can use zero, one, or more parameters (some programmers call them arguments). Even if a method takes no parameters, you must still use empty parentheses. For example, a variant of the println method with no parameters just prints a blank line. You invoke it with the call

Click here to view code image

System.out.println("We will not use 'Hello, World!'"); // is this too cute?

When longer comments are needed, you can mark each line with a //, or you can use the /* and */ comment delimiters that let you block off a longer comment.

Finally, a third kind of comment can be used to generate documentation automatically. This comment uses a /** to start and a */ to end. You can see this type of comment in Listing 3.1. For more on this type of comment and on automatic documentation generation, see Chapter 4.

Listing 3.1 FirstSample/FirstSample.java

Click here to view code image

 1   /**
 2    * This is the first sample program in Core Java Chapter 3
 3    * @version 1.01 1997-03-22
 4    * @author Gary Cornell
 5    */
 6   public class FirstSample
 7   {
 8      public static void main(String[] args)
 9      {
10         System.out.println("We will not use 'Hello, World!'");
11      }
12   }

Table 3.1 Java Integer Types

Under Java, the ranges of the integer types do not depend on the machine on which you will be running the Java code. This alleviates a major pain for the programmer who wants to move software from one platform to another, or even between operating systems on the same platform. In contrast, C and C++ programs use the most efficient integer type for each processor. As a result, a C program that runs well on a 32-bit processor may exhibit integer overflow on a 16-bit system. Since Java programs must run with the same results on all machines, the ranges for the various types are fixed.

Table 3.2 Floating-Point Types

Numbers of type float have a suffix F or f (for example, 3.14F). Floating-point numbers without an F suffix (such as 3.14) are always considered to be of type double. You can optionally supply the D or d suffix (for example, 3.14D).

Besides the \u escape sequences, there are several escape sequences for special characters, as shown in Table 3.3. You can use these escape sequences inside quoted character literals and strings, such as '\u2122' or "Hello\n". The \u escape sequence (but none of the other escape sequences) can even be used outside quoted character constants and strings. For example,

Click here to view code image

public static void main(String\u005B\u005D args)

is perfectly legal—\u005B and \u005D are the encodings for [ and ].

Table 3.3 Escape Sequences for Special Characters

We need a bit of terminology to explain how this problem is resolved in Java, beginning with Java SE 5.0. A code point is a code value that is associated with a character in an encoding scheme. In the Unicode standard, code points are written in hexadecimal and prefixed with U+, such as U+0041 for the code point of the Latin letter A. Unicode has code points that are grouped into 17 code planes. The first code plane, called the basic multilingual plane, consists of the “classic” Unicode characters with code points U+0000 to U+FFFF. Sixteen additional planes, with code points U+10000 to U+10FFFF, hold the supplementary characters.

The UTF-16 encoding represents all Unicode code points in a variable-length code. The characters in the basic multilingual plane are represented as 16-bit values, called code units. The supplementary characters are encoded as consecutive pairs of code units. Each of the values in such an encoding pair falls into a range of 2048 unused values of the basic multilingual plane, called the surrogates area (U+D800 to U+DBFF for the first code unit, U+DC00 to U+DFFF for the second code unit). This is rather clever, because you can immediately tell whether a code unit encodes a single character or it is the first or second part of a supplementary character. For example, (the mathematical symbol for the set of octonions, http://math.ucr.edu/home/baez/octonions) has code point U+1D546 and is encoded by the two code units U+D835 and U+DD46. (See http://en.wikipedia.org/wiki/UTF-16 for a description of the encoding algorithm.)

In Java, the char type describes a code unit in the UTF-16 encoding.

Our strong recommendation is not to use the char type in your programs unless you are actually manipulating UTF-16 code units. You are almost always better off treating strings (which we will discuss in Section 3.6, “Strings,” on p. 65) as abstract data types.

You also cannot use a Java reserved word as a variable name. (See Appendix A for a list of reserved words.)

You can declare multiple variables on a single line:

Click here to view code image

int i, j; // both are integers

However, we don’t recommend this style. If you declare each variable separately, your programs are easier to read.

Click here to view code image

int vacationDays;
System.out.println(vacationDays); // ERROR--variable not initialized

You assign to a previously declared variable by using the variable name on the left, an equal sign (=), and then some Java expression with an appropriate value on the right.

int vacationDays;
vacationDays = 12;

You can both declare and initialize a variable on the same line. For example:

int vacationDays = 12;

Finally, in Java you can put declarations anywhere in your code. For example, the following is valid code in Java:

Click here to view code image

double salary = 65000.0;
System.out.println(salary);
int vacationDays = 12; // OK to declare a variable here

In Java, it is considered good style to declare variables as closely as possible to the point where they are first used.

Click here to view code image

public class Constants
{
   public static void main(String[] args)
   {
      final double CM_PER_INCH = 2.54;
      double paperWidth = 8.5;
      double paperHeight = 11;
      System.out.println("Paper size in centimeters: "
         + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
   }
}

The keyword final indicates that you can assign to the variable once, and then its value is set once and for all. It is customary to name constants in all uppercase.

It is probably more common in Java to create a constant so it’s available to multiple methods inside a single class. These are usually called class constants. Set up a class constant with the keywords static final. Here is an example of using a class constant:

Click here to view code image

public class Constants2
{
   public static final double CM_PER_INCH = 2.54;

   public static void main(String[] args)
   {
      double paperWidth = 8.5;
      double paperHeight = 11;
      System.out.println("Paper size in centimeters: "
         + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
   }
}

Note that the definition of the class constant appears outside the main method. Thus, the constant can also be used in other methods of the same class. Furthermore, if the constant is declared, as in our example, public, methods of other classes can also use it—in our example, as Constants2.CM_PER_INCH.

To take the square root of a number, use the sqrt method:

Click here to view code image

double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // prints 2.0

The Java programming language has no operator for raising a quantity to a power: You must use the pow method in the Math class. The statement

double y = Math.pow(x, a);

sets y to be x raised to the power a (xa). The pow method’s parameters are both of type double, and it returns a double as well.

The floorMod method aims to solve a long-standing problem with integer remainders. Consider the expression n % 2. Everyone knows that this is 0 if n is even and 1 if n is odd. Except, of course, when n is negative. Then it is –1. Why? When the first computers were built, someone had to make rules for how integer division and remainder should work for negative operands. Mathematicians had known the optimal (or “Euclidean”) rule for a few hundred years: always leave the remainder ≥ 0. But, rather than open a math textbook, those pioneers came up with rules that seemed reasonable but are actually inconvenient.

Figure 3.1 Legal conversions between numeric types

The six solid arrows in Figure 3.1 denote conversions without information loss. The three dotted arrows denote conversions that may lose precision. For example, a large integer such as 123456789 has more digits than the float type can represent. When the integer is converted to a float, the resulting value has the correct magnitude but loses some precision.

Click here to view code image

int n = 123456789;
float f = n; // f is 1.23456792E8

When two values are combined with a binary operator (such as n + f where n is an integer and f is a floating-point value), both operands are converted to a common type before the operation is carried out.

Click here to view code image

int m = 7;
int n = 7;
int a = 2 * ++m; // now a is 16, m is 8
int b = 2 * n++; // now b is 14, n is 8

Click here to view code image

x != 0 && 1 / x > x + y // no division by 0

the second part is never evaluated if x equals zero. Thus, 1 / x is not computed if x is zero, and no divide-by-zero error can occur.

Similarly, the value of expression1 || expression₂ is automatically true if the first expression is true, without evaluating the second expression.

Finally, Java supports the ternary ?: operator that is occasionally useful. The expression

Click here to view code image

condition ? expression₁ : expression₂

evaluates to the first expression if the condition is true, to the second expression otherwise. For example,

Click here to view code image

&("and")  |("or")  ^("xor")  ~("not")

These operators work on bit patterns. For example, if n is an integer variable, then

Click here to view code image

int fourthBitFromRight = (n & 0b1000) / 0b1000;

gives you a 1 if the fourth bit from the right in the binary representation of n is 1, and 0 otherwise. Using & with the appropriate power of 2 lets you mask out all but a single bit.

There are also >> and << operators which shift a bit pattern to the right or left. These operators are convenient when you need to build up bit patterns to do bit masking:

Click here to view code image

int fourthBitFromRight = (n & (1 << 3)) >> 3;

Finally, a >>> operator fills the top bits with zero, unlike >> which extends the sign bit into the top bits. There is no <<< operator.

a && b || c

Table 3.4 Operator Precedence

Since += associates right to left, the expression

Click here to view code image

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

Now you can declare variables of this type:

Size s = Size.MEDIUM;

A variable of type Size can hold only one of the values listed in the type declaration, or the special value null that indicates that the variable is not set to any value at all.

We discuss enumerated types in greater detail in Chapter 5.

Click here to view code image

String e = ""; // an empty string
String greeting = "Hello";

Click here to view code image

String greeting = "Hello";
String s = greeting.substring(0, 3);

creates a string consisting of the characters "Hel".

The second parameter of substring is the first position that you do not want to copy. In our case, we want to copy positions 0, 1, and 2 (from position 0 to position 2 inclusive). As substring counts it, this means from position 0 inclusive to position 3 exclusive.

There is one advantage to the way substring works: Computing the length of the substring is easy. The string s.substring(a, b) always has length b – a. For example, the substring "Hel" has length 3 – 0 = 3.

Click here to view code image

String expletive = "Expletive";
String PG13 = "deleted";
String message = expletive + PG13;

The preceding code sets the variable message to the string "Expletivedeleted". (Note the lack of a space between the words: The + operator joins two strings in the order received, exactly as they are given.)

When you concatenate a string with a value that is not a string, the latter is converted to a string. (As you will see in Chapter 5, every Java object can be converted to a string.) For example,

int age = 13;
String rating = "PG" + age;

sets rating to the string "PG13".

This feature is commonly used in output statements. For example,

Click here to view code image

System.out.println("The answer is " + answer);

is perfectly acceptable and prints what you would expect (and with the correct spacing because of the space after the word is).

If you need to put multiple strings together, separated by a delimiter, use the static join method:

Click here to view code image

String all = String.join(" / ", "S", "M", "L", "XL");
    // all is the string "S / M / L / XL"

Click here to view code image

greeting = greeting.substring(0, 3) + "p!";

This declaration changes the current value of the greeting variable to "Help!".

Since you cannot change the individual characters in a Java string, the documentation refers to the objects of the String class as immutable. Just as the number 3 is always 3, the string "Hello" will always contain the code-unit sequence for the characters H, e, l, l, o. You cannot change these values. Yet you can, as you just saw, change the contents of the string variable greeting and make it refer to a different string, just as you can make a numeric variable currently holding the value 3 hold the value 4.

Isn’t that a lot less efficient? It would seem simpler to change the code units than to build up a whole new string from scratch. Well, yes and no. Indeed, it isn’t efficient to generate a new string that holds the concatenation of "Hel" and "p!". But immutable strings have one great advantage: The compiler can arrange that strings are shared.

To understand how this works, think of the various strings as sitting in a common pool. String variables then point to locations in the pool. If you copy a string variable, both the original and the copy share the same characters.

Overall, the designers of Java decided that the efficiency of sharing outweighs the inefficiency of string editing by extracting substrings and concatenating. Look at your own programs; we suspect that most of the time, you don’t change strings—you just compare them. (There is one common exception—assembling strings from individual characters or from shorter strings that come from the keyboard or a file. For these situations, Java provides a separate class that we describe in Section 3.6.9, “Building Strings,” on p. 77.)

Click here to view code image

"Hello".equalsIgnoreCase("hello")

Do not use the == operator to test whether two strings are equal! It only determines whether or not the strings are stored in the same location. Sure, if strings are in the same location, they must be equal. But it is entirely possible to store multiple copies of identical strings in different places.

Click here to view code image

String greeting = "Hello"; //initialize greeting to a string
if (greeting == "Hello") . . .
   // probably true
if (greeting.substring(0, 3) == "Hel") . . .
   // probably false

If the virtual machine always arranges for equal strings to be shared, then you could use the == operator for testing equality. But only string literals are shared, not strings that are the result of operations like + or substring. Therefore, never use == to compare strings lest you end up with a program with the worst kind of bug—an intermittent one that seems to occur randomly.

if (str.length() == 0)

or

if (str.equals(""))

An empty string is a Java object which holds the string length (namely 0) and an empty contents. However, a String variable can also hold a special value, called null, that indicates that no object is currently associated with the variable. (See Chapter 4 for more information about null.) To test whether a string is null, use the condition

if (str == null)

Sometimes, you need to test that a string is neither null nor empty. Then use the condition

Click here to view code image

if (str != null && str.length() != 0)

You need to test that str is not null first. As you will see in Chapter 4, it is an error to invoke a method on a null value.

The length method yields the number of code units required for a given string in the UTF-16 encoding. For example:

Click here to view code image

String greeting = "Hello";
int n = greeting.length(); // is 5.

To get the true length—that is, the number of code points—call

Click here to view code image

int cpCount = greeting.codePointCount(0, greeting.length());

The call s.charAt(n) returns the code unit at position n, where n is between 0 and s.length() – 1. For example:

Click here to view code image

char first = greeting.charAt(0); // first is 'H'
char last = greeting.charAt(4); // last is 'o'

To get at the ith code point, use the statements

Click here to view code image

int index = greeting.offsetByCodePoints(0, i);
int cp = greeting.codePointAt(index);

Why are we making a fuss about code units? Consider the sentence

Click here to view code image

int cp = sentence.codePointAt(i);
if (Character.isSupplementaryCodePoint(cp)) i += 2;
else i++;

You can move backwards with the following statements:

Click here to view code image

i--;
if (Character.isSurrogate(sentence.charAt(i))) i--;
int cp = sentence.codePointAt(i);

Obviously, that is quite painful. An easier way is to use the codePoints method that yields a “stream” of int values, one for each code point. (We will discuss streams in Chapter 2 of Volume II.) You can just turn it into an array (see Section 3.10, “Arrays,” on p. 111) and traverse that.

Click here to view code image

int[] codePoints = str.codePoints().toArray();

Conversely, to turn an array of code points to a string, use a constructor. (We discuss constructors and the new operator in detail in Chapter 4.)

Click here to view code image

String str = new String(codePoints, 0, codePoints.length);

Figure 3.2 The three panes of the API documentation

The screen is organized into three frames. A small frame on the top left shows all available packages. Below it, a larger frame lists all classes. Click on a class name, and the API documentation for the class is displayed in the large frame to the right (see Figure 3.3). For example, to get more information on the methods of the String class, scroll the second frame until you see the String link, then click on it.

Figure 3.3 Class description for the String class

Then scroll the frame on the right until you reach a summary of all methods, sorted in alphabetical order (see Figure 3.4). Click on any method name for a detailed description of that method (see Figure 3.5). For example, if you click on the compareToIgnoreCase link, you’ll get the description of the compareToIgnoreCase method.

Figure 3.4 Method summary of the String class

Figure 3.5 Detailed description of a String method

Click here to view code image

StringBuilder builder = new StringBuilder();

Each time you need to add another part, call the append method.

Click here to view code image

builder.append(ch); // appends a single character
builder.append(str); // appends a string

When you are done building the string, call the toString method. You will get a String object with the character sequence contained in the builder.

Click here to view code image

String completedString = builder.toString();

Click here to view code image

Scanner in = new Scanner(System.in);

(We discuss constructors and the new operator in detail in Chapter 4.)

Now you can use the various methods of the Scanner class to read input. For example, the nextLine method reads a line of input.

Click here to view code image

System.out.print("What is your name? ");
String name = in.nextLine();

Here, we use the nextLine method because the input might contain spaces. To read a single word (delimited by whitespace), call

String firstName = in.next();

To read an integer, use the nextInt method.

Click here to view code image

System.out.print("How old are you? ");
int age = in.nextInt();

Similarly, the nextDouble method reads the next floating-point number.

The program in Listing 3.2 asks for the user’s name and age and then prints a message like

Click here to view code image

Hello, Cay. Next year, you'll be 57

Finally, note the line

import java.util.*;

at the beginning of the program. The Scanner class is defined in the java.util package. Whenever you use a class that is not defined in the basic java.lang package, you need to use an import directive. We look at packages and import directives in more detail in Chapter 4.

Listing 3.2 InputTest/InputTest.java

Click here to view code image

 1   import java.util.*;
 2
 3   /**
 4    * This program demonstrates console input.
 5    * @version 1.10 2004-02-10
 6    * @author Cay Horstmann
 7    */
 8   public class InputTest
 9   {
10      public static void main(String[] args)
11      {
12         Scanner in = new Scanner(System.in);
13
14         // get first input
15         System.out.print("What is your name? ");
16         String name = in.nextLine();
17
18         // get second input
19         System.out.print("How old are you? ");
20         int age = in.nextInt();
21
22         // display output on console
23         System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));
24      }
25  }

Click here to view code image

System.out.printf("%8.2f", x);

prints x with a field width of 8 characters and a precision of 2 characters. That is, the printout contains a leading space and the seven characters

3333.33

You can supply multiple parameters to printf. For example:

Click here to view code image

System.out.printf("Hello, %s. Next year, you'll be %d", name, age);

Each of the format specifiers that start with a % character is replaced with the corresponding argument. The conversion character that ends a format specifier indicates the type of the value to be formatted: f is a floating-point number, s a string, and d a decimal integer. Table 3.5 shows all conversion characters.

Table 3.5 Conversions for printf

In addition, you can specify flags that control the appearance of the formatted output. Table 3.6 shows all flags. For example, the comma flag adds group separators. That is,

Click here to view code image

System.out.printf("%,.2f", 10000.0 / 3.0);

Table 3.6 Flags for printf

You can use the static String.format method to create a formatted string without printing it:

Click here to view code image

String message = String.format("Hello, %s. Next year, you'll be %d", name, age);

In the interest of completeness, we briefly discuss the date and time formatting options of the printf method. For new code, you should use the methods of the java.time package described in Chapter 6 of Volume II. But you may encounter the Date class and the associated formatting options in legacy code. The format consists of two letters, starting with t and ending in one of the letters of Table 3.7; for example,

Click here to view code image

System.out.printf("%tc", new Date());

Table 3.7 Date and Time Conversion Characters

As you can see in Table 3.7, some of the formats yield only a part of a given date—for example, just the day or just the month. It would be a bit silly if you had to supply the date multiple times to format each part. For that reason, a format string can indicate the index of the argument to be formatted. The index must immediately follow the %, and it must be terminated by a $. For example,

Click here to view code image

System.out.printf("%1$s %2$tB %2$te, %2$tY", "Due date:", new Date());

prints

Due date: February 9, 2015

Alternatively, you can use the < flag. It indicates that the same argument as in the preceding format specification should be used again. That is, the statement

Click here to view code image

System.out.printf("%s %tB %<te, %<tY", "Due date:", new Date());

yields the same output as the preceding statement.

You have now seen all features of the printf method. Figure 3.6 shows a syntax diagram for format specifiers.

Figure 3.6 Format specifier syntax

Click here to view code image

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

If the file name contains backslashes, remember to escape each of them with an additional backslash: "c:\\mydirectory\\myfile.txt".

Now you can read from the file, using any of the Scanner methods that we already described.

To write to a file, construct a PrintWriter object. In the constructor, supply the file name and the character encoding:

Click here to view code image

PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");

If the file does not exist, it is created. You can use the print, println, and printf commands as you did when printing to System.out.

As you just saw, you can access files just as easily as you can use System.in and System.out. There is just one catch: If you construct a Scanner with a file that does not exist or a PrintWriter with a file name that cannot be created, an exception occurs. The Java compiler considers these exceptions to be more serious than a “divide by zero” exception, for example. In Chapter 7, you will learn various ways of handling exceptions. For now, you should simply tell the compiler that you are aware of the possibility of an “input/output” exception. You do this by tagging the main method with a throws clause, like this:

Click here to view code image

public static void main(String[] args) throws IOException
{
   Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");
   ...
}

You have now seen how to read and write files that contain textual data. For more advanced topics, such as dealing with different character encodings, processing binary data, reading directories, and writing zip files, turn to Chapter 2 of Volume II.

A block or compound statement consists of a number of Java statements, surrounded by a pair of braces. Blocks define the scope of your variables. A block can be nested inside another block. Here is a block that is nested inside the block of the main method:

Click here to view code image

public static void main(String[] args)
{
   int n;
   . . .
   {
      int k;
      . . .
   } // k is only defined up to here
}

You may not declare identically named variables in two nested blocks. For example, the following is an error and will not compile:

Click here to view code image

public static void main(String[] args)
{
   int n;
   ...
   {
     int k;
     int n; // Error--can't redefine n in inner block
     ...
   }
}

if (condition) statement

The condition must be surrounded by parentheses.

In Java, as in most programming languages, you will often want to execute multiple statements when a single condition is true. In this case, use a block statement that takes the form

{
   statement₁
   statement₂
   . . .
}

Click here to view code image

if (yourSales >= target)
{
   performance = "Satisfactory";
   bonus = 100;
}

In this code all the statements surrounded by the braces will be executed when yourSales is greater than or equal to target (see Figure 3.7).

Figure 3.7 Flowchart for the if statement

The more general conditional in Java looks like this (see Figure 3.8):

Click here to view code image

if (condition) statement₁ else statement₂

Figure 3.8 Flowchart for the if/else statement

For example:

Click here to view code image

if (yourSales >= target)
{
   performance = "Satisfactory";
   bonus = 100 + 0.01 * (yourSales - target);
}
else
{
   performance = "Unsatisfactory";
   bonus = 0;
}

The else part is always optional. An else groups with the closest if. Thus, in the statement

Click here to view code image

if (x <= 0) if (x == 0) sign = 0; else sign = -1;

the else belongs to the second if. Of course, it is a good idea to use braces to clarify this code:

Click here to view code image

if (x <= 0) { if (x == 0) sign = 0; else sign = -1; }

Repeated if . . . else if . . . alternatives are common (see Figure 3.9). For example:

Click here to view code image

if (yourSales >= 2 * target)
{
   performance = "Excellent";
   bonus = 1000;
}
else if (yourSales >= 1.5 * target)
{
   performance = "Fine";
   bonus = 500;
}
else if (yourSales >= target)
{
   performance = "Satisfactory";
   bonus = 100;
}

else
{
   System.out.println("You're fired");

}

Figure 3.9 Flowchart for the if/else if (multiple branches)

The while loop will never execute if the condition is false at the outset (see Figure 3.10).

Figure 3.10 Flowchart for the while statement

The program in Listing 3.3 determines how long it will take to save a specific amount of money for your well-earned retirement, assuming you deposit the same amount of money per year and the money earns a specified interest rate.

In the example, we are incrementing a counter and updating the amount currently accumulated in the body of the loop until the total exceeds the targeted amount.

Click here to view code image

while (balance < goal)
{
   balance += payment;
   double interest = balance * interestRate / 100;
   balance += interest;
   years++;
}
System.out.println(years + " years.");

(Don’t rely on this program to plan for your retirement. We left out a few niceties such as inflation and your life expectancy.)

A while loop tests at the top. Therefore, the code in the block might never be executed. If you want to make sure a block is executed at least once, you need to move the test to the bottom, using the do/while loop. Its syntax looks like this:

Click here to view code image

do statement while (condition);

This loop executes the statement (which is typically a block) and only then tests the condition. If it’s true, it repeats the statement and retests the condition, and so on. The code in Listing 3.4 computes the new balance in your retirement account and then asks if you are ready to retire:

Click here to view code image

do
{
    balance += payment;
    double interest = balance * interestRate / 100;
    balance += interest;
    year++;
    // print current balance
    ...
    // ask if ready to retire and get input
    ...
}
while (input.equals("N"));

As long as the user answers "N", the loop is repeated (see Figure 3.11). This program is a good example of a loop that needs to be entered at least once, because the user needs to see the balance before deciding whether it is sufficient for retirement.

Figure 3.11 Flowchart for the do/while statement

Listing 3.3 Retirement/Retirement.java

Click here to view code image

 1   import java.util.*;
 2
 3   /**
 4    * This program demonstrates a <code>while</code> loop.
 5    * @version 1.20 2004-02-10
 6    * @author Cay Horstmann
 7    */
 8   public class Retirement
 9   {
10      public static void main(String[] args)
11      {
12         // read inputs
13         Scanner in = new Scanner(System.in);
14
15         System.out.print("How much money do you need to retire? ");
16         double goal = in.nextDouble();
17
18         System.out.print("How much money will you contribute every year? ");
19         double payment = in.nextDouble();
20
21         System.out.print("Interest rate in %: ");
22         double interestRate = in.nextDouble();
23
24         double balance = 0;
25         int years = 0;
26
27         // update account balance while goal isn't reached
28         while (balance < goal)
29         {
30            // add this year's payment and interest
31            balance += payment;
32            double interest = balance * interestRate / 100;
33            balance += interest;
34            years++;
35         }
36
37         System.out.println("You can retire in " + years + " years.");
38      }
39   }

Listing 3.4 Retirement2/Retirement2.java

Click here to view code image

 1   import java.util.*;
 2
 3   /**
 4    * This program demonstrates a <code>do/while</code> loop.
 5    * @version 1.20 2004-02-10
 6    * @author Cay Horstmann
 7    */
 8   public class Retirement2
 9   {
10      public static void main(String[] args)
11      {
12         Scanner in = new Scanner(System.in);
13
14         System.out.print("How much money will you contribute every year? ");
15         double payment = in.nextDouble();
16
17         System.out.print("Interest rate in %: ");
18         double interestRate = in.nextDouble();
19
20         double balance = 0;
21         int year = 0;
22
23         String input;
24
25         // update account balance while user isn't ready to retire
26         do
27         {
28            // add this year's payment and interest
29            balance += payment;
30            double interest = balance * interestRate / 100;
31            balance += interest;
32
33            year++;
34
35            // print current balance
36            System.out.printf("After year %d, your balance is %,.2f%n", year, balance);
37
38            // ask if ready to retire and get input
39            System.out.print("Ready to retire? (Y/N) ");
40            input = in.next();
41         }
42         while (input.equals("N"));
43      }
44   }

for (int i = 1; i <= 10; i++)
   System.out.println(i);

Figure 3.12 Flowchart for the for statement

Although Java, like C++, allows almost any expression in the various slots of a for loop, it is an unwritten rule of good taste that the three slots should only initialize, test, and update the same counter variable. One can write very obscure loops by disregarding this rule.

Click here to view code image

for (int i = 10; i > 0; i--)
   System.out.println("Counting down . . . " + i);
System.out.println("Blastoff!");

When you declare a variable in the first slot of the for statement, the scope of that variable extends until the end of the body of the for loop.

Click here to view code image

for (int i = 1; i <= 10; i++)
{
   ...
}
// i no longer defined here

In particular, if you define a variable inside a for statement, you cannot use its value outside the loop. Therefore, if you wish to use the final value of a loop counter outside the for loop, be sure to declare it outside the loop header.

int i;
for (i = 1; i <= 10; i++)
{
   ...
}
// i is still defined here

On the other hand, you can define variables with the same name in separate for loops:

Click here to view code image

for (int i = 1; i <= 10; i++)
{
   ...
}
...
for (int i = 11; i <= 20; i++) // OK to define another variable named i
{
   ...
}

A for loop is merely a convenient shortcut for a while loop. For example,

Click here to view code image

for (int i = 10; i > 0; i--)
   System.out.println("Counting down . . . " + i);

can be rewritten as

Click here to view code image

int i = 10;
while (i > 0)
{
   System.out.println("Counting down . . . " + i);
   i--;
}

Listing 3.5 shows a typical example of a for loop.

The program computes the odds of winning a lottery. For example, if you must pick six numbers from the numbers 1 to 50 to win, then there are (50 × 49 × 48 × 47 × 46 × 45)/(1 × 2 × 3 × 4 × 5 × 6) possible outcomes, so your chance is 1 in 15,890,700. Good luck!

In general, if you pick k numbers out of n, there are

possible outcomes. The following for loop computes this value:

Click here to view code image

int lotteryOdds = 1;
for (int i = 1; i <= k; i++)
   lotteryOdds = lotteryOdds * (n - i + 1) / i;

Listing 3.5 LotteryOdds/LotteryOdds.java

Click here to view code image

 1   import java.util.*;
 2
 3   /**
 4    * This program demonstrates a <code>for</code> loop.
 5    * @version 1.20 2004-02-10
 6    * @author Cay Horstmann
 7    */
 8   public class LotteryOdds
 9   {
10      public static void main(String[] args)
11      {
12         Scanner in = new Scanner(System.in);
13
14         System.out.print("How many numbers do you need to draw? ");
15         int k = in.nextInt();
16
17         System.out.print("What is the highest number you can draw? ");
18         int n = in.nextInt();
19
20         /*
21          * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
22          */
23
24         int lotteryOdds = 1;
25         for (int i = 1; i <= k; i++)
26            lotteryOdds = lotteryOdds * (n - i + 1) / i;
27
28         System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");
29      }
30   }

For example, if you set up a menu system with four alternatives like that in Figure 3.13, you could use code that looks like this:

Click here to view code image

Scanner in = new Scanner(System.in);
System.out.print("Select an option (1, 2, 3, 4) ");
int choice = in.nextInt();
switch (choice)
{
   case 1:
      ...
      break;
   case 2:
      ...
      break;
   case 3:
      ...
      break;
   case 4:
      ...
      break;
   default:
      // bad input
      ...
      break;
}

Figure 3.13 Flowchart for the switch statement

A case label can be

• A constant expression of type char, byte, short, or int

• An enumerated constant

• Starting with Java SE 7, a string literal

For example,

Click here to view code image

String input = . . .;
switch (input.toLowerCase())
{
   case "yes": // OK since Java SE 7
      ...
      break;
   ...
}

When you use the switch statement with enumerated constants, you need not supply the name of the enumeration in each label—it is deduced from the switch value. For example:

Click here to view code image

Size sz = . . .;
switch (sz)
{
   case SMALL: // no need to use Size.SMALL
      ...
      break;
   ...
}

Click here to view code image

while (years <= 100)
{
   balance += payment;
   double interest = balance * interestRate / 100;
   balance += interest;
   if (balance >= goal) break;
   years++;
}

Now the loop is exited if either years > 100 occurs at the top of the loop or balance >= goal occurs in the middle of the loop. Of course, you could have computed the same value for years without a break, like this:

Click here to view code image

while (years <= 100 && balance < goal)
{
   balance += payment;
   double interest = balance * interestRate / 100;
   balance += interest;
   if (balance < goal)
      years++;
}

But note that the test balance < goal is repeated twice in this version. To avoid this repeated test, some programmers prefer the break statement.

Unlike C++, Java also offers a labeled break statement that lets you break out of multiple nested loops. Occasionally something weird happens inside a deeply nested loop. In that case, you may want to break completely out of all the nested loops. It is inconvenient to program that simply by adding extra conditions to the various loop tests.

Here’s an example that shows the break statement at work. Notice that the label must precede the outermost loop out of which you want to break. It also must be followed by a colon.

Click here to view code image

Scanner in = new Scanner(System.in);
int n;
read_data:
while (. . .) // this loop statement is tagged with the label
{
   ...
   for (. . .) // this inner loop is not labeled
   {
      System.out.print("Enter a number >= 0: ");
      n = in.nextInt();
      if (n < 0) // should never happen—can't go on
         break read_data;
         // break out of read_data loop
      ...
   }
}
// this statement is executed immediately after the labeled break
if (n < 0) // check for bad situation
{
   // deal with bad situation
}
else
{
   // carry out normal processing
}

If there is a bad input, the labeled break moves past the end of the labeled block. As with any use of the break statement, you then need to test whether the loop exited normally or as a result of a break.

Finally, there is a continue statement that, like the break statement, breaks the regular flow of control. The continue statement transfers control to the header of the innermost enclosing loop. Here is an example:

Click here to view code image

Scanner in = new Scanner(System.in);
while (sum < goal)
{
   System.out.print("Enter a number: ");
   n = in.nextInt();
   if (n < 0) continue;
   sum += n; // not executed if n < 0
}

If n < 0, then the continue statement jumps immediately to the loop header, skipping the remainder of the current iteration.

If the continue statement is used in a for loop, it jumps to the “update” part of the for loop. For example:

Click here to view code image

for (count = 1; count <= 100; count++)
{
   System.out.print("Enter a number, -1 to quit: ");
   n = in.nextInt();
   if (n < 0) continue;
   sum += n; // not executed if n < 0
}

If n < 0, then the continue statement jumps to the count++ statement.

There is also a labeled form of the continue statement that jumps to the header of the loop with the matching label.

Use the static valueOf method to turn an ordinary number into a big number:

Click here to view code image

BigInteger a = BigInteger.valueOf(100);

Unfortunately, you cannot use the familiar mathematical operators such as + and * to combine big numbers. Instead, you must use methods such as add and multiply in the big number classes.

Click here to view code image

BigInteger c = a.add(b); // c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b + 2)

Listing 3.6 shows a modification of the lottery odds program of Listing 3.5, updated to work with big numbers. For example, if you are invited to participate in a lottery in which you need to pick 60 numbers out of a possible 490 numbers, you can use this program to tell you your odds of winning. They are 1 in 716395843461995557415116222540092933411717612789263493493351013459481104668848. Good luck!

The program in Listing 3.5 computed the statement

Click here to view code image

lotteryOdds = lotteryOdds * (n - i + 1) / i;

When big numbers are used, the equivalent statement becomes

Click here to view code image

lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + 1)).divide(BigInteger.valueOf(i));

Listing 3.6 BigIntegerTest/BigIntegerTest.java

Click here to view code image

 1   import java.math.*;
 2   import java.util.*;
 3
 4   /**
 5    * This program uses big numbers to compute the odds of winning the grand prize in a lottery.
 6    * @version 1.20 2004-02-10
 7    * @author Cay Horstmann
 8    */
 9   public class BigIntegerTest
10   {
11      public static void main(String[] args)
12      {
13         Scanner in = new Scanner(System.in);
14
15         System.out.print("How many numbers do you need to draw? ");
16         int k = in.nextInt();
17
18         System.out.print("What is the highest number you can draw? ");
19         int n = in.nextInt();
20
21         /*
22          * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
23          */
24
25         BigInteger lotteryOdds = BigInteger.valueOf(1);
26
27         for (int i = 1; i <= k; i++)
28            lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + 1)).divide(
29                  BigInteger.valueOf(i));
30
31         System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");
32      }
33   }

Click here to view code image

int[] a = new int[100];
for (int i = 0; i < 100; i++)
   a[i] = i; // fills the array with numbers 0 to 99

When you create an array of numbers, all elements are initialized with zero. Arrays of boolean are initialized with false. Arrays of objects are initialized with the special value null, which indicates that they do not (yet) hold any objects. This can be surprising for beginners. For example,

Click here to view code image

String[] names = new String[10];

creates an array of ten strings, all of which are null. If you want the array to hold empty strings, you must supply them:

Click here to view code image

for (int i = 0; i < 10; i++) names[i] = "";

To find the number of elements of an array, use array.length. For example:

Click here to view code image

for (int i = 0; i < a.length; i++)
   System.out.println(a[i]);

Once you create an array, you cannot change its size (although you can, of course, change an individual array element). If you frequently need to expand the size of an array while your program is running, you should use a different data structure called an array list. (See Chapter 5 for more on array lists.)

Click here to view code image

for (variable : collection) statement

sets the given variable to each element of the collection and then executes the statement (which, of course, may be a block). The collection expression must be an array or an object of a class that implements the Iterable interface, such as ArrayList. We discuss array lists in Chapter 5 and the Iterable interface in Chapter 9.

For example,

Click here to view code image

for (int element : a)
   System.out.println(element);

prints each element of the array a on a separate line.

You should read this loop as “for each element in a”. The designers of the Java language considered using keywords, such as foreach and in. But this loop was a late addition to the Java language, and in the end nobody wanted to break the old code that already contained methods or variables with these names (such as System.in).

Of course, you could achieve the same effect with a traditional for loop:

Click here to view code image

for (int i = 0; i < a.length; i++)
   System.out.println(a[i]);

However, the “for each” loop is more concise and less error-prone, as you don’t have to worry about those pesky start and end index values.

The “for each” loop is a pleasant improvement over the traditional loop if you need to process all elements in a collection. However, there are still plenty of opportunities to use the traditional for loop. For example, you might not want to traverse the entire collection, or you may need the index value inside the loop.

Click here to view code image

int[] smallPrimes = { 2, 3, 5, 7, 11, 13 };

Notice that you do not call new when you use this syntax.

You can even initialize an anonymous array:

Click here to view code image

new int[] { 17, 19, 23, 29, 31, 37 }

This expression allocates a new array and fills it with the values inside the braces. It counts the number of initial values and sets the array size accordingly. You can use this syntax to reinitialize an array without creating a new variable. For example,

Click here to view code image

smallPrimes = new int[] { 17, 19, 23, 29, 31, 37 };

is shorthand for

Click here to view code image

int[] anonymous = { 17, 19, 23, 29, 31, 37 };
smallPrimes = anonymous;

Click here to view code image

int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

Figure 3.14 shows the result. If you actually want to copy all values of one array into a new array, you use the copyOf method in the Arrays class:

Click here to view code image

int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);

Figure 3.14 Copying an array variable

Click here to view code image

luckyNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);

The additional elements are filled with 0 if the array contains numbers, false if the array contains boolean values. Conversely, if the length is less than the length of the original array, only the initial values are copied.

Click here to view code image

public class Message
{
   public static void main(String[] args)
   {
      if (args.length == 0 || args[0].equals("-h"))
         System.out.print("Hello,");
      else if (args[0].equals("-g"))
         System.out.print("Goodbye,");
      // print the other command-line arguments
      for (int i = 1; i < args.length; i++)
         System.out.print(" " + args[i]);
      System.out.println("!");
   }
}

If the program is called as

java Message -g cruel world

then the args array has the following contents:

args[0]: "-g"
args[1]: "cruel"
args[2]: "world"

The program prints the message

Goodbye, cruel world!

The program in Listing 3.7 puts arrays to work. This program draws a random combination of numbers for a lottery game. For example, if you play a “choose 6 numbers from 49” lottery, the program might print this:

Click here to view code image

Bet the following combination. It'll make you rich!
   4
   7
   8
   19
   30
   44

To select such a random set of numbers, we first fill an array numbers with the values 1, 2, . . ., n:

Click here to view code image

int[] numbers = new int[n];
for (int i = 0; i < numbers.length; i++)
   numbers[i] = i + 1;

A second array holds the numbers to be drawn:

int[] result = new int[k];

Now we draw k numbers. The Math.random method returns a random floating-point number that is between 0 (inclusive) and 1 (exclusive). By multiplying the result with n, we obtain a random number between 0 and n – 1.

Click here to view code image

int r = (int) (Math.random() * n);

We set the ith result to be the number at that index. Initially, that is just r + 1, but as you’ll see presently, the contents of the numbers array are changed after each draw.

result[i] = numbers[r];

Now we must be sure never to draw that number again—all lottery numbers must be distinct. Therefore, we overwrite numbers[r] with the last number in the array and reduce n by 1.

numbers[r] = numbers[n - 1];
n--;

Listing 3.7 LotteryDrawing/LotteryDrawing.java

Click here to view code image

 1   import java.util.*;
 2
 3   /**
 4    * This program demonstrates array manipulation.
 5    * @version 1.20 2004-02-10
 6    * @author Cay Horstmann
 7    */
 8   public class LotteryDrawing
 9   {
10      public static void main(String[] args)
11      {
12         Scanner in = new Scanner(System.in);
13
14         System.out.print("How many numbers do you need to draw? ");
15         int k = in.nextInt();
16
17         System.out.print("What is the highest number you can draw? ");
18         int n = in.nextInt();
19
20         // fill an array with numbers 1 2 3 . . . n
21         int[] numbers = new int[n];
22         for (int i = 0; i < numbers.length; i++)
23             numbers[i] = i + 1;
24
25         // draw k numbers and put them into a second array
26         int[] result = new int[k];
27         for (int i = 0; i < result.length; i++)
28         {
29            // make a random index between 0 and n - 1
30            int r = (int) (Math.random() * n);
31
32            // pick the element at the random location
33            result[i] = numbers[r];
34
35            // move the last element into the random location
36            numbers[r] = numbers[n - 1];
37            n--;
38         }
39
40         // print the sorted array
41         Arrays.sort(result);
42         System.out.println("Bet the following combination. It'll make you rich!");
43         for (int r : result)
44            System.out.println(r);
45      }
46   }

---

java.util.Arrays 1.2

• static String toString(type[] a) 5.0

returns a string with the elements of a, enclosed in brackets and delimited by commas.

• static type[] copyOf(type[] a, int length) 6

• static type[] copyOfRange(type[] a, int start, int end) 6

returns an array of the same type as a, of length either length or end - start, filled with the values of a.

• static void sort(type[] a)

sorts the array, using a tuned QuickSort algorithm.

• static int binarySearch(type[] a, type v)

• static int binarySearch(type[] a, int start, int end, type v) 6

Uses the binary search algorithm to search for the value v. If it is found, its index is returned. Otherwise, a negative value r is returned; -r - 1 is the spot at which v should be inserted to keep a sorted.

• static void fill(type[] a, type v)

Sets all elements of the array to v.

• static boolean equals(type[] a, type[] b)

Returns true if the arrays have the same length and if the elements in corresponding indexes match.

---

Suppose you want to make a table of numbers that shows how much an investment of $10,000 will grow under different interest rate scenarios in which interest is paid annually and reinvested (Table 3.8).

Table 3.8 Growth of an Investment at Different Interest Rates

You cannot use the array until you initialize it. In this case, you can do the initialization as follows:

Click here to view code image

balances = new double[NYEARS][NRATES];

In other cases, if you know the array elements, you can use a shorthand notation for initializing a multidimensional array without a call to new. For example:

int[][] magicSquare =
   {
      {16, 3, 2, 13},
      {5, 10, 11, 8},
      {9, 6, 7, 12},
      {4, 15, 14, 1}
   };

Once the array is initialized, you can access individual elements by supplying two pairs of brackets—for example, balances[i][j].

The example program stores a one-dimensional array interest of interest rates and a two-dimensional array balances of account balances, one for each year and interest rate. We initialize the first row of the array with the initial balance:

Click here to view code image

for (int j = 0; j < balances[0].length; j++)
   balances[0][j] = 10000;

Then we compute the other rows, as follows:

Click here to view code image

for (int i = 1; i < balances.length; i++)
{
   for (int j = 0; j < balances[i].length; j++)
   {
      double oldBalance = balances[i - 1][j];
      double interest = . . .;
      balances[i][j] = oldBalance + interest;
   }
}

Listing 3.8 shows the full program.

Listing 3.8 CompoundInterest/CompoundInterest.java

Click here to view code image

 1   /**
 2    * This program shows how to store tabular data in a 2D array.
 3    * @version 1.40 2004-02-10
 4    * @author Cay Horstmann
 5    */
 6   public class CompoundInterest
 7   {
 8      public static void main(String[] args)
 9      {
10         final double STARTRATE = 10;
11         final int NRATES = 6;
12         final int NYEARS = 10;
13
14         // set interest rates to 10 . . . 15%
15         double[] interestRate = new double[NRATES];
16         for (int j = 0; j < interestRate.length; j++)
17            interestRate[j] = (STARTRATE + j) / 100.0;
18
19         double[][] balances = new double[NYEARS][NRATES];
20
21         // set initial balances to 10000
22         for (int j = 0; j < balances[0].length; j++)
23            balances[0][j] = 10000;
24
25         // compute interest for future years
26         for (int i = 1; i < balances.length; i++)
27         {
28            for (int j = 0; j < balances[i].length; j++)
29            {
30               // get last year's balances from previous row
31               double oldBalance = balances[i - 1][j];
32
33               // compute interest
34               double interest = oldBalance * interestRate[j];
35
36               // compute this year's balances
37               balances[i][j] = oldBalance + interest;
38            }
39         }
40
41         // print one row of interest rates
42         for (int j = 0; j < interestRate.length; j++)
43            System.out.printf("%9.0f%%", 100 * interestRate[j]);
44
45         System.out.println();
46
47         // print balance table
48         for (double[] row : balances)
49         {
50            // print table row
51            for (double b : row)
52               System.out.printf("%10.2f", b);
53
54             System.out.println();
55         }
56      }
57   }

For example, the balances array in the preceding example is actually an array that contains ten elements, each of which is an array of six floating-point numbers (Figure 3.15).

Figure 3.15 A two-dimensional array

The expression balances[i] refers to the ith subarray—that is, the ith row of the table. It is itself an array, and balances[i][j] refers to the jth element of that array.

Click here to view code image

double[] temp = balances[i];
balances[i] = balances[i + 1];
balances[i + 1] = temp;

It is also easy to make “ragged” arrays—that is, arrays in which different rows have different lengths. Here is the standard example. Let us make an array in which the element at row i and column j equals the number of possible outcomes of a “choose j numbers from i numbers” lottery.

1
1 1
1 2  1
1 3  3  1
1 4  6  4  1
1 5 10 10  5 1
1 6 15 20 15 6 1

As j can never be larger than i, the matrix is triangular. The ith row has i + 1 elements. (We allow choosing 0 elements; there is one way to make such a choice.) To build this ragged array, first allocate the array holding the rows.

Click here to view code image

int[][] odds = new int[NMAX + 1][];

Next, allocate the rows.

Click here to view code image

for (int n = 0; n <= NMAX; n++)
   odds[n] = new int[n + 1];

Now that the array is allocated, we can access the elements in the normal way, provided we do not overstep the bounds.

Click here to view code image

for (int n = 0; n < odds.length; n++)
   for (int k = 0; k < odds[n].length; k++)
   {
      // compute lotteryOdds
      ...
      odds[n][k] = lotteryOdds;
   }

Listing 3.9 gives the complete program.

Listing 3.9 LotteryArray/LotteryArray.java

Click here to view code image

 1   /**
 2    * This program demonstrates a triangular array.
 3    * @version 1.20 2004-02-10
 4    * @author Cay Horstmann
 5    */
 6   public class LotteryArray
 7   {
 8      public static void main(String[] args)
 9      {
10         final int NMAX = 10;
11
12         // allocate triangular array
13         int[][] odds = new int[NMAX + 1][];
14         for (int n = 0; n <= NMAX; n++)
15            odds[n] = new int[n + 1];
16
17         // fill triangular array
18         for (int n = 0; n < odds.length; n++)
19            for (int k = 0; k < odds[n].length; k++)
20            {
21               /*
22                * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
23                */
24               int lotteryOdds = 1;
25               for (int i = 1; i <= k; i++)
26                  lotteryOdds = lotteryOdds * (n - i + 1) / i;
27
28               odds[n][k] = lotteryOdds;
29            }
30
31         // print triangular array
32         for (int[] row : odds)
33         {
34            for (int odd : row)
35               System.out.printf("%4d", odd);
36            System.out.println();
37         }
38      }
39   }

You have now seen the fundamental programming structures of the Java language. The next chapter covers object-oriented programming in Java.