At this point, you have dealt with only a few variables in each Java program. In some cases, it’s manageable to use individual variables to store information, but what if you had 20 items of related information to track? You could create 20 different variables and set up their initial values, but that approach becomes progressively more cumbersome as you deal with larger amounts of information. What if there were 100 items, or even 1,000?

Arrays are a way to store a list of items that have the same primitive data type, the same class, or a common parent class. Each item on the list goes into its own numbered slot so that you can easily access the information.

Arrays can contain any type of information that is stored in a variable, but after the array is created, you can use it for that information type only. For example, you can have an array of integers, an array of String objects, or an array of arrays, but you can’t have an array that contains both String objects and integers.

Java implements arrays differently than some other languages do—as objects treated like other objects.

To create an array in Java, you must do the following:

String[] requests;

Point[] targets;

float[] donations;

String requests[];

Point targets[];

float donations[];

String[] players = new String[10];

int[] temps = new int[99];

Integer[] series = new Integer[3];
series[0] = new Integer(10);
series[1] = new Integer(3);
series[2] = new Integer(5);

Point[] markup = { new Point(1,5), new Point(3,3), new Point(2,3) };

String[] titles = { "Mr.", "Mrs.", "Ms.", "Miss", "Dr." };

testScore[40] = 920;

float[] rating = new float[20];
rating[20] = 3.22F;

System.out.println("Elements: " + rating.length);

temperature[4] = 85;

day[0] = "Sunday";

manager[2] = manager[0];

 1: class HalfDollars {
 2:     public static void main(String[] arguments) {
 3:         int[] denver = { 2500000, 2900000, 3500000  };
 4:         int[] philadelphia = new int[denver.length];
 5:         int[] total = new int[denver.length];
 6:         int average;
 7:
 8:          philadelphia[0] = 2500000;
 9:          philadelphia[1] = 2900000;
10:          philadelphia[2] = 3800000;
11:
12:          total[0] = denver[0] + philadelphia[0];
13:          total[1] = denver[1] + philadelphia[1];
14:          total[2] = denver[2] + philadelphia[2];
15:          average = (total[0] + total[1] + total[2]) / 3;
16:
17:          System.out.print("2003 production: ");
18:          System.out.format("%,d%n", total[0]);
19:          System.out.print("2004 production: ");
20:          System.out.format("%,d%n", total[1]);
21:          System.out.print("2005 production: ");
22:          System.out.format("%,d%n", total[2]);
23:          System.out.print("Average production: ");
24:          System.out.format("%,d%n", average);
25:     }
26: }

2003 production: 5,000,000
2004 production: 5,800,000
2005 production: 7,300,000
Average production: 6,033,333

int[][] dayValue = new int[52][7];

dayValue[9][0] = 14200;

int[][][] century = new int[100][52][7];
System.out.println("Elements in the first dimension: " + century.length);
System.out.println("Elements in the second dimension: " + century[0].length);
System.out.println("Elements in the third dimension: " + century[0][0].length);

Statements in Java are grouped into blocks. The beginning and ending boundaries of a block are noted with brace characters—an opening brace ({) for the beginning and a closing brace (}) for the ending.

At this point, you have used blocks to hold the variables and methods in a class definition and define statements that belong in a method.

Blocks also are called block statements because an entire block can be used anywhere a single statement could be used (they’re called compound statements in C and other languages). Each statement inside the block is then executed from top to bottom.

You can put blocks inside other blocks, just as you do when you put a method inside a class definition.

An important thing to note about using a block is that it creates a scope for the local variables created inside the block.

Scope is the part of a program in which a variable exists and can be used. If you try to use a variable outside its scope, an error occurs.

In Java, the scope of a variable is the block in which it was created. When you can declare and use local variables inside a block, those variables cease to exist after the block is finished executing. For example, the following testBlock() method contains a block:

void testBlock() {
    int x = 10;
    { // start of block
        int y = 40;
        y = y + x;
    } // end of block
}

Two variables are defined in this method: x and y. The scope of the y variable is the block it’s in, which is noted with the start of block and end of block comments.

The variable can be used only within that block. An error would result if you tried to use the y variable in another part of the testBlock() method.

The x variable was created inside the method but outside the inner block, so it can be used anywhere in the method. You can modify the value of x anywhere within the method.

Block statements usually are not used alone within a method definition, as they are in the preceding example. You use them throughout class and method definitions, as well as in the logic and looping structures you learn about next.

A key aspect of any programming language is how it enables a program to make decisions. This is handled through a special type of statement called a conditional.

A conditional is a programming statement executed only if a specific condition is met.

The most basic conditional in Java is the if keyword. The if conditional uses a Boolean expression to decide whether a statement should be executed. If the expression produces a true value, the statement is executed.

Here’s a simple example that displays the message "Not enough arguments" on only one condition: If the value of the arguments.length instance variable is less than 3

if (arguments.length < 3)
   System.out.println("Not enough arguments");

If you want something else to happen when an if expression produces a false value, an optional else keyword can be used. The following example uses both if and else:

String server;
if (arguments.length < 1)
    server = "localhost";
else
    server = arguments[0];

The if conditional executes different statements based on the result of a single Boolean test.

Using if, you can include only a single statement as the code to execute if the test expression is true and another statement if the expression is false.

However, as you learned earlier today, a block can appear anywhere in Java that a single statement can appear. If you want to do more than one thing as a result of an if statement, you can enclose those statements inside a block. Note the following snippet of code, which was used on Day 1, “Getting Started with Java”:

if (temperature > 660) {
    status = "returning home";
    speed = 5;
}

The if statement in this example contains the test expression temperature > 660. If the temperature variable contains a value higher than 660, the block statement is executed, and two things occur:

If the temperature variable is equal to or less than 660, the entire block is skipped, so nothing happens.

All if and else statements use Boolean tests to determine whether statements are executed. You can use a boolean variable itself for this test, as in the following:

if (outOfGas)
    status = "inactive";

The preceding example uses a boolean variable called outOfGas. It functions exactly like the following:

if (outOfGas == true)
    status = "inactive";

A common programming practice is to test a variable against a value, and if it doesn’t match, test it again against a different value, and so on.

This approach can become unwieldy if you’re using only if statements, depending on how many different values you have to test. For example, you might end up with a set of if statements something like the following:

if (operation == '+')
   add(object1, object2);
else if (operation == '-')
    subtract(object1, object2);
else if (operation == '*')
    multiply(object1, object2);
else if (operation == '/')
    divide(object1, object2);

This use of if statements is called a nested if statement because each else statement contains another if until all possible tests have been made.

In some languages, a shorthand mechanism that you can use for nested if statements is to group tests and actions together in a single statement. In Java, you can group actions together with the switch statement. The following example demonstrates switch usage:

switch (grade) {
    case 'A':
        System.out.println('Great job!");
        break;
    case 'B':
        System.out.println('Good job!");
        break;
    case 'C':
        System.out.println('You can do better!");
        break;
    default:
        System.out.println('Consider cheating!");
}

A switch statement is built on a test variable; in the preceding example, the variable is the value of the grade variable, which holds a char value.

The test variable, which can be the primitive types byte, char, short, or int, is compared in turn with each of the case values. If a match is found, the statement or statements after the test are executed.

If no match is found, the default statement or statements are executed. Providing a default statement is optional—if it is omitted and there is no match for any of the case statements, the switch statement might complete without executing anything.

The Java implementation of switch is limited—tests and values can be only simple primitive types that can be cast to an int. You cannot use larger primitive types such as long or float, strings, or other objects within a switch, nor can you test for any relationship other than equality. These restrictions limit switch to the simplest cases. In contrast, nested if statements can work for any kind of test on any possible type.

The following is a revision of the nested if example shown previously. It has been rewritten as a switch statement:

switch (operation) {
    case '+':
        add(object1, object2);
        break;
    case '-':
        subtract(object1, object2);
        break;
    case '*':
        multiply(object1, object2);
        break;
    case '/':
        divide(object1, object2);
        break;
}

After each case, you can include a single result statement or as many as you need. Unlike with if statements, multiple statements don’t require a block statement.

The break statement included with each case section determines when to stop executing statements in response to a matching case. Without a break statement in a case section, after a match is made, the statements for that match and all the statements further down the switch are executed until a break or the end of the switch is found.

In some situations, this might be exactly what you want to do. Otherwise, you should include break statements to ensure that only the right code is executed. The break statement, which you use again later in the section “Breaking Out of Loops,” stops execution at the current point and jumps to the statement after the closing brace that ends the switch statement.

One handy use of falling through without a break occurs when multiple values need to execute the same statements. To accomplish this task, you can use multiple case lines with no result; the switch executes the first statement that it finds.

For example, in the following switch statement, the string x is an even number is printed if x has the values of 2, 4, 6, or 8. All other values of x cause the string x is an odd number to be printed.

switch (x) {
    case 2:
    case 4:
    case 6:
    case 8:
       System.out.println("x is an even number");
       break;
    default: System.out.println("x is an odd number");
}

In Listing 4.2, the DayCounter application takes two arguments, a month and a year, and displays the number of days in that month. A switch statement, if statements, and else statements are used.

 1: class DayCounter {
 2:     public static void main(String[] arguments) {
 3:         int yearIn = 2008;
 4:         int monthIn = 1;
 5:         if (arguments.length > 0)
 6:             monthIn = Integer.parseInt(arguments[0]);
 7:         if (arguments.length > 1)
 8:             yearIn = Integer.parseInt(arguments[1]);
 9:         System.out.println(monthIn + "/" + yearIn + " has "
10:             + countDays(monthIn, yearIn) + " days.");
11:      }
12:
13:     static int countDays(int month, int year) {
14:         int count = -1;
15:         switch (month) {
16:             case 1:
17:             case 3:
18:             case 5:
19:             case 7:
20:             case 8:
21:             case 10:
22:             case 12:
23:                 count = 31;
24:                 break;
25:             case 4:
26:             case 6:
27:             case 9:
28:             case 11:
29:                 count = 30;
30:                 break;
31:             case 2:
32:                 if (year % 4 == 0)
33:                     count = 29;
34:                 else
35:                     count = 28;
36:                 if ((year % 100 == 0) & (year % 400 != 0))
37:                     count = 28;
38:        }
39:        return count;
40:     }
41: }

This application uses command-line arguments to specify the month and year to check. The first argument is the month, which should be expressed as a number from 1 to 12. The second argument is the year, which should be expressed as a full four-digit year.

After compiling the program, type the following at a command line to see the number of days in April 2008:

java DayCounter 4 2008

The output is the following:

4/2008 has 30 days.

If you run it without arguments, the default month of January 2008 is used, and the output is the following:

1/2008 has 31 days.

The DayCounter application uses a switch statement to count the days in a month. This statement is part of the countDays() method in lines 13–40 of Listing 4.2.

The countDays() method has two int arguments: month and year. The number of days is stored in the count variable, which is given an initial value of -1 that is replaced by the correct count later.

The switch statement that begins on line 15 uses month as its conditional value.

The number of days in a month is easy to determine for 11 months of the year. January, March, May, July, August, October, and December have 31 days. April, June, September, and November have 30 days.

The count for these 11 months is handled in lines 16–30 of Listing 4.2. Months are numbered from 1 (January) to 12 (December), as you would expect. When one of the case statements has the same value as month, every statement after that is executed until break or the end of the switch statement is reached.

February is a little more complex and is handled in lines 31–37 of the program. Every leap year has 29 days in February, whereas other years have 28. A leap year must meet either of the following conditions:

As you learned on Day 2, “The ABCs of Programming,” the modulus operator % returns the remainder of a division operation. This is used with several if-else statements to determine how many days there are in February, depending on what year it is.

The if-else statement in lines 32–35 sets count to 29 when the year is evenly divisible by 4 and sets it to 28 otherwise.

The if statement in lines 36–37 uses the & operator to combine two conditional expressions: year % 100 == 0 and year % 400 != 0. If both these conditions are true, count is set to 28.

The countDays method ends by returning the value of count in line 39.

When you run the DayCounter application, the main() method in lines 2–11 is executed.

In all Java applications, command-line arguments are stored in an array of String objects. This array is called arguments in DayCounter. The first command-line argument is stored in argument[0], the second in argument[1], and upward until all arguments have been stored. If the application is run with no arguments, the array is created with no elements.

Lines 3–4 create yearIn and monthIn, two integer variables to store the year and month that should be checked.

The if statement in line 5 uses arguments.length to make sure that the arguments array has at least one element. If it does, line 6 is executed.

Line 6 calls parseInt(), a class method of the Integer class, with argument[0] as an argument. This method takes a String object as an argument, and if the string could be a valid integer, it returns that value as an int. This converted value is stored in monthIn. A similar thing happens in line 7; parseInt() is called with argument[1], and this is used to set yearIn.

The output of the program is displayed in lines 9–11. As part of the output, the countDays() method is called with monthIn and yearIn, and the value returned by this method is displayed.

A for loop is used to repeat a statement until a condition is met. Although for loops frequently are used for simple iteration in which a statement is repeated a certain number of times, for loops can be used for just about any kind of loop.

The for loop in Java looks roughly like the following:

for (initialization; test;increment) {
    statement;
}

The start of the for loop has three parts:

The statement part of the for loop is the statement that is executed each time the loop iterates. As with if, you can include either a single statement or a block statement. The previous example used a block because that is more common. The following example is a for loop that sets all slots of a String array to the value Mr.:

String[] salutation = new String[10];
int i; // the loop index variable

for (i = 0; i < salutation.length; i++)
    salutation[i] = "Mr.";

In this example, the variable i serves as a loop index; it counts the number of times the loop has been executed. Before each trip through the loop, the index value is compared with salutation.length, the number of elements in the salutation array. When the index is equal to or greater than salutation.length, the loop is exited.

The final element of the for statement is i++. This causes the loop index to increment by 1 each time the loop is executed. Without this statement, the loop would never stop.

The statement inside the loop sets an element of the salutation array equal to "Mr.". The loop index is used to determine which element is modified.

Any part of the for loop can be an empty statement; in other words, you can include a semicolon with no expression or statement, and that part of the for loop is ignored. Note that if you do use an empty statement in your for loop, you might have to initialize or increment any loop variables or loop indexes yourself elsewhere in the program.

You also can have an empty statement as the body of your for loop if everything you want to do is in the first line of that loop. For example, the following for loop finds the first prime number higher than 4,000. (It employs a method called notPrime(), which returns a Boolean value, presumably to indicate when i is not prime.)

for (i = 4001; notPrime(i); i += 2)
;

A common mistake in for loops is to accidentally put a semicolon at the end of the line that includes the for statement:

for (i = 0; i < 10; i++);
    x = x * i; // this line is not inside the loop!

In this example, the first semicolon ends the loop without executing x = x * i as part of the loop. The x = x * i line is executed only once because it is outside the for loop entirely. Be careful not to make this mistake in your Java programs.

The next project you undertake is a rewrite of the HalfDollar application that uses for loops to remove redundant code.

The original application works only with an array that is three elements long. The new version, shown in Listing 4.3, is shorter and more flexible (but it returns the same output).

 1: class HalfLooper {
 2:     public static void main(String[] arguments) {
 3:         int[] denver = { 2500000, 2900000, 3500000 };
 4:         int[] philadelphia = { 2500000, 2900000, 3800000 };
 5:         int[] total = new int[denver.length];
 6:         int sum = 0;
 7:
 8:         for (int i = 0; i < denver.length; i++) {
 9:             total[i] = denver[i] + philadelphia[i];
10:             System.out.format((i + 2003) + " production: %,d%n",
11:                 total[i]);
12:             sum += total[i];
13:         }
14:
15:         System.out.format("Average production: %,d%n",
16:             (sum / denver.length));
17:     }
18: }

The output of the program is as follows:

2003 production: 5,000,000
2004 production: 5,800,000
2005 production: 7,300,000
Average production: 6,033,333

Instead of going through the elements of the three arrays one by one, this example uses a for loop. The following things take place in the loop, which is contained in lines 8–13 of Listing 4.3:

Using a more general-purpose loop to iterate over an array enables you to use the program with arrays of different sizes and still have it assign correct values to the elements of the total array and display those values.

The remaining types of loops are while and do. As with for loops, while and do loops enable a block of Java code to be executed repeatedly until a specific condition is met. Whether you use a for, while, or do loop is mostly a matter of your programming style.

while (i < 13) {
    x = x * i++; // the body of the loop
}

 1: class ArrayCopier {
 2:     public static void main(String[] arguments) {
 3:         int[] array1 = { 7, 4, 8, 1, 4, 1, 4 };
 4:         float[] array2 = new float[array1.length];
 5:
 6:         System.out.print("array1: [ ");
 7:         for (int i = 0; i < array1.length; i++) {
 8:            System.out.print(array1[i] + " ");
 9:         }
10:         System.out.println("]");
11:
12:         System.out.print("array2: [ ");
13:         int count = 0;
14:         while ( count < array1.length && array1[count] != 1) {
15:             array2[count] = (float) array1[count];
16:             System.out.print(array2[count++] + " ");
17:         }
18:         System.out.println("]");
19:     }
20: }

array1: [ 7 4 8 1 4 1 4 ]
array2: [ 7.0 4.0 8.0 ]

long i = 1;
do {
    i *= 2;
    System.out.print(i + " ");
} while (i < 3000000000000L);

In all the loops, the loop ends when a tested condition is met. There might be times when something occurs during execution of a loop and you want to exit the loop early. In that case, you can use the break and continue keywords.

You already have seen break as part of the switch statement; break stops execution of the switch statement, and the program continues. The break keyword, when used with a loop, does the same thing—it immediately halts execution of the current loop. If you have nested loops within loops, execution picks up with the next outer loop. Otherwise, the program simply continues executing the next statement after the loop.

For example, recall the while loop that copied elements from an integer array into an array of floating-point numbers until either the end of the array or a 1 was reached. You can test for the latter case inside the body of the while loop and then use break to exit the loop:

int count = 0;
while (count < array1.length) {
    if (array1[count] == 1)
        break;
    array2[count] = (float) array1[count++];
}

The continue keyword starts the loop over at the next iteration. For do and while loops, this means that the execution of the block statement starts over again; with for loops, the increment expression is evaluated, and then the block statement is executed.

The continue keyword is useful when you want to make a special case out of elements within a loop. With the previous example of copying one array to another, you could test for whether the current element is equal to 1 and use continue to restart the loop after every 1 so that the resulting array never contains zero. Note that because you’re skipping elements in the first array, you now have to keep track of two different array counters:

int count = 0;
int count2 = 0;
while (count++ <= array1.length) {
    if (array1[count] == 1)
       continue;
    array2[count2++] = (float)array1[count];
}

out:
    for (int i = 0; i <10; i++) {
        while (x < 50) {
            if (i * x++ > 400)
                break out;
            // inner loop here
        }
        // outer loop here
    }

test ? trueresult : falseresult;

int ourBestScore = myScore > yourScore ? myScore : yourScore;

int ourBestScore;
if (myScore > yourScore)
   ourBestScore = myScore;
else
   ourBestScore = yourScore;

Now that you have been introduced to lists, loops, and logic, you can make a computer decide whether to repeatedly display the contents of an array.

You learned how to declare an array variable, assign an object to it, and access and change elements of the array. With the if and switch conditional statements, you can branch to different parts of a program based on a Boolean test. You learned about the for, while, and do loops, and you learned that each enables a portion of a program to be repeated until a given condition is met.

It bears repeating: You’ll use all three of these features frequently in your Java programs.

You’ll use all three of these features frequently in your Java programs.

Review today’s material by taking this three-question quiz.

public class Cases {
    public static void main(String[] arguments) {
        float x = 9;
        float y = 5;
        int z = (int)(x / y);
        switch (z) {
            case 1:
                x = x + 2;
            case 2:
                x = x + 3;
            default:
                x = x + 1;
        }
        System.out.println("Value of x: " + x);
    }
}

To extend your knowledge of the subjects covered today, try the following exercises:

Where applicable, exercise solutions are offered on the book’s website at http://www.java21days.com.