Fundamentals of Java Programming

Nicko V.

doi:10.1007/978-3-319-89491-1

Fundamentals of Java Programming

Nicko V.

2017

https://doi.org/10.1007/978-3-319-89491-1

visibility

…

description

514 pages

link

1 file

Abstract

Fundamentals of Java Programming By Mitsunori Ogihara

Figures (401)

command according to its syntax. If the command is syntactically correct, the interface executes the
action represented by the command. When the action occurs, some characters may appear on the
screen after the command line. If there are many such characters, the text screen scrolls down to show
however many characters will fit on the screen, starting with the most recent. If the command is not
syntactically correct, the command line interface prints an error message. To inform the user that it is
ready to accept a new command, the command line interface prints a special sequence of characters,
called prompt, e.g., the “percent” symbol % followed by one white space, or the “greater than” symbol
>. Table 1.1 is a select list of commands.

7 a: a, a i a: a i ie. i soo: op | Ol ce : a? es, i: e, | ae: ja
1.2 Changing Folders in a Command Line Interface — command according to its syntax. If the command is syntactically correct, the interface executes the action represented by the command. When the action occurs, some characters may appear on the screen after the command line. If there are many such characters, the text screen scrolls down to show however many characters will fit on the screen, starting with the most recent. If the command is not syntactically correct, the command line interface prints an error message. To inform the user that it is ready to accept a new command, the command line interface prints a special sequence of characters, called prompt, e.g., the “percent” symbol % followed by one white space, or the “greater than” symbol >. Table 1.1 is a select list of commands. 7 a: a, a i a: a i ie. i soo: op | Ol ce : a? es, i: e, | ae: ja 1.2 Changing Folders in a Command Line Interface

Table 1.1 A short list of commands available in the Terminal programs for Mac OSX and Linux, as well as their
counterparts in the Windows cmd — Table 1.1 A short list of commands available in the Terminal programs for Mac OSX and Linux, as well as their counterparts in the Windows cmd

Consider the following code, which is intended to execute three print 1n statements successively.
Listing 1.5 A buggy version of the HelloWorld program. The intended class name is BuggyHelloWorlc
A syntax error is a part of source code that fails to conform to the Java syntax. If a source code
contains syntax errors, the Java compiler, instead of producing the bytecode, produces an error
message stating that there are syntax errors. If there is a bytecode generated from the prior successful
compilation, that code remains the same without being updated.

The cvntay error that 9 comniler nrodiices is 9 hit crvntic and takes cqgme exynerience to cgmnrehend. — Consider the following code, which is intended to execute three print 1n statements successively. Listing 1.5 A buggy version of the HelloWorld program. The intended class name is BuggyHelloWorlc A syntax error is a part of source code that fails to conform to the Java syntax. If a source code contains syntax errors, the Java compiler, instead of producing the bytecode, produces an error message stating that there are syntax errors. If there is a bytecode generated from the prior successful compilation, that code remains the same without being updated. The cvntay error that 9 comniler nrodiices is 9 hit crvntic and takes cqgme exynerience to cgmnrehend.

At the compilation step, we encounter the following error messages:
Each error message consists of the source file name, the line number of the error, the nature of the
error, and the actual location of the error (indicated by the caret symbol). In the case of an IDE, instead
of presenting the errors in its command line interface screen, these errors are highlighted in the source
code editor screen. — At the compilation step, we encounter the following error messages: Each error message consists of the source file name, the line number of the error, the nature of the error, and the actual location of the error (indicated by the caret symbol). In the case of an IDE, instead of presenting the errors in its command line interface screen, these errors are highlighted in the source code editor screen.

produces the following six-line output.
The program executes the six System.out.printi1n statements from top to bottom, and
produces the following six-line output.
Listing 1.6 A source code with multiple print 1n statements — produces the following six-line output. The program executes the six System.out.printi1n statements from top to bottom, and produces the following six-line output. Listing 1.6 A source code with multiple print 1n statements

Listing 1.12 A program that prints a quotation from Mark Twain’s Adventures of Huckleberry Finn
produces the following output: — Listing 1.12 A program that prints a quotation from Mark Twain’s Adventures of Huckleberry Finn produces the following output:

Listing 1.13 A program that uses squeezed print statements to produce the same quotation from Mark Twain’s
Adventures of Huckleberry Finn as before
The execution produces exactly the same result as before. — Listing 1.13 A program that uses squeezed print statements to produce the same quotation from Mark Twain’s Adventures of Huckleberry Finn as before The execution produces exactly the same result as before.

Suppose we want to print the figure of a right-angled triangle like the one appears next:

Listing 1.14 The code for producing a right-angled triangle
How about an isosceles triangle, like this one? — Listing 1.14 The code for producing a right-angled triangle How about an isosceles triangle, like this one?

Let’s try printing an isosceles upside down, as shown next:
Listing 1.15 A code for printing on the screen an isosceles triangle — Let’s try printing an isosceles upside down, as shown next: Listing 1.15 A code for printing on the screen an isosceles triangle

Listing 1.16 The code for producing an upside-down isosceles triangle on the screen

Listing 2.3. A program that produces comments about three NFL quarterbacks (part 2). The part that produces
comments about the second and the third players
For these additional two players, number literals appear in Lines 15, 20, 24 and 29. — Listing 2.3. A program that produces comments about three NFL quarterbacks (part 2). The part that produces comments about the second and the third players For these additional two players, number literals appear in Lines 15, 20, 24 and 29.

If a variable is not a constant, the value of the variable can be updated any number of times. Consider
the next code: — If a variable is not a constant, the value of the variable can be updated any number of times. Consider the next code:

[n Java, the four standard arithmetic operations in mathematics (addition, subtraction, multiplication,
and division) are represented with the standard mathematical symbols (+, -, *, and /, respectively).
[he negative sign - can be used for flipping the sign. The regular parentheses ( ) can be used for
lipping the sign. There is no symbol for representing exponentiation.

Tes oxesetamlea fie mmaemonewd kde mumnentirovae nen wallad meanness "hic ex leveace Fert coe wero lente — [n Java, the four standard arithmetic operations in mathematics (addition, subtraction, multiplication, and division) are represented with the standard mathematical symbols (+, -, *, and /, respectively). [he negative sign - can be used for flipping the sign. The regular parentheses ( ) can be used for lipping the sign. There is no symbol for representing exponentiation. Tes oxesetamlea fie mmaemonewd kde mumnentirovae nen wallad meanness "hic ex leveace Fert coe wero lente

Alternatively, the code could be written as either

Listing 2.6 A preliminary version of the program for computing values for a given radius
This code produces the following output: — Listing 2.6 A preliminary version of the program for computing values for a given radius This code produces the following output:

Listing 2.8 The code for printing the values of the four quantities. The part for calculating the quantities and printing
the results
The second part of the code is for reporting the results of the calculation. — Listing 2.8 The code for printing the values of the four quantities. The part for calculating the quantities and printing the results The second part of the code is for reporting the results of the calculation.

Listing 2.10 The radius code with the value of z as the global constant
Listing 2.9 An alternative for the calculation of values associated with a circle and a ball — Listing 2.10 The radius code with the value of z as the global constant Listing 2.9 An alternative for the calculation of values associated with a circle and a ball

The program then executes a number of operations on the variables.
Listing 2.11 A program that demonstrates the use of operators on double and/or int variables (part 1) — The program then executes a number of operations on the variables. Listing 2.11 A program that demonstrates the use of operators on double and/or int variables (part 1)

The result of executing the code is as follows:
When a literal of a primitive number type appears, its default type is int for a whole number and
double for a floating point number. To treat a data as an alternate type, attach, in front of it, the
alternate type enclosed in a matching pair of parentheses. For example, (byte) 12 instructs to treat
the int type value of 12 as a byte type. The action of attaching a data type to treat a data as <
different type is called casting. — The result of executing the code is as follows: When a literal of a primitive number type appears, its default type is int for a whole number and double for a floating point number. To treat a data as an alternate type, attach, in front of it, the alternate type enclosed in a matching pair of parentheses. For example, (byte) 12 instructs to treat the int type value of 12 as a byte type. The action of attaching a data type to treat a data as < different type is called casting.

Listing 2.12 A program that demonstrates the use of operators on double and/or int variables (part 1)

The program produces the following output:
The next code uses two variables, int myInt and double myReal, to store an integer and a
floating point number, respectively. The program computes the product of the two variables and stores
the value of the product ina doub1e variable, result. In addition, in the assignment of the product,
the program executes one of ++ or - either before or after the two variables: — The program produces the following output: The next code uses two variables, int myInt and double myReal, to store an integer and a floating point number, respectively. The program computes the product of the two variables and stores the value of the product ina doub1e variable, result. In addition, in the assignment of the product, the program executes one of ++ or - either before or after the two variables:

These actions appear in Lines 19, 35, 51, and 66.

Listing 2.18 A program that demonstrate the use of ++ and —— (part 1

Here is the code, presented in multiple parts. ++ or - appears in Lines 19, 35, 51, and 67.

Listing 2.19 A program that demonstrate the use of ++ and —— (part 2

This series of actions produces the desired output line:
To be more precise, the following code will be used: — This series of actions produces the desired output line: To be more precise, the following code will be used:

The following is the code that represents this decomposition:

“Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty,
and dedicated to the proposition that all men are created equal.” — “Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty, and dedicated to the proposition that all men are created equal.”

Fig. 3.1 The results of five consecutive calls of next. The arrows show the start positions of the Scanner object for
the next read. The sequences immediately to the left of the arrows are the tokens that have been read — Fig. 3.1 The results of five consecutive calls of next. The arrows show the start positions of the Scanner object for the next read. The sequences immediately to the left of the arrows are the tokens that have been read

All the methods in this table are usually called with an empty parameter,
ie., with () attached after the method names. We will study hasNext in
Chap. 11
Using Scanner, we can fetch the next token not only as a St ring data but also as a token of <
specific primitive data type, given that the token can be interpreted as a literal of that type. The type-
specific fetch methods are: next Boolean, nextByte, nextDouble, nextFloat, nextInt
nextLong, and nextShort. Note that there is no method corresponding to reading a char. If
one of these methods is called and the next token cannot be interpreted as the type associated witk
the method, a run-time error of InputMismatchException occurs. For example, suppose the
next token in the input sequence is - 1.0. The token can be interpreted as a double data, a float
data, and a String data, but not as a whole number data or as a boolean data. Thus, the use ot
nextBoolean, nextByte, nextDouble, nextFloat, next Int, ornextLong will fail (anc
a run-time error will subsequently appear).

Table 3.1 presents a list of Scanner methods that appear in this textbook. We will study hasNext — All the methods in this table are usually called with an empty parameter, ie., with () attached after the method names. We will study hasNext in Chap. 11 Using Scanner, we can fetch the next token not only as a St ring data but also as a token of < specific primitive data type, given that the token can be interpreted as a literal of that type. The type- specific fetch methods are: next Boolean, nextByte, nextDouble, nextFloat, nextInt nextLong, and nextShort. Note that there is no method corresponding to reading a char. If one of these methods is called and the next token cannot be interpreted as the type associated witk the method, a run-time error of InputMismatchException occurs. For example, suppose the next token in the input sequence is - 1.0. The token can be interpreted as a double data, a float data, and a String data, but not as a whole number data or as a boolean data. Thus, the use ot nextBoolean, nextByte, nextDouble, nextFloat, next Int, ornextLong will fail (anc a run-time error will subsequently appear). Table 3.1 presents a list of Scanner methods that appear in this textbook. We will study hasNext

The source of the Scanner object is the String literal

The fifth token of the input source is the String literal "17". We can treat this as either a
string type or an int (or any other number type since 17 can be represented as a byte data).
‘he delimiter sequence that follows this number token consists of five characters, represented as
' , \n_". (the double quotation marks are attached so as to clarify the beginning and the ending
f the character sequence. If the method that is called at that point is next, then the Scanner
vill skip to the next token ", ". However, if the method that is called is nextLine instead, the
'\n" appearing as the fourth character of the five-character sequence becomes the delimiter. When
his happens, the Scanner object returns " , " as the result of executing nextLine, and then
he Scanner object positions itself to the fifth character of the sequence, i.e., the " " after the
ewline. If next Line and next are called successively, the method call to next returns "how".
f next Line is called twice successively, the first call returns " , " as in the previous case, and
he second call returns the remainder of the sequence, " how about yours? ", because is no
dditional appearance of \n. Based upon this analysis, the output of the program is expected to be: — The fifth token of the input source is the String literal "17". We can treat this as either a string type or an int (or any other number type since 17 can be represented as a byte data). ‘he delimiter sequence that follows this number token consists of five characters, represented as ' , \n_". (the double quotation marks are attached so as to clarify the beginning and the ending f the character sequence. If the method that is called at that point is next, then the Scanner vill skip to the next token ", ". However, if the method that is called is nextLine instead, the '\n" appearing as the fourth character of the five-character sequence becomes the delimiter. When his happens, the Scanner object returns " , " as the result of executing nextLine, and then he Scanner object positions itself to the fifth character of the sequence, i.e., the " " after the ewline. If next Line and next are called successively, the method call to next returns "how". f next Line is called twice successively, the first call returns " , " as in the previous case, and he second call returns the remainder of the sequence, " how about yours? ", because is no dditional appearance of \n. Based upon this analysis, the output of the program is expected to be:

Fig. 3.2 The results of executing the program. The arrows show the positions of the Scanner object for the next read.
The sequences immediately to the left of the arrows are the tokens that have been read. Note that the last two reads are
done by nextLine so the delimiters other than the newline characters, if any, are included in the returned String

data that are returned — Fig. 3.2 The results of executing the program. The arrows show the positions of the Scanner object for the next read. The sequences immediately to the left of the arrows are the tokens that have been read. Note that the last two reads are done by nextLine so the delimiters other than the newline characters, if any, are included in the returned String data that are returned

Listing 3.3 A program that demonstrates the use of various “next” methods of Scanne:

Listing 3.4 A program that reads a String data, an int data, and a double data using methods of Scanner
In the next code, the program expects three input tokens from the keyboard, a String, an int,
and a double. The program receives these input tokens and then prints them. Knowing what happens
in the code, the user can type ABC 10 4.5 to enter all the tokens required by the program at once. — Listing 3.4 A program that reads a String data, an int data, and a double data using methods of Scanner In the next code, the program expects three input tokens from the keyboard, a String, an int, and a double. The program receives these input tokens and then prints them. Knowing what happens in the code, the user can type ABC 10 4.5 to enter all the tokens required by the program at once.

Listing 4.1 The source code for a program that produces a 3 x 3 white space rectangle with encompassing borders
We can accomplish the task using five System.out.printin statements correspond-
ing to the five horizontal strips of the shape, as shown next.! For clarification, the five
System.out.printin statements are marked with line comments indicating their correspon-
dence to the strips.
'The program name for this is Rectangle, not Square, although the size of the white-area is 3 x 3. This is because the
shape does not look like a square, which is because the computer characters have longer height than width. — Listing 4.1 The source code for a program that produces a 3 x 3 white space rectangle with encompassing borders We can accomplish the task using five System.out.printin statements correspond- ing to the five horizontal strips of the shape, as shown next.! For clarification, the five System.out.printin statements are marked with line comments indicating their correspon- dence to the strips. 'The program name for this is Rectangle, not Square, although the size of the white-area is 3 x 3. This is because the shape does not look like a square, which is because the computer characters have longer height than width.

We can accomplish the task by repeating the five statements two more times:

A method that prints a single rectangle can be defined as follows (where we use the name
oneRectangle for the method): — A method that prints a single rectangle can be defined as follows (where we use the name oneRectangle for the method):

Listing 4.6 A program that prints four rectangles with two on top of the other two
As in the case of the three rectangles, there are only two different printed strips that are printed:
(a) the pattern appearing at the top, in the middle, and at the bottom of the shape and (b) the pattern
appearing elsewhere. So, as before, we define two methods representing the patterns: line for the
former and side for the latter. We can decompose the drawing of the shape as the following sequence:
line, side, side, side, line, side, side, side, line — Listing 4.6 A program that prints four rectangles with two on top of the other two As in the case of the three rectangles, there are only two different printed strips that are printed: (a) the pattern appearing at the top, in the middle, and at the bottom of the shape and (b) the pattern appearing elsewhere. So, as before, we define two methods representing the patterns: line for the former and side for the latter. We can decompose the drawing of the shape as the following sequence: line, side, side, side, line, side, side, side, line

Listing 4.7 A program that produces four rectangles using method class (part 1). The methods that are responsible for
producing single lines — Listing 4.7 A program that produces four rectangles using method class (part 1). The methods that are responsible for producing single lines

Listing 4.9 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals. Presented without repeat:
Listing 4.10 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals. Presented without repeats
(cont’d) — Listing 4.9 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals. Presented without repeat: Listing 4.10 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals. Presented without repeats (cont’d)

With the repeats from previous verses, the rhyme looks like:
Listing 4.11 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals (part 1) — With the repeats from previous verses, the rhyme looks like: Listing 4.11 The lyrics to the rhyme “Old MacDonald Had A Farm” with four animals (part 1)

Listing 4.13 A program that print the lyrics to “Old MacDonald Had A Farm” using decomposition (part 1). The
method that produces the opening and ending lines of the verses and the methods for producing the lines about the
animals
Based upon this observation, we design the following code: — Listing 4.13 A program that print the lyrics to “Old MacDonald Had A Farm” using decomposition (part 1). The method that produces the opening and ending lines of the verses and the methods for producing the lines about the animals Based upon this observation, we design the following code:

Listing 4.15 A program that produces the lyrics to the rhyme “Old MacDonald Had A Farm” (part 3). The method
that build individual verses and the method main — Listing 4.15 A program that produces the lyrics to the rhyme “Old MacDonald Had A Farm” (part 3). The method that build individual verses and the method main

Fig. 4.4 The dependency among methods in 0ldMacDonaldDecomposed. jave

Signature.java has one method, sign, which produces four lines of output as follows:

The action of the program can be divided into three parts:

Recall the rhyme “Old MacDonald Had a Farm” that we examined in Chap. 4. The verses of the
song became longer and longer as each new verse introduced one new animal. The contents of the
verses are repetitive because they have the same principal structures. We now consider a new program
in which the song introduces only three animals: a cow, a pig, and a dog in this order. With slight
changes in capitalization and punctuation, our goal is to generate this output:
Listing 5.1 The expected output our new “Old MacDonald Had A Farm” program (part 1) — Recall the rhyme “Old MacDonald Had a Farm” that we examined in Chap. 4. The verses of the song became longer and longer as each new verse introduced one new animal. The contents of the verses are repetitive because they have the same principal structures. We now consider a new program in which the song introduces only three animals: a cow, a pig, and a dog in this order. With slight changes in capitalization and punctuation, our goal is to generate this output: Listing 5.1 The expected output our new “Old MacDonald Had A Farm” program (part 1)

Look at the lines that introduce the animal names:

where xxx and yyy are respectively "an Oink" and "Oink" for the pig and respectively "a
Bow" and "Wow" for the dog. (Naturally, we wish we could dispose of the article appearing in each
xxx, but unfortunately that appears impossible, since the article is "an" for the pig and "a" for the
others.) The pattern is encode in a method named with as follows:
Note that the name appearing in the second method call is different from the name appearing in
the method itself due to their scopes. The range of the first name starts at the { immediately after the
main declaration and ends at the } before the had declaration. The range of the second name starts
at the { immediately after the had declaration and ends at the last }. Therefore, we can safely change

the names stored in the variables without causing any problems.
We annlv 9 cimilar decgnmnoacitinn ta the cectinn that nrintse the calling of the animale Tn thic — where xxx and yyy are respectively "an Oink" and "Oink" for the pig and respectively "a Bow" and "Wow" for the dog. (Naturally, we wish we could dispose of the article appearing in each xxx, but unfortunately that appears impossible, since the article is "an" for the pig and "a" for the others.) The pattern is encode in a method named with as follows: Note that the name appearing in the second method call is different from the name appearing in the method itself due to their scopes. The range of the first name starts at the { immediately after the main declaration and ends at the } before the had declaration. The range of the second name starts at the { immediately after the had declaration and ends at the last }. Therefore, we can safely change the names stored in the variables without causing any problems. We annlv 9 cimilar decgnmnoacitinn ta the cectinn that nrintse the calling of the animale Tn thic

1e parameter type signature of the method. The entire code appears next, shown in two parts:
Listing 5.3. A source code for the parameterized version of the “Old MacDonald” program (part 1) — 1e parameter type signature of the method. The entire code appears next, shown in two parts: Listing 5.3. A source code for the parameterized version of the “Old MacDonald” program (part 1)

Listing 5.4 A source code for the parameterized version of the “Old MacDonald” program (part 2)

Listing 5.5 A code that demonstrates call-by-reference
Executing the code produces the following result: — Listing 5.5 A code that demonstrates call-by-reference Executing the code produces the following result:

Fig. 5.1 The call-by-reference concept. On the top side, the boxes are actual parameters

Listing 5.6 A program that demonstrates the use of method overloading (part 1)

Listing 5.7 A program that demonstrates the use of method overloading (part 2)

Listing 5.8 A program with method overloading in which available methods are fewer than the method call type:
(part 1) — Listing 5.8 A program with method overloading in which available methods are fewer than the method call type: (part 1)

Notice that the output for myByte is in decimals, although the value specified is hexadecimal.

If the type signature of a method call does not match the type signature of any method having the
same name, a compiler checks if the data types of the actual parameter can be interpreted as different
types so that the interpreted type signature has a match. The interpretation is applied to number types,
by treating a whole number type as a floating point number type and/or by treating a number type
as a larger number type. If no match can be found even with the parameter type interpretation, the
compiler produces a syntax error.
Here is the result of executing the code: — Notice that the output for myByte is in decimals, although the value specified is hexadecimal. If the type signature of a method call does not match the type signature of any method having the same name, a compiler checks if the data types of the actual parameter can be interpreted as different types so that the interpreted type signature has a match. The interpretation is applied to number types, by treating a whole number type as a floating point number type and/or by treating a number type as a larger number type. If no match can be found even with the parameter type interpretation, the compiler produces a syntax error. Here is the result of executing the code:

Listing 5.9 A program with method overloading in which available methods are fewer than the method call type:
(part 2) — Listing 5.9 A program with method overloading in which available methods are fewer than the method call type: (part 2)

For myByte, the compiler uses the int version as its surrogate, and for myFloat, the compiler
uses the double version as its surrogate. These substitutions come naturally, since both int and
byte are for whole numbers with more bits in int, and both double and float are for floating
point numbers with more bits in double. Here is the result of executing the program.
point numbers with more bits in doub1le. Here is the result of executing the program. — For myByte, the compiler uses the int version as its surrogate, and for myFloat, the compiler uses the double version as its surrogate. These substitutions come naturally, since both int and byte are for whole numbers with more bits in int, and both double and float are for floating point numbers with more bits in double. Here is the result of executing the program. point numbers with more bits in doub1le. Here is the result of executing the program.

Listing 5.13 A new version of the program for computing the BMI values for the input provided by the user (part 2)
The next part consists of the method for interacting with the user and the method main. — Listing 5.13 A new version of the program for computing the BMI values for the input provided by the user (part 2) The next part consists of the method for interacting with the user and the method main.

Listing 5.14 A program that demonstrates the use of constants and the method random of the class Math
Running the code produces the following result: — Listing 5.14 A program that demonstrates the use of constants and the method random of the class Math Running the code produces the following result:

Another execution produces the following result:

wee ss, See

Since the number that Math.random produces is between 0 and 1 (not including 1), by
multiplying the result of Math. random with a positive integer b and then adding another integer a,
a random real number between a and b can be generated. By applying the casting (int) to sucha
number, it is possible to generate a random integer between a anda + b. — wee ss, See Since the number that Math.random produces is between 0 and 1 (not including 1), by multiplying the result of Math. random with a positive integer b and then adding another integer a, a random real number between a and b can be generated. By applying the casting (int) to sucha number, it is possible to generate a random integer between a anda + b.

Listing 5.15 A program that generates random integers using Math. random
Here is another run: — Listing 5.15 A program that generates random integers using Math. random Here is another run:

Listing 5.18 A program that demonstrates the use of trigonometric methods in Math (part 1)

Listing 5.19 A program that demonstrates the use of trigonometric methods in Math (part 2)

Two conditions can be compared for equality and inequality. Given two conditions x and y,
x == y tests whether or not the value of x is equal to the value of y, and x != y tests whether
or not the value of x is not equal to the value of y. If x (or y) is a formula, it may be necessary to
surround it with a pair of parentheses.
The execution of the code produces the following result: — Two conditions can be compared for equality and inequality. Given two conditions x and y, x == y tests whether or not the value of x is equal to the value of y, and x != y tests whether or not the value of x is not equal to the value of y. If x (or y) is a formula, it may be necessary to surround it with a pair of parentheses. The execution of the code produces the following result:

FORMAT STRING is a String data. We call the first parameter of printf the formatting String.

In System. out .printf, each data placeholder takes the form of ¢XXXt, where t is a letter that
refers to the expected data type and XXX is a character sequence that specifies the way in which the
data value is printed. In this book we will see five types for t: c for char, d for any whole number
£ for any floating point number, s for String and boolean, and, much later, e for exponential
representation. If the XXX part is empty, System. out .printf uses the default formatting for the
type t (see Chap. 8).
The first printf statement in our code is: — FORMAT STRING is a String data. We call the first parameter of printf the formatting String. In System. out .printf, each data placeholder takes the form of ¢XXXt, where t is a letter that refers to the expected data type and XXX is a character sequence that specifies the way in which the data value is printed. In this book we will see five types for t: c for char, d for any whole number £ for any floating point number, s for String and boolean, and, much later, e for exponential representation. If the XXX part is empty, System. out .printf uses the default formatting for the type t (see Chap. 8). The first printf statement in our code is:

Here is one execution example of the program:

Listing 6.6 A program that shows comparisons between numbers (part 3)

The primary structure for an if-statement in Java, with no action to perform in C, is:
In other words, this code fragment is executed as follows:
“if C then execute A; otherwise, execute B” — The primary structure for an if-statement in Java, with no action to perform in C, is: In other words, this code fragment is executed as follows: “if C then execute A; otherwise, execute B”

mn Eye Set AAV, EEEM MERO ES ROLIAL Mids MEAN Pe Elias

Our next code example uses two if-statements. The first if-statement tests if the value entered is
strictly greater than 90.0 as before. The second one tests if the temperature value is less than or equal
to 70.0 (notice the equality sign placed on the second one). There are two messages from which the
program chooses to print. The program prints the first message if and only if the temperature is strictly
greater than 90.0, and the second message if and only if the temperature is less than or equal to 70.0.
The program prints no statement if the temperature is strictly greater than 70.0 and less than or equal
to 90.0:
Listing 6.8 Another program that receives a temperature value and makes a comment when appropriate — mn Eye Set AAV, EEEM MERO ES ROLIAL Mids MEAN Pe Elias Our next code example uses two if-statements. The first if-statement tests if the value entered is strictly greater than 90.0 as before. The second one tests if the temperature value is less than or equal to 70.0 (notice the equality sign placed on the second one). There are two messages from which the program chooses to print. The program prints the first message if and only if the temperature is strictly greater than 90.0, and the second message if and only if the temperature is less than or equal to 70.0. The program prints no statement if the temperature is strictly greater than 70.0 and less than or equal to 90.0: Listing 6.8 Another program that receives a temperature value and makes a comment when appropriate

Listing 6.9 A program that receives a temperature value and a humidity value, and then makes a comment when
appropriate — Listing 6.9 A program that receives a temperature value and a humidity value, and then makes a comment when appropriate

The four cases the program tests are as follows:

Following is an example of executing the program:
Listing 6.11 An interactive program that responds to the user’s color selection (part 2) — Following is an example of executing the program: Listing 6.11 An interactive program that responds to the user’s color selection (part 2)

Now we look at the if-statements having the “otherwise” part, which we call if-else statements:

meee

In an if-else statement, an if and an else work as a pair. For each if-else pair, the if part
must appear before the else part. Furthermore, the if part and the else part must be at the same

depth. Furthermore, there must be no other statements or code blocks between the paired if and
else parts.
The following example shows syntactically incorrect if-else statements: — meee In an if-else statement, an if and an else work as a pair. For each if-else pair, the if part must appear before the else part. Furthermore, the if part and the else part must be at the same depth. Furthermore, there must be no other statements or code blocks between the paired if and else parts. The following example shows syntactically incorrect if-else statements:

Similar to the case of if-statements, the curly brackets for the else-part can be omitted if there is only
one statement in it. In other words, — Similar to the case of if-statements, the curly brackets for the else-part can be omitted if there is only one statement in it. In other words,

is syntactically incorrect, because the code is basically saying:
The code: — is syntactically incorrect, because the code is basically saying: The code:

Listing 6.12 A program that responds to a color selection of the user. The program uses else

A special case of successive if-else statements is else if as follows:

Using this option, we can rewrite the previous code as follows:
Fig. 6.5 A hypothetical
situation with interwoven
conditions — Using this option, we can rewrite the previous code as follows: Fig. 6.5 A hypothetical situation with interwoven conditions

Here is an example that demonstrates the benefit of else.

Suppose we are to write a program that receives an int value from the user and produces an output
line depending on the value: message X for values 0, 4, 8, and 12, message Y for values less than 0
and values greater than 12, and message Z for the rest. Without using else the code may look like: — Here is an example that demonstrates the benefit of else. Suppose we are to write a program that receives an int value from the user and produces an output line depending on the value: message X for values 0, 4, 8, and 12, message Y for values less than 0 and values greater than 12, and message Z for the rest. Without using else the code may look like:

On the other hand, if we use else, we can simplify it as:

By swapping the order between the first and the second conditions, we can further simplify the code,
since 0, 4, 8, and 12 are all multiples of 4, as shown next: — By swapping the order between the first and the second conditions, we can further simplify the code, since 0, 4, 8, and 12 are all multiples of 4, as shown next:

Using else, we can avoid using one conditional evaluation:

If b == 0, the conditional evaluation halts immediately with the outcome of false, so the
remainder operator a % b will not occur. Thus, the program works the same way.
Another nice feature of conditional evaluation is that each of the six comparisons can be combined

with an assignment. For example, consider the following code fragment: — If b == 0, the conditional evaluation halts immediately with the outcome of false, so the remainder operator a % b will not occur. Thus, the program works the same way. Another nice feature of conditional evaluation is that each of the six comparisons can be combined with an assignment. For example, consider the following code fragment:

1. Flattening multi-level if-then statements Consider the following code:

2. Flattening multi-level if-then statement, alternate
Rewrite the code in the form of: — 2. Flattening multi-level if-then statement, alternate Rewrite the code in the form of:

The execution of the code, with some input from the user, produces the following:

The next program contains a for-loop with an interaction that changes its value from 0 to 7.

The iteration variable of the for-loop is count. Since the initial value of the iteration variable is 0,
the termination condition is count < 8,and the update is count ++, the last value of count for
which the loop-body is executed is 7. Figure 7.2 summarizes the above observation.

Running the code produces the following: — The iteration variable of the for-loop is count. Since the initial value of the iteration variable is 0, the termination condition is count < 8,and the update is count ++, the last value of count for which the loop-body is executed is 7. Figure 7.2 summarizes the above observation. Running the code produces the following:

Running the code produces the following:

Here is the code that follows this algorithm:
Suppose we use a modest value, 20, for N and run an experiment to examine how close the average
ets to the expected average of 0.50. Our program uses a double variable named random to record
1e random number Math. random produces at each round, an int variable named round to record
1e number of times a random number has been generated, and a double variable named sum to
ecord the sum of the random numbers. At each round, the program announces the round number and
1e random number that has been generated. After the for-loop, the program divides the total by 20
nd then prints the average. — Here is the code that follows this algorithm: Suppose we use a modest value, 20, for N and run an experiment to examine how close the average ets to the expected average of 0.50. Our program uses a double variable named random to record 1e random number Math. random produces at each round, an int variable named round to record 1e number of times a random number has been generated, and a double variable named sum to ecord the sum of the random numbers. At each round, the program announces the round number and 1e random number that has been generated. After the for-loop, the program divides the total by 20 nd then prints the average.

Listing 7.6 Examples of iteration (part 1)
Furthermore, the two lines preceding each for-loop have the role of producing the three components
of the loop on the screen: — Listing 7.6 Examples of iteration (part 1) Furthermore, the two lines preceding each for-loop have the role of producing the three components of the loop on the screen:

Listing 7.7 Examples of iteration (part 2)

Another run produces this result:
Listing 7.9 A program that counts down from an input number to 0 by dividing the number by 2 — Another run produces this result: Listing 7.9 A program that counts down from an input number to 0 by dividing the number by 2

Listing 7.10 A program that calculates the sum of all integers between | and n by adding one number after another

Here is another:
The next program receives the value for an int variable, n, from the user, and then computes the
sum of integers between | and n. In Chap. 2, we have seen the program performing this calculation,
using Gauss’s approach for a fixed valueofn(asn * (n - 1 ) / 2). The version here computes
the sum by adding the numbers one after another: — Here is another: The next program receives the value for an int variable, n, from the user, and then computes the sum of integers between | and n. In Chap. 2, we have seen the program performing this calculation, using Gauss’s approach for a fixed valueofn(asn * (n - 1 ) / 2). The version here computes the sum by adding the numbers one after another:

Listing 7.11 A program that computes the factorial function using a for-loop
In a similar vein, we can write a program that computes the product of all integers between | and n,
where n is a value that the user enters. The mathematical name for the product of consecutive numbers
starting from | is the factorial of n, written n!. Since the factorial is a function that increases very
quickly as the value of n increases, we use long instead of int. We compute the value of the factorial
in a long variable named product. Then, we initialize product with the value of 1. During the
loop, we update the value of product by multiplying it with the value of the iteration variable i. — Listing 7.11 A program that computes the factorial function using a for-loop In a similar vein, we can write a program that computes the product of all integers between | and n, where n is a value that the user enters. The mathematical name for the product of consecutive numbers starting from | is the factorial of n, written n!. Since the factorial is a function that increases very quickly as the value of n increases, we use long instead of int. We compute the value of the factorial in a long variable named product. Then, we initialize product with the value of 1. During the loop, we update the value of product by multiplying it with the value of the iteration variable i.

The execution of the code with three different pairs of input results is shown next.
Note the following:
We use two successive calls to next Int (Lines 8 and 9) to receive the input value of the user.
The user may hit the return key after entering the first number, but at that point the program will still
be waiting for the second number, meaning nothing will happen. After receiving the two numbers,
the program executes an iteration with the initialization of count = start and the termination
condition of count <= end (Line 15).

— me"; ru 1 ro | wer 7 . fe 7 4. os. 1 — The execution of the code with three different pairs of input results is shown next. Note the following: We use two successive calls to next Int (Lines 8 and 9) to receive the input value of the user. The user may hit the return key after entering the first number, but at that point the program will still be waiting for the second number, meaning nothing will happen. After receiving the two numbers, the program executes an iteration with the initialization of count = start and the termination condition of count <= end (Line 15). — me"; ru 1 ro | wer 7 . fe 7 4. os. 1

Listing 7.14 A program that generates a rectangle of hash marks with surrounding lines (part 1)

Listing 7.15 A program that generates a rectangle of hash marks with surrounding lines (part 2)
The second part consists of three components. The first component is for printing the top line,
which isa ’+’,alineof ’-’ having length width, and another ' +’ in the order of appearance. The
second component is similar to the previous double for-loop, but has one ’ |’ at the beginning and
at the end. In addition, the program prints the second ’ |’ with System. out .print1n instead of
System.out.print. The third component is identical to the first one. — Listing 7.15 A program that generates a rectangle of hash marks with surrounding lines (part 2) The second part consists of three components. The first component is for printing the top line, which isa ’+’,alineof ’-’ having length width, and another ' +’ in the order of appearance. The second component is similar to the previous double for-loop, but has one ’ |’ at the beginning and at the end. In addition, the program prints the second ’ |’ with System. out .print1n instead of System.out.print. The third component is identical to the first one.

By using the value of the external iteration variable in the header of the internal iteration, it is
possible to perform a complicated task. The next example shows this. The goal is to print an upside
down triangle with the right angle at the upper-left corner, like this one:
The number of ‘ *’ printed in one line starts from some number and decreases one by one, until it
becomes 1. The start number is equal to the number of ‘ *’ printed in the first line. Suppose an int
variable named down contains the number of ’ «’s that must be in a give line. Using an iteration
variable, across, the task of printing that specific line can be accomplished as: — By using the value of the external iteration variable in the header of the internal iteration, it is possible to perform a complicated task. The next example shows this. The goal is to print an upside down triangle with the right angle at the upper-left corner, like this one: The number of ‘ *’ printed in one line starts from some number and decreases one by one, until it becomes 1. The start number is equal to the number of ‘ *’ printed in the first line. Suppose an int variable named down contains the number of ’ «’s that must be in a give line. Using an iteration variable, across, the task of printing that specific line can be accomplished as:

Specifying one of the two dimensions as 0 results in the following. This is when the height is 0:

Computing the Maximum and Minimum in a Series of Numbers
Here, we combine for-loops and conditional executions to write an application. — Computing the Maximum and Minimum in a Series of Numbers Here, we combine for-loops and conditional executions to write an application.

Listing 7.17 A program for computing the maximum and the minimum of an integer series (part 1). A part that is
responsible for receiving the length and running a check
Next, the program receives the first element of the series and stores this in the variable input.
Since this is the very first element, the program stores its value in both maximum and minimum. The
declarations of all these variables appear in Line 6. If the value of nData is 1, then there will be no
further input, and so the first number the user enters is both the maximum and the minimum. — Listing 7.17 A program for computing the maximum and the minimum of an integer series (part 1). A part that is responsible for receiving the length and running a check Next, the program receives the first element of the series and stores this in the variable input. Since this is the very first element, the program stores its value in both maximum and minimum. The declarations of all these variables appear in Line 6. If the value of nData is 1, then there will be no further input, and so the first number the user enters is both the maximum and the minimum.

Listing 7.19 A program for computing the maximum and the minimum of an integer series (part 3). A part that
responsible for receiving the remaining numbers and printing the result
Here is an execution example where the run-time error IllegalArgumentException occurs: — Listing 7.19 A program for computing the maximum and the minimum of an integer series (part 3). A part that responsible for receiving the remaining numbers and printing the result Here is an execution example where the run-time error IllegalArgumentException occurs:

Listing 7.22 Betting game (part 3). The part that determines the bet type
The next part is for determining the betting type. The program does the following: — Listing 7.22 Betting game (part 3). The part that determines the bet type The next part is for determining the betting type. The program does the following:

Listing 7.21 A betting game (part 2). The part that processes the bet amount

Listing 7.23 A betting game (part 4). The part that throws a dice and reports the result

Consider the following code block:
Two important statements that can be used in a for-loop body are continue and break. The
statement continue instructs the program to skip the remainder of the loop-body and move on
to the next round of the loop. The statement break instructs the program to terminate the execution
of the loop immediately, ignoring the remainder of the present round and all the remaining rounds. If
these statements appear inside an interior loop of multiple loops, their actions apply to the innermost
loop that contains the statements.
Here is another example. In the following code, a is an int variable. — Consider the following code block: Two important statements that can be used in a for-loop body are continue and break. The statement continue instructs the program to skip the remainder of the loop-body and move on to the next round of the loop. The statement break instructs the program to terminate the execution of the loop immediately, ignoring the remainder of the present round and all the remaining rounds. If these statements appear inside an interior loop of multiple loops, their actions apply to the innermost loop that contains the statements. Here is another example. In the following code, a is an int variable.

Once possession becomes 0, there will be no action to be performed in the loop-body.
Therefore, we can use break to terminate the loop as soon as possession becomes 0.
Once possession becomes 0, there will be no action to be performed in the loop-body. — Once possession becomes 0, there will be no action to be performed in the loop-body. Therefore, we can use break to terminate the loop as soon as possession becomes 0. Once possession becomes 0, there will be no action to be performed in the loop-body.

The next code encapsulates the above ideas and prints the value of £, along with the values of fr
and fpp.
ine task by using a for-loop and memorizing just the two previous values in the sequence.

Using a for-loop that iterates the sequence 2, ..., mn witha variable named i, we compute th
value of F;. To record the values of F; and its two predecessors, we use three Long variables, instea
of three int variables. This is because the values of the elements of the Fibonacci sequence increas
very quickly. The three variables are £, £p, and fpp. They represent F;, F;_1, and F;_2 respectivels
At the start of the loop body, it is ensured that the value of fp is equal to Fj;_; and the value o
Epp is equal to F;_2. We obtain the value of F; by £ = fp + fpp and print its value. When th
program returns to the start of the loop-body, the value of i has been increased by 1. Therefore, w
must make sure that fpp and fp hold the values of F;_; and F;_2 for the new value of i. This can b
accomplished by first replacing the value of fpp with the value of fp, and then replacing the valu
of Ep with the value of £. Also, before entering the loop, since the value of i starts with 2, we nee
io assign the value of F; to fp and Fo to fpp.

a, a: i a i ne: a i i nn ae ee. ae: a ee Sr ae — The next code encapsulates the above ideas and prints the value of £, along with the values of fr and fpp. ine task by using a for-loop and memorizing just the two previous values in the sequence. Using a for-loop that iterates the sequence 2, ..., mn witha variable named i, we compute th value of F;. To record the values of F; and its two predecessors, we use three Long variables, instea of three int variables. This is because the values of the elements of the Fibonacci sequence increas very quickly. The three variables are £, £p, and fpp. They represent F;, F;_1, and F;_2 respectivels At the start of the loop body, it is ensured that the value of fp is equal to Fj;_; and the value o Epp is equal to F;_2. We obtain the value of F; by £ = fp + fpp and print its value. When th program returns to the start of the loop-body, the value of i has been increased by 1. Therefore, w must make sure that fpp and fp hold the values of F;_; and F;_2 for the new value of i. This can b accomplished by first replacing the value of fpp with the value of fp, and then replacing the valu of Ep with the value of £. Also, before entering the loop, since the value of i starts with 2, we nee io assign the value of F; to fp and Fo to fpp. a, a: i a i ne: a i i nn ae ee. ae: a ee Sr ae

Double for-loop Write a double for-loop that produces the following output:

10. Output generated by for-loops 1 State the output the following code generates:

11. Output generated by for-loops 2 State the output the following code generates:

Listing 8.1 A code that shows various output formatting for String data. The main method
The method main prints the String variable t using various formats. The method first stores the lit-
eral "Welcome to the Club!" tot (Line 5). The method then prints the header lines (Lines 7-
9). The method then prints t in seven different formats by calling the printStringWithFormat
method (Lines 10-16). At the end, in Line 17, the method prints a line identical to the one that it
printed in Line 9. — Listing 8.1 A code that shows various output formatting for String data. The main method The method main prints the String variable t using various formats. The method first stores the lit- eral "Welcome to the Club!" tot (Line 5). The method then prints the header lines (Lines 7- 9). The method then prints t in seven different formats by calling the printStringWithFormat method (Lines 10-16). At the end, in Line 17, the method prints a line identical to the one that it printed in Line 9.

Listing 8.5 A code that shows various output formatting for floating point data (part 3). The main method of the
second program
Here is the second program.
The auxiliary methods between the two programs are identical. — Listing 8.5 A code that shows various output formatting for floating point data (part 3). The main method of the second program Here is the second program. The auxiliary methods between the two programs are identical.

The following is from Print FFloat:
Listing 8.6 A code that shows various output formatting for floating point data (part 4). A method used for printing
the format St ring and the formatted data together — The following is from Print FFloat: Listing 8.6 A code that shows various output formatting for floating point data (part 4). A method used for printing the format St ring and the formatted data together

In Chap.7, we learned how to compute the Fibonacci numbers using two variables to record twe
immediate predecessors in the sequence. Now, consider printing the square and cubic roots of the
numbers obtained as a table, where we generate the sequence up to F9: — In Chap.7, we learned how to compute the Fibonacci numbers using two variables to record twe immediate predecessors in the sequence. Now, consider printing the square and cubic roots of the numbers obtained as a table, where we generate the sequence up to F9:

Listing 8.8 A program that prints the Fibonacci numbers and their square and cubic roots neatly (part 2)
Listing 8.7 A program that prints the Fibonacci numbers and their square and cubic roots neatly (part 1) — Listing 8.8 A program that prints the Fibonacci numbers and their square and cubic roots neatly (part 2) Listing 8.7 A program that prints the Fibonacci numbers and their square and cubic roots neatly (part 1)

Here is the code for this task, FibonacciClean.
We can generate this output using two coordinated formats, one for the first line of the header and the
other for the data rows of the table. Both types have four entries, and the numbers of spaces allocated
for them are 5, 20, 20, and 20 in this order. For the header line, all the entries are String data, so
we use the place holders "5s", "20s", "320s", and "%20s". For each data line, the first two
entries are integers and the last entries are floating point numbers with five digits after the decimal
point, so we use the placeholders "35d", "20d", "%20.5f", and "%20.5£". Each time a new
element of the Fibonacci sequence is calculated, the element is stored in the variable £. The new
element is calculated as the sum of the two variables, fp and fpp. fp and fpp hold the values of the
previous Fibonacci number and the number right before the previous Fibonacci number. We calculate
the two roots using the Math functions sqrt and cbrt.

i ee es a ey ee Se ee ae ae — Here is the code for this task, FibonacciClean. We can generate this output using two coordinated formats, one for the first line of the header and the other for the data rows of the table. Both types have four entries, and the numbers of spaces allocated for them are 5, 20, 20, and 20 in this order. For the header line, all the entries are String data, so we use the place holders "5s", "20s", "320s", and "%20s". For each data line, the first two entries are integers and the last entries are floating point numbers with five digits after the decimal point, so we use the placeholders "35d", "20d", "%20.5f", and "%20.5£". Each time a new element of the Fibonacci sequence is calculated, the element is stored in the variable £. The new element is calculated as the sum of the two variables, fp and fpp. fp and fpp hold the values of the previous Fibonacci number and the number right before the previous Fibonacci number. We calculate the two roots using the Math functions sqrt and cbrt. i ee es a ey ee Se ee ae ae

Here s represents the String data to which the methods appearing in the table are applied. For methods indexOf
and last IndexOf, a char value is also accepted as the first parameter
Table 9.1 A list of String methods — Here s represents the String data to which the methods appearing in the table are applied. For methods indexOf and last IndexOf, a char value is also accepted as the first parameter Table 9.1 A list of String methods

The error message starts immediately after the output position = 13.

Listing 9.3. An example of String comparison (part 2). This section is for executing comparisons
performCompareTo. performEquals receives two String data, s and t, and reports the
result of comparing s with t using equals. performCompareTo receives two String data
s and t, and reports the result of comparing s with t using compareTo. Both methods uss
printf for reporting the result. The method performEquals uses %s as the placeholder fo:
printing the return value of the equals method, while the method performCompareTo uses %¢
as the placeholder for printing the return value of the compareTo. Using the two methods, the
method main executes equals between text1 and text1 itself, between text1 and text2
and between text2 and text3. The method then executes comparesTo between text1 anc
text1 itself, and all distinct pairs (in this case, there are six of them). — Listing 9.3. An example of String comparison (part 2). This section is for executing comparisons performCompareTo. performEquals receives two String data, s and t, and reports the result of comparing s with t using equals. performCompareTo receives two String data s and t, and reports the result of comparing s with t using compareTo. Both methods uss printf for reporting the result. The method performEquals uses %s as the placeholder fo: printing the return value of the equals method, while the method performCompareTo uses %¢ as the placeholder for printing the return value of the compareTo. Using the two methods, the method main executes equals between text1 and text1 itself, between text1 and text2 and between text2 and text3. The method then executes comparesTo between text1 anc text1 itself, and all distinct pairs (in this case, there are six of them).

Here is another example. This time, the input contains numerals:

Listing 9.6 A program that demonstrates the use of pattern search methods of String (part 2). The part that prints
the header of the output
The program presents the input and the character positions using the table-like format shown above.
If the input from the user has length between 0 and 100, the decimal representation of each character
position requires at most two digits. If a value between 0 and 99 is represented by an int variable
i, its digit in the tens place is i / 10 and its digit in the ones place is i % 10. Based upon this
observation, the program uses the following code to produce the header.
The program then executes pattern search. There are four different calls. The program announces
the method it is about to call, and then prints the return value. — Listing 9.6 A program that demonstrates the use of pattern search methods of String (part 2). The part that prints the header of the output The program presents the input and the character positions using the table-like format shown above. If the input from the user has length between 0 and 100, the decimal representation of each character position requires at most two digits. If a value between 0 and 99 is represented by an int variable i, its digit in the tens place is i / 10 and its digit in the ones place is i % 10. Based upon this observation, the program uses the following code to produce the header. The program then executes pattern search. There are four different calls. The program announces the method it is about to call, and then prints the return value.

Listing 9.11 A program that demonstrates the use of String methods for generating new St ring data (part 4). The
method changesThree
In changesThree, the program receives an input line (Lines 39 and 40) and two additiona
lines representing the patterns (Lines 41-44) from the user, and then executes the pattern replacemer
(Lines 45-48).
Here is one execution example of the code. — Listing 9.11 A program that demonstrates the use of String methods for generating new St ring data (part 4). The method changesThree In changesThree, the program receives an input line (Lines 39 and 40) and two additiona lines representing the patterns (Lines 41-44) from the user, and then executes the pattern replacemer (Lines 45-48). Here is one execution example of the code.

nextInt. If there is no nextLine after the two calls of nextInt in changesTwo, the first
nextLine in changesThree returns the sequence of characters entered between the last numeral
of the second integer retrieved with next Int in changesTwo and the return key that has been
pressed to enter the numbers. — nextInt. If there is no nextLine after the two calls of nextInt in changesTwo, the first nextLine in changesThree returns the sequence of characters entered between the last numeral of the second integer retrieved with next Int in changesTwo and the return key that has been pressed to enter the numbers.

Listing 9.12 A program that demonstrates the use of StringBuilder objects

The switch statement replaces these if and else if conditional tests with case names:
LMS prODdaDLy Mldkes It CiCaler Wat ule CHOICES dle VU UNOURTI O.

The entire program of the selective shape generation appears next. First comes the part in the
method main that receives the input from the user: the value for the selection variable choice (Lines
18 and 19) and the value for the height variable height (Lines 20 and 21). The switch statement we
discussed appears in Lines 25-31. This version lacks the final break, since a break statement at
the end of the body of a switch statement is redundant. — The switch statement replaces these if and else if conditional tests with case names: LMS prODdaDLy Mldkes It CiCaler Wat ule CHOICES dle VU UNOURTI O. The entire program of the selective shape generation appears next. First comes the part in the method main that receives the input from the user: the value for the selection variable choice (Lines 18 and 19) and the value for the height variable height (Lines 20 and 21). The switch statement we discussed appears in Lines 25-31. This version lacks the final break, since a break statement at the end of the body of a switch statement is redundant.

accomplished as follows using an if-else statement:
In Lines 8 and 9, the program prompts the user to choose the shape and its size, and receives 3 and
10 from the user. The output of the shape appears after receiving the size parameter.

As shown in the example, there are four possible shapes to choose in the menu. The user can
choose the size of each shape. The generation of the four shapes are accomplished by four methods,
rightAngle, isosceles, square, and parallelogram. Each of the four receives a size
parameter. The task of directing the flow to the generation of the shape chosen by the user can be
accomplished as follows using an if-else statement: — accomplished as follows using an if-else statement: In Lines 8 and 9, the program prompts the user to choose the shape and its size, and receives 3 and 10 from the user. The output of the shape appears after receiving the size parameter. As shown in the example, there are four possible shapes to choose in the menu. The user can choose the size of each shape. The generation of the four shapes are accomplished by four methods, rightAngle, isosceles, square, and parallelogram. Each of the four receives a size parameter. The task of directing the flow to the generation of the shape chosen by the user can be accomplished as follows using an if-else statement:

isting 10.3 A program that uses a switch statement to generate a shape (part 3). Two shape-producing methods
For rightAngle (Line 47), the actual callis Line ( 0, i ) (Line 51). This produces i hash
marks with no indentation. Since the value of i is increasing, a right-angled triangle is produced. For
isosceles (Line 55), the actual call is line( height - i, i * 2 - 1 ) (Line 59). As
the value of i increases from 1 to height, the length of indentation decreases from height - 1 to
0 while the number of hash marks increases from 1 to2 * height - 1 by2 ata time. Therefore,
an isosceles triangle is produced. For square (Line 63), the actual callis line( 0, height )
(Line 67). This produces height hash marks with no indentation. Therefore, a square is produced.
For parallelogram (Line 71), the actual call is Line( i - 1, height ) (Line 75). The
length of indentation increases from 0 to height - 1 while the number of hash marks is height.
Therefore, a parallelogram is produced.
Therefore, a parallelogram is produced. — isting 10.3 A program that uses a switch statement to generate a shape (part 3). Two shape-producing methods For rightAngle (Line 47), the actual callis Line ( 0, i ) (Line 51). This produces i hash marks with no indentation. Since the value of i is increasing, a right-angled triangle is produced. For isosceles (Line 55), the actual call is line( height - i, i * 2 - 1 ) (Line 59). As the value of i increases from 1 to height, the length of indentation decreases from height - 1 to 0 while the number of hash marks increases from 1 to2 * height - 1 by2 ata time. Therefore, an isosceles triangle is produced. For square (Line 63), the actual callis line( 0, height ) (Line 67). This produces height hash marks with no indentation. Therefore, a square is produced. For parallelogram (Line 71), the actual call is Line( i - 1, height ) (Line 75). The length of indentation increases from 0 to height - 1 while the number of hash marks is height. Therefore, a parallelogram is produced. Therefore, a parallelogram is produced.

Listing 10.2 A program that uses a switch statement to generate a shape (part 2). A method line that produces a line
of "#" after some indentation — Listing 10.2 A program that uses a switch statement to generate a shape (part 2). A method line that produces a line of "#" after some indentation

Listing 10.4 A program that uses a switch statement to generate a shape (part 4). The two remaining shape-producing
methods — Listing 10.4 A program that uses a switch statement to generate a shape (part 4). The two remaining shape-producing methods

Multiple anchors can be assigned to the same entry points. Recall the program from Chap. 6 that
shows four colors and produces statements based upon the choice made (List 6.10). In that code, | and
2 were the official University of Miami colors and 3 and 4 were the official University of Michigan
colors. Using a switch statement with default as an anchor, we can write the following code that
behaves exactly the same way: — Multiple anchors can be assigned to the same entry points. Recall the program from Chap. 6 that shows four colors and produces statements based upon the choice made (List 6.10). In that code, | and 2 were the official University of Miami colors and 3 and 4 were the official University of Michigan colors. Using a switch statement with default as an anchor, we can write the following code that behaves exactly the same way:

Listing 10.6 A program that counts punctuations (part 1). The program header and a program for receiving a multiple-
line input
object named builder to build the String to be returned (Line 11). The method announces the
actions to be performed and instantiates a Scanner object for reading the keyboard (Lines 8-10).
The method uses a for-loop to count the number of lines entered (Line 12). At each round of iteration,
the method reads one line of input (Line 14), and then appends the line and the newline to builder
(Line 15). At the end, the method converts the contents of builder to a String value and returns
1t.
The method print Info receives a String representing the name of a punctuation marks and
an int representing the count, and prints the two values using printf (Line 22). The String
appears in 20 character spaces and the count in three character spaces. The two are separated by a
colon and one white space. The method main first calls the method receiveInput to obtain a — Listing 10.6 A program that counts punctuations (part 1). The program header and a program for receiving a multiple- line input object named builder to build the String to be returned (Line 11). The method announces the actions to be performed and instantiates a Scanner object for reading the keyboard (Lines 8-10). The method uses a for-loop to count the number of lines entered (Line 12). At each round of iteration, the method reads one line of input (Line 14), and then appends the line and the newline to builder (Line 15). At the end, the method converts the contents of builder to a String value and returns 1t. The method print Info receives a String representing the name of a punctuation marks and an int representing the count, and prints the two values using printf (Line 22). The String appears in 20 character spaces and the count in three character spaces. The two are separated by a colon and one white space. The method main first calls the method receiveInput to obtain a

Here is another program that uses a switch statement. This time, the program uses a char data
for directing the flow. This program receives four pieces of information about a person (name, age,
gender, and phone number) from the user, and stores the information in four variables. The program
then receives a text input from the user. The program examines the first character of the text input,
obtained using charAt ( 0 ).Ifthe character matches one of the four letters (‘N’, ‘A’, ‘G‘, and
‘P’) representing the four pieces of information, the program prints the information; otherwise, the
program prints an error message. — Here is another program that uses a switch statement. This time, the program uses a char data for directing the flow. This program receives four pieces of information about a person (name, age, gender, and phone number) from the user, and stores the information in four variables. The program then receives a text input from the user. The program examines the first character of the text input, obtained using charAt ( 0 ).Ifthe character matches one of the four letters (‘N’, ‘A’, ‘G‘, and ‘P’) representing the four pieces of information, the program prints the information; otherwise, the program prints an error message.

In the second example, the user asks to recall the name by entering the prefix "Nam" of "Name":
Here are some execution examples of the code. In the first example, the user asks to recall the age — In the second example, the user asks to recall the name by entering the prefix "Nam" of "Name": Here are some execution examples of the code. In the first example, the user asks to recall the age

In the last example, the user enters "Q", but there is no matching choice, so the program prints the
error message:
In the third example, the user asks to recall the phone number by entering "Pine", whose first

ce tp em — In the last example, the user enters "Q", but there is no matching choice, so the program prints the error message: In the third example, the user asks to recall the phone number by entering "Pine", whose first ce tp em

0.3. Using a String Data in a Switch Statement
An alternate version of the memory recall program show next uses a switch statement that examines
the value of a String data. In this version, to recall information, the user must type the exact name
of the information to recall. The program handles the input that the user enters in a non-case-sensitive
manner by converting it to all lowercase using the method toLowerCase () of String (Line 22). — 0.3. Using a String Data in a Switch Statement An alternate version of the memory recall program show next uses a switch statement that examines the value of a String data. In this version, to recall information, the user must type the exact name of the information to recall. The program handles the input that the user enters in a non-case-sensitive manner by converting it to all lowercase using the method toLowerCase () of String (Line 22).

Listing 10.12 A program for recalling memory (part 2). The part responsible for recalling information

We saw earlier that executing next on a Scanner object after obtaining its last token results
in a run-time error of NoSuchElementException. In our example (List 3.1), we attempted to
obtain five tokens from a String data with only four tokens, thereby intentionally produced the
run-time error. It is possible to prevent an attempt to read beyond the last token by using the method
hasNext () mentioned in Chap. 3. This method returns a boolean that represents whether or not
at least one token is remaining.
The formal study of programming languages categorizes loops into two types, definite loops and
indefinite loops, depending on whether the number of repetition is determined at the start of the loop
or it is dynamically determined during the execution of the loop. The former type includes the for-loop
and the latter includes the while-loop. Although for-loops and while-loops are interchangeable, there
are situations where the use of one type appears more appropriate than the user of the other type. — We saw earlier that executing next on a Scanner object after obtaining its last token results in a run-time error of NoSuchElementException. In our example (List 3.1), we attempted to obtain five tokens from a String data with only four tokens, thereby intentionally produced the run-time error. It is possible to prevent an attempt to read beyond the last token by using the method hasNext () mentioned in Chap. 3. This method returns a boolean that represents whether or not at least one token is remaining. The formal study of programming languages categorizes loops into two types, definite loops and indefinite loops, depending on whether the number of repetition is determined at the start of the loop or it is dynamically determined during the execution of the loop. The former type includes the for-loop and the latter includes the while-loop. Although for-loops and while-loops are interchangeable, there are situations where the use of one type appears more appropriate than the user of the other type.

Listing 11.2 A program that reads all tokens from a String obtained from the user
11.1.2 Summing Input Numbers Until the Total Reaches a Goal
Our next example is a program that receives a series of integers from the user, and presents its running
total after receiving each number. The program keeps receiving numbers from the user until the total
reaches a preset goal. The program uses three int variables (input, total, and goal1) to record
the input from the user, the total of the input values, and the goal. The program initializes total with
the value of 0 and uses the value of 1000 for goal. The process of receiving one integer and then
adding its value to value can be code as follows: — Listing 11.2 A program that reads all tokens from a String obtained from the user 11.1.2 Summing Input Numbers Until the Total Reaches a Goal Our next example is a program that receives a series of integers from the user, and presents its running total after receiving each number. The program keeps receiving numbers from the user until the total reaches a preset goal. The program uses three int variables (input, total, and goal1) to record the input from the user, the total of the input values, and the goal. The program initializes total with the value of 0 and uses the value of 1000 for goal. The process of receiving one integer and then adding its value to value can be code as follows:

Following is a source code of the program. The program uses a Scanner object keyboard
instantiated with System. in (Line 6). The declarations of the int variables and their initializations
appear in Line 7. In the while-loop, the program prints a prompt (Line 10), receives an input (Line
11), updates the total (Line 12), and reports the present values of input and total (Line 13) using
printf. After exiting the loop, the program announces that the goal has been reached (Line 15).

Here is one execution example: — Following is a source code of the program. The program uses a Scanner object keyboard instantiated with System. in (Line 6). The declarations of the int variables and their initializations appear in Line 7. In the while-loop, the program prints a prompt (Line 10), receives an input (Line 11), updates the total (Line 12), and reports the present values of input and total (Line 13) using printf. After exiting the loop, the program announces that the goal has been reached (Line 15). Here is one execution example:

11.1.3 Integer Overflow
The loop can be quickly finished by entering a large number:
The next example is a program that receives a positive initial value from the user, and then keeps
updating the value with the multiplication by 2. The program uses an int variable named number
to store the input number as well as the value after each update. Since the number of bits allocated
Listing 11.3 A program that receives input numbers until the total exceeds a preset bound — 11.1.3 Integer Overflow The loop can be quickly finished by entering a large number: The next example is a program that receives a positive initial value from the user, and then keeps updating the value with the multiplication by 2. The program uses an int variable named number to store the input number as well as the value after each update. Since the number of bits allocated Listing 11.3 A program that receives input numbers until the total exceeds a preset bound

Listing 11.4 A program that demonstrates an overflow with multiplication by 2
for int is finite, the repeated doubling will eventually produce a value greater than the largest value
an int can represent. We call such a phenomenon an overflow. If doubling is the cause of overflow,
the value of the int variable immediately after the overflow is negative. Therefore, the program
uses the continuation condition while ( number >= 0 ) in the while-loop (Line 10). Lines
6-8 are responsible for receiving the initial value from the user. To ensure that the initial value is
strictly positive, the program substitutes a nonpositive input with 1. This conditional substitution
is accomplished using the assignment number = Math.max( 1, number ) (Line 9). In the
loop-body, the program reports the value of number (Line 12). An overflow will occur at Line
13, after reporting the value of number prior to doubling. Therefore, to report the negative value
generated, the program has another statement to report the value of number (Line 15). — Listing 11.4 A program that demonstrates an overflow with multiplication by 2 for int is finite, the repeated doubling will eventually produce a value greater than the largest value an int can represent. We call such a phenomenon an overflow. If doubling is the cause of overflow, the value of the int variable immediately after the overflow is negative. Therefore, the program uses the continuation condition while ( number >= 0 ) in the while-loop (Line 10). Lines 6-8 are responsible for receiving the initial value from the user. To ensure that the initial value is strictly positive, the program substitutes a nonpositive input with 1. This conditional substitution is accomplished using the assignment number = Math.max( 1, number ) (Line 9). In the loop-body, the program reports the value of number (Line 12). An overflow will occur at Line 13, after reporting the value of number prior to doubling. Therefore, to report the negative value generated, the program has another statement to report the value of number (Line 15).

Here, token is the input that the user enters when given a prompt for the coin type, and so
token.charAt( 0 ) is the very first character of the input. The switch statement examines this
character and takes an appropriate action. The user may enter more characters after the first one, but
those extraneous characters are ignored. After exiting the loop, the program reports the total deposit
(Line 28) and announces that the user can make a purchase (Line 29).

Here is an execution example of the nroscram:
To determine the value of inc, the program uses a switch statement: — Here, token is the input that the user enters when given a prompt for the coin type, and so token.charAt( 0 ) is the very first character of the input. The switch statement examines this character and takes an appropriate action. The user may enter more characters after the first one, but those extraneous characters are ignored. After exiting the loop, the program reports the total deposit (Line 28) and announces that the user can make a purchase (Line 29). Here is an execution example of the nroscram: To determine the value of inc, the program uses a switch statement:

Listing 11.5 A program that mimics the process of depositing coins in a vending machine

.isting 11.7 A program that tests the Collatz Conjecture (part 2). A part that performs the test on one number
The method test has an int data named input as its formal parameter (Line 16). The method
uses a variable named number and applies the transformation rule to the value stored in number.
The initial value of number is equal to the value of input. The method uses a variable named
round to record how many times the transformation rule has been applied to the input. The initial
value of round is 0. The declarations and initializations of the two variables appear in Line 18.
After reporting the value of input (Line 19), the method enters a while-loop with the continuation
condition number > 1 (Line 20). The loop terminates when the value of number becomes less
than or equal to 1. In the loop-body, the method applies the transformation rule using the method
update, replaces the value of number with the value returned (Line 22), adds | to round (Line
23), and reports the values of round and number (Line 24). To report the value of round, the
method allocates 4 character spaces. — .isting 11.7 A program that tests the Collatz Conjecture (part 2). A part that performs the test on one number The method test has an int data named input as its formal parameter (Line 16). The method uses a variable named number and applies the transformation rule to the value stored in number. The initial value of number is equal to the value of input. The method uses a variable named round to record how many times the transformation rule has been applied to the input. The initial value of round is 0. The declarations and initializations of the two variables appear in Line 18. After reporting the value of input (Line 19), the method enters a while-loop with the continuation condition number > 1 (Line 20). The loop terminates when the value of number becomes less than or equal to 1. In the loop-body, the method applies the transformation rule using the method update, replaces the value of number with the value returned (Line 22), adds | to round (Line 23), and reports the values of round and number (Line 24). To report the value of round, the method allocates 4 character spaces.

Here are some execution examples of the program:

Here is an execution example of the code:

Listing 11.9 A program that obtains the binary representation of a nonnegative integer

Here are some execution examples with additional output:

Listing 11.10 A program that obtains the binary representation of a nonnegative integer while showing the progress
on the calculation — Listing 11.10 A program that obtains the binary representation of a nonnegative integer while showing the progress on the calculation

11.1.7 Infinite Loops and Their Termination
An infinite loop is a loop that is designated to run forever. An infinite loop is constructed with t rue a:
the continuation condition. An infinite loop usually has a condition for termination inside the body. Ir
Sect. 7.5.2, we saw the use of break to terminate a for-loop. break can be used to terminate a while-
loop as well. Consider computing the number of times a pattern represented by a St ring variable
named pattern appears in an input String variable named input. We can use an infinite loop fo:
the task. We use a variable named pos to maintain the start position of the search in input. We alsc
use a variable named count to record the number of occurrences of the pattern. The initial value i:
0 for both pos and count. We use input .indexOf( pattern, pos ) to check whether o1
not pattern appears in input at or after position pos. If the return value of indexOf is negative
we terminate the loop; otherwise, the return value is the position at which pattern appears, so we
add one to count and update the value of pos with the returned value plus |. The following code
captures this idea: — 11.1.7 Infinite Loops and Their Termination An infinite loop is a loop that is designated to run forever. An infinite loop is constructed with t rue a: the continuation condition. An infinite loop usually has a condition for termination inside the body. Ir Sect. 7.5.2, we saw the use of break to terminate a for-loop. break can be used to terminate a while- loop as well. Consider computing the number of times a pattern represented by a St ring variable named pattern appears in an input String variable named input. We can use an infinite loop fo: the task. We use a variable named pos to maintain the start position of the search in input. We alsc use a variable named count to record the number of occurrences of the pattern. The initial value i: 0 for both pos and count. We use input .indexOf( pattern, pos ) to check whether o1 not pattern appears in input at or after position pos. If the return value of indexOf is negative we terminate the loop; otherwise, the return value is the position at which pattern appears, so we add one to count and update the value of pos with the returned value plus |. The following code captures this idea:

11.2.2 “Waiting for Godot”
——— EO ———Oee

Consider receiving a series of tokens from the user until the user enters “Godot”, when the
execution terminates (where, of course, the “Godot” comes from a play by Samuel Beckett? titled
Waiting for Godot). We store the user input to a String variable named input, and build a do-
while loop using the condition !input.equals( "Godot" ). In other words, the program will
run until the user enters "Godot". — 11.2.2 “Waiting for Godot” ——— EO ———Oee Consider receiving a series of tokens from the user until the user enters “Godot”, when the execution terminates (where, of course, the “Godot” comes from a play by Samuel Beckett? titled Waiting for Godot). We store the user input to a String variable named input, and build a do- while loop using the condition !input.equals( "Godot" ). In other words, the program will run until the user enters "Godot".

Listing 11.11 A program that obtains the binary representation of a nonnegative integer using a do-while loop (part 1)
Listing 11.12 A program that obtains the binary representation of a nonnegative integer using a do-while loop (part 2) — Listing 11.11 A program that obtains the binary representation of a nonnegative integer using a do-while loop (part 1) Listing 11.12 A program that obtains the binary representation of a nonnegative integer using a do-while loop (part 2)

The while-loop appears in Lines 9-14. At the end, the program prints the number of inputs entered
and their total. — The while-loop appears in Lines 9-14. At the end, the program prints the number of inputs entered and their total.

Here is one execution of the program. The inputs are: 10, 11, 12, 13, and 14. Each input line i
followed by the return key. After entering 14 followed by the return key, the user presses CTRL-D
The CTRL-D does not echo. — Here is one execution of the program. The inputs are: 10, 11, 12, 13, and 14. Each input line i followed by the return key. After entering 14 followed by the return key, the user presses CTRL-D The CTRL-D does not echo.

Arrays are objects, so before accessing their individual elements, they must be instantiated. Ar
array is instantiated with its number of elements. We call the number of elements in an array the
length or size of the array. The length specification appears inside a pair of square brackets [] afte:
the type specification of the individual elements. Examples of the length specification are showr
next. Line 4 instantiates a 10-element array of int values, Line 5 instantiates a 17-element array o:
String values, and Line 6 instantiates a 40-element array of double values.
© Springer Nature Switzerland AG 2018
M. Ogihara, Fundamentals of Java Programming,
https://doi.org/10.1007/978-3-319-89491-1 12 — Arrays are objects, so before accessing their individual elements, they must be instantiated. Ar array is instantiated with its number of elements. We call the number of elements in an array the length or size of the array. The length specification appears inside a pair of square brackets [] afte: the type specification of the individual elements. Examples of the length specification are showr next. Line 4 instantiates a 10-element array of int values, Line 5 instantiates a 17-element array o: String values, and Line 6 instantiates a 40-element array of double values. © Springer Nature Switzerland AG 2018 M. Ogihara, Fundamentals of Java Programming, https://doi.org/10.1007/978-3-319-89491-1 12

AN eS MDE een eres NING ewan ee aearee ee AAMETRuYE Oras entre Nn! MURS TT SENOS eNN eens Sn tne ae Siew ERMA Inrsn ner Socwaenrcnes YemrranGn go nneen enrvorinee Seietnwas smo eh nse setae cane pune

Here is the first part of the source code, where the program receives the scores. The program
leclares an int array counts and instantiates it as an 11-element array (Line 8). The program asks
he user to start entering numbers and enter CTRL-D to report the end of input (Lines 10 and 11).
[o receive input, the program uses a while-loop with keyboard.hasNext () as the continuation
‘ondition. As we saw in Chap. 11, keyboard.hasNext () returns false only when the user
nters CTRL-D at the start of the input sequence. In the loop-body, the program receives a new score
ising keyboard.nextInt (), and then stores it in the variable score (Line 14). The program
letermines the index of the bin in the manner we have discussed, and then stores it in the variable
o9osition (Line 15). The program then increases counts[ position ] by 1 (Line 16).
The program must produce two types of output from the counts thus obtained, a numerical output
and a bar-histogram. In both outputs, the program uses the numbers 0, 10, ..., 90, 100 as the
representatives of the bins. These representative numbers are equal to ten times the indexes to the
bins. In the bar-histogram output, the program prints a horizontal line of hash marks for each bin. The
lengths of the lines are equal to the counts. The histogram can be generated using a double for-loop. — AN eS MDE een eres NING ewan ee aearee ee AAMETRuYE Oras entre Nn! MURS TT SENOS eNN eens Sn tne ae Siew ERMA Inrsn ner Socwaenrcnes YemrranGn go nneen enrvorinee Seietnwas smo eh nse setae cane pune Here is the first part of the source code, where the program receives the scores. The program leclares an int array counts and instantiates it as an 11-element array (Line 8). The program asks he user to start entering numbers and enter CTRL-D to report the end of input (Lines 10 and 11). [o receive input, the program uses a while-loop with keyboard.hasNext () as the continuation ‘ondition. As we saw in Chap. 11, keyboard.hasNext () returns false only when the user nters CTRL-D at the start of the input sequence. In the loop-body, the program receives a new score ising keyboard.nextInt (), and then stores it in the variable score (Line 14). The program letermines the index of the bin in the manner we have discussed, and then stores it in the variable o9osition (Line 15). The program then increases counts[ position ] by 1 (Line 16). The program must produce two types of output from the counts thus obtained, a numerical output and a bar-histogram. In both outputs, the program uses the numbers 0, 10, ..., 90, 100 as the representatives of the bins. These representative numbers are equal to ten times the indexes to the bins. In the bar-histogram output, the program prints a horizontal line of hash marks for each bin. The lengths of the lines are equal to the counts. The histogram can be generated using a double for-loop.

Listing 12.2 A program for computing the distribution of scores in range 0..100 (part 2).

Listing 12.3 A program for computing a cumulative distribution (part 1).

Listing 12.4 A program for computing a cumulative distribution (part 2).

With the same input sequence as before, the program produces the following output:
12.1.2.2 Simulating the Action of Throwing Two Dice
Our next example is a program for computing, by simulation, the probability distribution of the
number that is “rolled” by “throwing” two fair dice. The number that is “rolled” ranges from 2 to
12. The program simulates the action of throwing two dice repeatedly, and computes the frequencies
that these numbers are “rolled”. At the end, the frequencies are converted to percentages. The program
receives how many “rolls” must be made from the user. — With the same input sequence as before, the program produces the following output: 12.1.2.2 Simulating the Action of Throwing Two Dice Our next example is a program for computing, by simulation, the probability distribution of the number that is “rolled” by “throwing” two fair dice. The number that is “rolled” ranges from 2 to 12. The program simulates the action of throwing two dice repeatedly, and computes the frequencies that these numbers are “rolled”. At the end, the frequencies are converted to percentages. The program receives how many “rolls” must be made from the user.

Listing 12.5 A program that simulated the action of throwing two dice (part 1).
By combining the two occurrences of +1, we obtain: — Listing 12.5 A program that simulated the action of throwing two dice (part 1). By combining the two occurrences of +1, we obtain:

Here is the result of running the program with one million throws:

Here is the result of running the program with 10,000 throws:
Listing 12.6 A program that simulated the action of throwing two dice (part 2). — Here is the result of running the program with 10,000 throws: Listing 12.6 A program that simulated the action of throwing two dice (part 2).

In the following execution example, the user enters a non-existing index 9 for a 9-element array,
thereby makes ArrayIndexOutOfBoundsException occur. — In the following execution example, the user enters a non-existing index 9 for a 9-element array, thereby makes ArrayIndexOutOfBoundsException occur.

Listing 12.7 A program that builds an array of String data and then presents its contents.

Listing 12.11 A program that counts the occurrences of letters (part 2). The part responsible for generating counts.

Listing 12.12 A program that counts the occurrences of letters (part 3). The part responsible for printing the result.
To present the result, the program prints the input line (Line 22), the lowercase version (Line
23), and a header line (Line 24). The program then uses a for-loop that iterates over the sequence
0, ..., 25 with a variable named index (Line 25). The character represented by index is
obtained by converting the relative index to its absolute index with the addition of a’ , and then casting
of (char) on the absolute index. In other words, (char) ( ‘a’ + index ) produces the letter
(Line 28). The count corresponding to the letter is count [ index ] (Line 28). The program prints
the letter and the count using printf with the format of "6c: %2d%n" (Line 27). The format
instructs to allocate six character spaces to the letter and two character spaces to the count. — Listing 12.12 A program that counts the occurrences of letters (part 3). The part responsible for printing the result. To present the result, the program prints the input line (Line 22), the lowercase version (Line 23), and a header line (Line 24). The program then uses a for-loop that iterates over the sequence 0, ..., 25 with a variable named index (Line 25). The character represented by index is obtained by converting the relative index to its absolute index with the addition of a’ , and then casting of (char) on the absolute index. In other words, (char) ( ‘a’ + index ) produces the letter (Line 28). The count corresponding to the letter is count [ index ] (Line 28). The program prints the letter and the count using printf with the format of "6c: %2d%n" (Line 27). The format instructs to allocate six character spaces to the letter and two character spaces to the count.

Next is an execution example of the code:

In this example, since the input line is short, several letters have 0 as their counts. Since each letter-
count pair does not require more than 12 character spaces, we can expect to be able to reduce the
number of output lines by skipping letters whose counts are O and by printing multiple letter-count
pairs in each line of output. — In this example, since the input line is short, several letters have 0 as their counts. Since each letter- count pair does not require more than 12 character spaces, we can expect to be able to reduce the number of output lines by skipping letters whose counts are O and by printing multiple letter-count pairs in each line of output.

Here is the output with another input:
The output of the new program with the same input as before is shown next:
Listing 12.13 A new version of the program that counts the occurrences of letters. — Here is the output with another input: The output of the new program with the same input as before is shown next: Listing 12.13 A new version of the program that counts the occurrences of letters.

Since the value of flags[ n ] does not change from false to true, the loop can be
terminated as soon as the value changes to false: — Since the value of flags[ n ] does not change from false to true, the loop can be terminated as soon as the value changes to false:

Listing 12.14 A program that finds all prime numbers less than or equal to a given bound.

Listing 12.15 A program that receives names and scores and performs search (part 1).
To retrieve scores, the program receives two double values from the user, and stores them in
double variables, Low and high (Lines 27-29). The program uses a variable named count to
record the number of scores that have passed the test (Line 31). The program uses a for-loop that iter-
ates over the sequence of valid index values with a variable named i (Line 32). For each index value of
i, the program stores the valueof ( scores[ i ] >= low && scores[ i ] <= high )
inflags[ i ] (Line 34), and then, if the value obtained is true (Line 35), increases the value of
count by | (Line 37). The program announces the value of count after completing the recalculation
of the elements in flags (Line 40). To report which scores are in the range, the program uses
a for-loop again with the iteration variable i (Line 42). If flags[ i ] has the value of true
(Line 44), the program prints i, names[ i ], and scores[ i ] in one line using the format
"$3d %10s %6.2£%n". This means that three character spaces are allocated for i, ten character — Listing 12.15 A program that receives names and scores and performs search (part 1). To retrieve scores, the program receives two double values from the user, and stores them in double variables, Low and high (Lines 27-29). The program uses a variable named count to record the number of scores that have passed the test (Line 31). The program uses a for-loop that iter- ates over the sequence of valid index values with a variable named i (Line 32). For each index value of i, the program stores the valueof ( scores[ i ] >= low && scores[ i ] <= high ) inflags[ i ] (Line 34), and then, if the value obtained is true (Line 35), increases the value of count by | (Line 37). The program announces the value of count after completing the recalculation of the elements in flags (Line 40). To report which scores are in the range, the program uses a for-loop again with the iteration variable i (Line 42). If flags[ i ] has the value of true (Line 44), the program prints i, names[ i ], and scores[ i ] in one line using the format "$3d %10s %6.2£%n". This means that three character spaces are allocated for i, ten character

Here is an example of how the program works:

Listing 12.17 A program that receives names and scores and performs search (part 3).

Since the tokens are separated by tab-stops, sp1it can be used as follows:

Write a program, St dDev that generates an array of random real numbers greater than or equal
to 0 and less than 10,000, and then computes the standard deviation of the elements in the array.
The user specifies the length of the array. Since the formula has n — | in the denominator, the
length of the array must be greater than or equal to 2. To obtain an integer greater than or equal
to 2, the program keeps asking the user to enter a value for the length until the value entered is
greater than or equal to 2. After the calculation, the program must print the elements in the array,
the average, and the standard deviation. Each real number, when printed, must be formatted by
allocating four character spaces before the decimal point and ten digits after the decimal point.
The following is an execution example of the prosram: — Write a program, St dDev that generates an array of random real numbers greater than or equal to 0 and less than 10,000, and then computes the standard deviation of the elements in the array. The user specifies the length of the array. Since the formula has n — | in the denominator, the length of the array must be greater than or equal to 2. To obtain an integer greater than or equal to 2, the program keeps asking the user to enter a value for the length until the value entered is greater than or equal to 2. After the calculation, the program must print the elements in the array, the average, and the standard deviation. Each real number, when printed, must be formatted by allocating four character spaces before the decimal point and ten digits after the decimal point. The following is an execution example of the prosram:

Listing 13.1 A program that demonstrates the use of methods from class Arrays (part 1). The method for printing
an array — Listing 13.1 A program that demonstrates the use of methods from class Arrays (part 1). The method for printing an array

Listing 13.2 A program that demonstrates the use of methods from class Arrays (part 2). The method for randomly
generating a (gibberish) character sequence of length len — Listing 13.2 A program that demonstrates the use of methods from class Arrays (part 2). The method for randomly generating a (gibberish) character sequence of length len

Listing 13.3. A program that demonstrates the use of methods from class Arrays (part 3). The method main
rhe code for the method main is presented next, with the calls to Arrays methods highlighted: — Listing 13.3. A program that demonstrates the use of methods from class Arrays (part 3). The method main rhe code for the method main is presented next, with the calls to Arrays methods highlighted:

Figure 13.1 illustrates the series of actions performed on the array elements.

Listing 13.5 A program that swaps elements between two positions in an array (part 2). The method main

The result of executing the code is as follows:

Listing 13.6 A program that performs cyclic shifting (part 1). The method printArray

Listing 13.7 A program that performs cyclic shifting (part 2). The method for left cyclic shifting

Listing 13.9 A program that performs cyclic shifting (part 4). The method main

Listing 13.10 A program that demonstrates resizing of an array (part 1). The class header and the method insert

Listing 13.11 A program that demonstrates resizing of an array (part 2). The method remove

In the method main, the program receives the initial length of the array from the user (Line 37),
instantiates a new array with the number of elements specified by the user (Line 38), and then receives
the initial elements that to be stored in the array from the user (Lines 40-44). The variable pos to
specify a position in the array is declared outside the for-loop (Line 39). This variable is used in other
places of the code.
Two String variables, value and answer, are used for interaction (Line 46). The available
actions are presented with the first letters of the names of the actions. The first letters of the action
names are ‘I’, 'R’, ‘'V’, and ’Q’ (Lines 49). The user enters an action to be performed as a
String value, and this is stored in answer (Line 50). To direct the execution, the program uses an
if-else statement (Line 51)

-— os - — a Uk le xe e ee ee eon a woe a 7m —. awe remeone: — In the method main, the program receives the initial length of the array from the user (Line 37), instantiates a new array with the number of elements specified by the user (Line 38), and then receives the initial elements that to be stored in the array from the user (Lines 40-44). The variable pos to specify a position in the array is declared outside the for-loop (Line 39). This variable is used in other places of the code. Two String variables, value and answer, are used for interaction (Line 46). The available actions are presented with the first letters of the names of the actions. The first letters of the action names are ‘I’, 'R’, ‘'V’, and ’Q’ (Lines 49). The user enters an action to be performed as a String value, and this is stored in answer (Line 50). To direct the execution, the program uses an if-else statement (Line 51) -— os - — a Uk le xe e ee ee eon a woe a 7m —. awe remeone:

In the following execution example, the user enters the last names of eight of his favorite operatic
singers: George London, Dietrich Fischer-Dieskau, Astrid Varnay, Karita Mattila, Renee Fleming,
Birgit Nilsson, Wolfgang Windgassen, and Ben Heppner. The user makes some changes by adding
Christa Ludwig, removing Windgassen, and then adding Elisabeth Schwartzkopf.” Note that the array
length is 8 at the start and the index position of the last element is 7, so to append the element at the
end, the user enters 8. — In the following execution example, the user enters the last names of eight of his favorite operatic singers: George London, Dietrich Fischer-Dieskau, Astrid Varnay, Karita Mattila, Renee Fleming, Birgit Nilsson, Wolfgang Windgassen, and Ben Heppner. The user makes some changes by adding Christa Ludwig, removing Windgassen, and then adding Elisabeth Schwartzkopf.” Note that the array length is 8 at the start and the index position of the last element is 7, so to append the element at the end, the user enters 8.

Searching in an array is the problem of checking, given some array a and a data key, if key is already
an element of a. A simple solution to the problem is to examine the elements of the array in order.
Such search is called the sequential search. Suppose that a is an array of String data and key is a
String value. A sequential search can be executed as follows:
The value of found represents whether or not a match has been found. The value of i at the end
is the location of the first match. If there is no match, the value of i at the end is a. length. We
can convert the code fragment to a method that reports the outcome with an int return value. The
conversion needs two return statements. One substitutes the action inside the if-statement and the
other substitutes the action after the for-loop. Typically, the internal one returns the index at which <
match is found, the external one returns a special value, e.g., -1. — Searching in an array is the problem of checking, given some array a and a data key, if key is already an element of a. A simple solution to the problem is to examine the elements of the array in order. Such search is called the sequential search. Suppose that a is an array of String data and key is a String value. A sequential search can be executed as follows: The value of found represents whether or not a match has been found. The value of i at the end is the location of the first match. If there is no match, the value of i at the end is a. length. We can convert the code fragment to a method that reports the outcome with an int return value. The conversion needs two return statements. One substitutes the action inside the if-statement and the other substitutes the action after the for-loop. Typically, the internal one returns the index at which < match is found, the external one returns a special value, e.g., -1.

3.5 Searching for an Element in an Array

The program FixedSizeUnsorted is an example of arrays with capacity and size. The
application receives an initial set of String data from the user, and then interacts with the user
to make modifications and perform examinations on the data. The operations that are available on the
data are adding elements in succession, removing one element, viewing the collection, and searching
for all the elements matching a key specified by the user. The program uses four global variables,
String[] theNames,int capacity,int size,andScanner keyboard (Lines 6-10).
The variables represent the array, the capacity of the array, the size of the array, and the keyboard
with which to receive input from the user. The method main consists of two method calls: setup
(Line 12), for setting up the initial array, and action (Line 13), for performing the interaction with
the neer — The program FixedSizeUnsorted is an example of arrays with capacity and size. The application receives an initial set of String data from the user, and then interacts with the user to make modifications and perform examinations on the data. The operations that are available on the data are adding elements in succession, removing one element, viewing the collection, and searching for all the elements matching a key specified by the user. The program uses four global variables, String[] theNames,int capacity,int size,andScanner keyboard (Lines 6-10). The variables represent the array, the capacity of the array, the size of the array, and the keyboard with which to receive input from the user. The method main consists of two method calls: setup (Line 12), for setting up the initial array, and action (Line 13), for performing the interaction with the neer

Listing 13.17 A program that uses an array with capacity and size (part 3). The method that interacts with the user for
modifications and examinations — Listing 13.17 A program that uses an array with capacity and size (part 3). The method that interacts with the user for modifications and examinations

If there is no space left, the program prints an error message (Line 98).

4Diana Jean Krall (born November 16, 1964) is a Canadian jazz pianist and singer. She is an Officer of the Order of
Canada and an officer of the Order of British Columbia, Canada. Dianne Reeves (born October 23, 1956) is an American
jazz singer. Sarah Lois Vaughan (March 27, 1924 to April 3, 1990) was an American jazz singer. Cassandra Wilson (born
December 4, 1955) is an American jazz musician, vocalist, songwriter, and producer. Nancy Wilson (born February 20,
1937) is an American singer, who has won three Grammy awards. Norma Ann Winstone (born 23 September 1941) is
a British jazz singer and lyricist. She has the rank Most Excellent Order of the British Empire.
Listing 13.20 A program that uses an array with capacity and size (part 6). The method for removing an element — 4Diana Jean Krall (born November 16, 1964) is a Canadian jazz pianist and singer. She is an Officer of the Order of Canada and an officer of the Order of British Columbia, Canada. Dianne Reeves (born October 23, 1956) is an American jazz singer. Sarah Lois Vaughan (March 27, 1924 to April 3, 1990) was an American jazz singer. Cassandra Wilson (born December 4, 1955) is an American jazz musician, vocalist, songwriter, and producer. Nancy Wilson (born February 20, 1937) is an American singer, who has won three Grammy awards. Norma Ann Winstone (born 23 September 1941) is a British jazz singer and lyricist. She has the rank Most Excellent Order of the British Empire. Listing 13.20 A program that uses an array with capacity and size (part 6). The method for removing an element

|. A method that checks some property of an array, 1

Programming Projects
A simple merge of three arrays Write a program, SimpleThreeMerge, that generates three
arrays of random integers with identical lengths, and then merges the three into one. The user
specifies the length as well as the range of the values of the array elements. The array generated
by merging should be three times as long as the individual arrays. The array should contain the
elements of the first array in the first third in the order they appear, the elements of the second
array in the second third in the order they appear, and the elements of the third array in the last
third in the order they appear. The program must print the elements of the individual arrays as
well as the elements of the array that contains all three. Design and use a method for printing the
elements of an array of int values. The format is five elements per line, 12 character spaces per
element, flush right, and without currency punctuation. Since the longest int without punctuation
requires 11 character spaces, this should put at least once space between the elements in the same
line. The program may run as follows: — Programming Projects A simple merge of three arrays Write a program, SimpleThreeMerge, that generates three arrays of random integers with identical lengths, and then merges the three into one. The user specifies the length as well as the range of the values of the array elements. The array generated by merging should be three times as long as the individual arrays. The array should contain the elements of the first array in the first third in the order they appear, the elements of the second array in the second third in the order they appear, and the elements of the third array in the last third in the order they appear. The program must print the elements of the individual arrays as well as the elements of the array that contains all three. Design and use a method for printing the elements of an array of int values. The format is five elements per line, 12 character spaces per element, flush right, and without currency punctuation. Since the longest int without punctuation requires 11 character spaces, this should put at least once space between the elements in the same line. The program may run as follows:

Reading doub1e tokens and quantifying changes Write a program, NumberTokens, that
receives a sequence of floating point numbers of an indefinite length from the user, and reporting
the results of comparing the numbers after the first one to their immediate predecessors. The
comparison has three outcomes: 'U’ to mean “significantly greater than the predecessor", ’D’ to
mean “significantly smaller than the predecessor", and “neither”. The “significance” of difference
is measured by the absolute difference compared to a fixed positive threshold. In other words, the
present value is significantly greater than its predecessor if the present value is greater than the
predecessor plus the threshold, and the present value is significantly smaller than its predecessor
if the present value is smaller than the predecessor minus the threshold. The threshold is entered
after the input number sequence is entered, so the input sequence must be stored in an array.
The program may run as follows: — Reading doub1e tokens and quantifying changes Write a program, NumberTokens, that receives a sequence of floating point numbers of an indefinite length from the user, and reporting the results of comparing the numbers after the first one to their immediate predecessors. The comparison has three outcomes: 'U’ to mean “significantly greater than the predecessor", ’D’ to mean “significantly smaller than the predecessor", and “neither”. The “significance” of difference is measured by the absolute difference compared to a fixed positive threshold. In other words, the present value is significantly greater than its predecessor if the present value is greater than the predecessor plus the threshold, and the present value is significantly smaller than its predecessor if the present value is smaller than the predecessor minus the threshold. The threshold is entered after the input number sequence is entered, so the input sequence must be stored in an array. The program may run as follows:

(be

Fig. 14.1 The structure of a multi-dimensional array. The word “nulll” indicates subarrays that are nul 1 — (be Fig. 14.1 The structure of a multi-dimensional array. The word “nulll” indicates subarrays that are nul 1

receives the elements of the array from the user (Lines 13-17), and then returns the array (Line 18).
Listing 14.1 A program that computing partial sums using a two-dimensional array (part 1). The method readData — receives the elements of the array from the user (Lines 13-17), and then returns the array (Line 18). Listing 14.1 A program that computing partial sums using a two-dimensional array (part 1). The method readData

Listing 14.3 A program that computing partial sums using a two-dimensional array (part 3). The method print
The method print is for printing the data of a two-dimensional array (Line 38). The program uses
a double for-loop to generate row-column index pairs with variables rowPos and col Pos (Lines 40
and 42), and then prints twoD[ rowPos ][ colPos ] using the format 5d (Line 44). At the
end of each row, the method prints the newline (Line 46). — Listing 14.3 A program that computing partial sums using a two-dimensional array (part 3). The method print The method print is for printing the data of a two-dimensional array (Line 38). The program uses a double for-loop to generate row-column index pairs with variables rowPos and col Pos (Lines 40 and 42), and then prints twoD[ rowPos ][ colPos ] using the format 5d (Line 44). At the end of each row, the method prints the newline (Line 46).

program instantiates a two-dimensional array as oneD. length by oneD. length (Line 24). The
method then executes a double for-loop to fill this array. The external for-loop generates the row
index with a variable named rowPos (Line 25). For each value of rowPos, the method stores
oneD[ rowPos ] in twoD[ rowPos ][ rowPos ] (Line 27), and then using an internal
for-loop, generates the column index values rowPos + 1, ..., oneD.length - 1 witha
variable named colPos (Line 28), and stores twoD[ rowPos ][ colPos - 1 ] +oneD
[ colPos ] intwoD[ rowPos ][ colPos ] (Lines 30 and 31). After the double for-loop,
the method returns twoD (Line 34).
Listing 14.2 A program that computing partial sums using a two-dimensional array (part 2). The method
partialsAll — program instantiates a two-dimensional array as oneD. length by oneD. length (Line 24). The method then executes a double for-loop to fill this array. The external for-loop generates the row index with a variable named rowPos (Line 25). For each value of rowPos, the method stores oneD[ rowPos ] in twoD[ rowPos ][ rowPos ] (Line 27), and then using an internal for-loop, generates the column index values rowPos + 1, ..., oneD.length - 1 witha variable named colPos (Line 28), and stores twoD[ rowPos ][ colPos - 1 ] +oneD [ colPos ] intwoD[ rowPos ][ colPos ] (Lines 30 and 31). After the double for-loop, the method returns twoD (Line 34). Listing 14.2 A program that computing partial sums using a two-dimensional array (part 2). The method partialsAll

Alternatively, the three method calls appearing in the method main can be combined into one:

The next is the part for receiving the names and scores. The program uses a for-loop that
iterates over the sequence 0, ..., nPeople - 1 with a variable named index. At each
round, the program receives the name of the person (Lines 17 and 18), receives the number of
scores for that person, stores the number in a variable named size (Lines 19 and 20), instantiates
data[ index ] withnew double[ size ] (Line 21), and then uses an interior for-loop to
generate column indexes 0, ..., Size - 1 witha variable named col (Line 23) to receive the
elements data[ index ][ 0], ..., data[ index ][ size - 1 ] (Line 25).
Listing 14.6 A program that receives the names and scores for a number of students and reports the averages of th
scores (part 2). The part responsible for receiving the names and the scores — The next is the part for receiving the names and scores. The program uses a for-loop that iterates over the sequence 0, ..., nPeople - 1 with a variable named index. At each round, the program receives the name of the person (Lines 17 and 18), receives the number of scores for that person, stores the number in a variable named size (Lines 19 and 20), instantiates data[ index ] withnew double[ size ] (Line 21), and then uses an interior for-loop to generate column indexes 0, ..., Size - 1 witha variable named col (Line 23) to receive the elements data[ index ][ 0], ..., data[ index ][ size - 1 ] (Line 25). Listing 14.6 A program that receives the names and scores for a number of students and reports the averages of th scores (part 2). The part responsible for receiving the names and the scores

Listing 14.7 A program that receives the names and scores for a number of students and reports the averages of the
scores (part 3). The part responsible for computing the averages
The calculation of the averages requires a double for-loop. The external for-loop iterates over the
sequence 0, ..., nPeople - 1 witha variable named index (Line 29). The internal for-loop
iterates over the sequence 0, ..., data[ index ].length - 1 witha variable named col
(Line 31). The program stores the total of the scores appearing in that row in average[ index ]
(Line 33). Then, with the division by data[ index ].length, the program scales the total
stored inaverage[ index ] to the average. — Listing 14.7 A program that receives the names and scores for a number of students and reports the averages of the scores (part 3). The part responsible for computing the averages The calculation of the averages requires a double for-loop. The external for-loop iterates over the sequence 0, ..., nPeople - 1 witha variable named index (Line 29). The internal for-loop iterates over the sequence 0, ..., data[ index ].length - 1 witha variable named col (Line 31). The program stores the total of the scores appearing in that row in average[ index ] (Line 33). Then, with the division by data[ index ].length, the program scales the total stored inaverage[ index ] to the average.

Listing 14.8 A program that receives the names and scores for a number of students and reports the averages of the
scores (part 4). The part responsible for reporting the results
Here is an execution example of the code. — Listing 14.8 A program that receives the names and scores for a number of students and reports the averages of the scores (part 4). The part responsible for reporting the results Here is an execution example of the code.

The absolute paths of the five File objects, in the order of appearance, are as follows:
15.1.2 File Methods — The absolute paths of the five File objects, in the order of appearance, are as follows: 15.1.2 File Methods

To simplify the description, we assume that the methods are applied to a File object £. All methods on this list take
no parameters, except for renameTo
Table 15.1 A list of File methods — To simplify the description, we assume that the methods are applied to a File object £. All methods on this list take no parameters, except for renameTo Table 15.1 A list of File methods

A method cannot have more than one throws declaration. This limitation creates an issue when
a method makes calls to multiple methods and they have different error types in their throws
declarations. Fortunately, the Java run-time error types are organized as a tree, so any common
ancestor of the different error types can be used as the error type in the throws declaration.
Exception is the error type at the root of the tree, so in a situation where different run-time errors
need to be handled, Exception can be used.
15.1.3.3 “Catching” a Run-Time Error
=

The other way to handle a formally declared run-time errors is to “catch” the error. The syntax for
“catching” a run-time error of type E that originates from a method call to N is as follows: enclose
a code block that includes the method call to N in a pair of curly brackets with a keyword try
preceding the open bracket, and then immediately after the close bracket, add another pair of brackets
preceded by a phrase catch (E e). Some code can be placed inside the second pair of brackets.
The lowercase letter e appearing in the parentheses represents an object representing the error that
has occurred.
has occurred. — A method cannot have more than one throws declaration. This limitation creates an issue when a method makes calls to multiple methods and they have different error types in their throws declarations. Fortunately, the Java run-time error types are organized as a tree, so any common ancestor of the different error types can be used as the error type in the throws declaration. Exception is the error type at the root of the tree, so in a situation where different run-time errors need to be handled, Exception can be used. 15.1.3.3 “Catching” a Run-Time Error = The other way to handle a formally declared run-time errors is to “catch” the error. The syntax for “catching” a run-time error of type E that originates from a method call to N is as follows: enclose a code block that includes the method call to N in a pair of curly brackets with a keyword try preceding the open bracket, and then immediately after the close bracket, add another pair of brackets preceded by a phrase catch (E e). Some code can be placed inside the second pair of brackets. The lowercase letter e appearing in the parentheses represents an object representing the error that has occurred. has occurred.

Listing 15.2 A program that demonstrates the use of File methods for creating, deleting, and renaming files (part
1). The method showExistence — Listing 15.2 A program that demonstrates the use of File methods for creating, deleting, and renaming files (part 1). The method showExistence

Listing 15.4 A program that demonstrates the use of File methods for creating, deleting, and renaming files (part 3).
The method main
LSS Se Sa ee, ee: eee ee ee Re ee) See nee ee

The program handles IOException that may originate from creat ionPlay (Line 53) using
try-catch. If creationPlay produces a run-time error of IOException, the execution
jumps to Line 53 without executing Line 51. There are two actions to be performed in the catch
block. One is to print the information stored in e. This is accomplished by the method call
e.printStackTrace() (Line 55). This method is available for all data types representing run-
time errors. The method prints the series of method calls, starting from main, that have ultimately
resulted in the run-time error at hand. The other action to be performed is to print a message to inform
that a run-time error has occurred (Line 56). After producing the message on the screen, the program
terminates because there is no statement after the catch block. — Listing 15.4 A program that demonstrates the use of File methods for creating, deleting, and renaming files (part 3). The method main LSS Se Sa ee, ee: eee ee ee Re ee) See nee ee The program handles IOException that may originate from creat ionPlay (Line 53) using try-catch. If creationPlay produces a run-time error of IOException, the execution jumps to Line 53 without executing Line 51. There are two actions to be performed in the catch block. One is to print the information stored in e. This is accomplished by the method call e.printStackTrace() (Line 55). This method is available for all data types representing run- time errors. The method prints the series of method calls, starting from main, that have ultimately resulted in the run-time error at hand. The other action to be performed is to print a message to inform that a run-time error has occurred (Line 56). After producing the message on the screen, the program terminates because there is no statement after the catch block.

After these array instantiations, the method examines the files appearing in the list. Using
a for-loop, the method generates the index sequence 0, ..., list.length - 1 with
a variable named i. At each round, the method executes the five tests, canExecute,
canRead, canRead, isDirectory, and isFile, in this order, and stores the results in
flags[ i][0], ..., flags[ i ][ 4 ] (Lines 14-18). The program also obtains
the file length and the file name using the methods length and getName, and stores the returned
values in their respective arrays, size and name.
Listing 15.5 A program that demonstrates the use of File methods for examining properties of files (part 1). The
part responsible for taking the inventory — After these array instantiations, the method examines the files appearing in the list. Using a for-loop, the method generates the index sequence 0, ..., list.length - 1 with a variable named i. At each round, the method executes the five tests, canExecute, canRead, canRead, isDirectory, and isFile, in this order, and stores the results in flags[ i][0], ..., flags[ i ][ 4 ] (Lines 14-18). The program also obtains the file length and the file name using the methods length and getName, and stores the returned values in their respective arrays, size and name. Listing 15.5 A program that demonstrates the use of File methods for examining properties of files (part 1). The part responsible for taking the inventory

Listing 15.6 A program that demonstrates the use of File methods for examining properties of files (part 2). The
part responsible for printing the results
The method prints the inventory thus obtained, but before that, the method prints the name of
home, the absolute path to home, the name of parent, and the absolute path to parent that are
obtained using the methods getName and getAbsolutePath (Lines 22-25). The method prints
the inventory one file per line. The information that it prints consists of the index to the file in the file
list, the five boolean values stored in the array flags, the file length, and the file name. The format
it uses is the following: — Listing 15.6 A program that demonstrates the use of File methods for examining properties of files (part 2). The part responsible for printing the results The method prints the inventory thus obtained, but before that, the method prints the name of home, the absolute path to home, the name of parent, and the absolute path to parent that are obtained using the methods getName and getAbsolutePath (Lines 22-25). The method prints the inventory one file per line. The information that it prints consists of the index to the file in the file list, the five boolean values stored in the array flags, the file length, and the file name. The format it uses is the following:

Here is the result of executing the code on the data file presented earlier.

People often use the “tab-delimited” format for data files. The following is a “tab-delimited”
version of the data file we have just used, where the number of people or the numbers of scores
does not appear. However, the information is presented one person per line and the entries in each line
are separated by a tab-stop.
Listing 15.10 A sample data file for the score reading data program. The file is without dimensional information — People often use the “tab-delimited” format for data files. The following is a “tab-delimited” version of the data file we have just used, where the number of people or the numbers of scores does not appear. However, the information is presented one person per line and the entries in each line are separated by a tab-stop. Listing 15.10 A sample data file for the score reading data program. The file is without dimensional information

We want to write new versions of USePositionZero, where the two coordinates are treated
as one unit. To accomplish this, we define an object class PositionFirst. An object of
PositionFirst has two data components, x and y, representing the x- and y-coordinates of
the position. Both x and y are int variables. They are declared as instance variables. Figure 16.2
visualizes the way PositionFirst encompasses the two instance variables in it. — We want to write new versions of USePositionZero, where the two coordinates are treated as one unit. To accomplish this, we define an object class PositionFirst. An object of PositionFirst has two data components, x and y, representing the x- and y-coordinates of the position. Both x and y are int variables. They are declared as instance variables. Figure 16.2 visualizes the way PositionFirst encompasses the two instance variables in it.

Listing 16.6 Class UsePositionPrivate (part 2)

Again, from the user’s point of view, the program works exactly the same way as before.
16.1.3 Using Constants in an Object Class — Again, from the user’s point of view, the program works exactly the same way as before. 16.1.3 Using Constants in an Object Class

Listing 16.16 A program that manipulates with a list of bank accounts (part 1). The methods deposit, withdraw,

WnA tog eye aA
The method deposit attempts to make a deposit of an amount given in the second parameter to
the account given in the first parameter (Line 4). To accomplish this, the method calls the instance
method deposit on the specified account, and then checks its return value (Line 6). If the return
value is false, the method prints an error message (Line 8).

Fe by n,n, re ee: ee, . . er. 7 — Listing 16.16 A program that manipulates with a list of bank accounts (part 1). The methods deposit, withdraw, WnA tog eye aA The method deposit attempts to make a deposit of an amount given in the second parameter to the account given in the first parameter (Line 4). To accomplish this, the method calls the instance method deposit on the specified account, and then checks its return value (Line 6). If the return value is false, the method prints an error message (Line 8). Fe by n,n, re ee: ee, . . er. 7

Listing 16.17 A program that manipulates with a list of bank accounts (part 2). The methods initial anc
actionPrompt
The method initial handles the initialization of the individual accounts on the list. The method
returns a BankAccount object (Line 33). The parameter of the method index is an int value
presumably representing the index to the bank account that is to be generated. The value index is
used just for presenting a prompt (Line 37). The method receives the name using next Line (Line
38), and the initial balance (Lines 39 and 40). The method uses next Line to receive an input line,
and then converts the input line to an int value using Integer.parseInt. The method then
combines the values to instantiate a BankAccount object, and then returns this object.

Tha mathnd avnttAnnDrrnmnt nnnta tha nramnt Tha mathnd roanaiwvacd an arrawu anf Danlnavnnniint — Listing 16.17 A program that manipulates with a list of bank accounts (part 2). The methods initial anc actionPrompt The method initial handles the initialization of the individual accounts on the list. The method returns a BankAccount object (Line 33). The parameter of the method index is an int value presumably representing the index to the bank account that is to be generated. The value index is used just for presenting a prompt (Line 37). The method receives the name using next Line (Line 38), and the initial balance (Lines 39 and 40). The method uses next Line to receive an input line, and then converts the input line to an int value using Integer.parseInt. The method then combines the values to instantiate a BankAccount object, and then returns this object. Tha mathnd avnttAnnDrrnmnt nnnta tha nramnt Tha mathnd roanaiwvacd an arrawu anf Danlnavnnniint

Listing 16.19 A program that manipulates with a list of bank accounts (part 4). The loop in the method main

Here is an execution example of the program, presented in two parts:

Here is a code for ArrayWithCapacity. The global variables are now private instance variables
(Lines 4 and 5). They are int variables, size and capacity, and a String[] variable,
theNames. The constructor takes an int value, capacity, as the formal parameter (Line 7).
The constructor saves the value of the parameter to the instance variable, capacity. Here we use
this. for distinction (Line 9). The constructor then instantiates the array using the capacity value as
the length (Line 10) and assigns 0 to size (Line 11). The getters get Capacity (Lines 14-17) and
getSize (Lines 19-22) return the values of capacity and size.
e We will add new methods, get Capacity and get Size, as getters. — Here is a code for ArrayWithCapacity. The global variables are now private instance variables (Lines 4 and 5). They are int variables, size and capacity, and a String[] variable, theNames. The constructor takes an int value, capacity, as the formal parameter (Line 7). The constructor saves the value of the parameter to the instance variable, capacity. Here we use this. for distinction (Line 9). The constructor then instantiates the array using the capacity value as the length (Line 10) and assigns 0 to size (Line 11). The getters get Capacity (Lines 14-17) and getSize (Lines 19-22) return the values of capacity and size. e We will add new methods, get Capacity and get Size, as getters.

The method add (Lines 44—54) is now designed to take only one element to add:
Listing 16.22 The method for printing the data in class ArrayWithCapacity — The method add (Lines 44—54) is now designed to take only one element to add: Listing 16.22 The method for printing the data in class ArrayWithCapacity

Listing 16.26 A new version of the program that uses an array with capacity and size (part 2)
Listing 16.25 A new version of the program that uses an array with capacity and size (part 1) — Listing 16.26 A new version of the program that uses an array with capacity and size (part 2) Listing 16.25 A new version of the program that uses an array with capacity and size (part 1)

Listing 17.2 The code for PizzaSimple
The class has a declaration, implements PizzaSimpleInt (Line 1). The instance variables
are declared in Lines 3 and 4 as private variables. The constructor receives the name and price as
parameters, and stores their values in the instance variables. Since the parameters and the instance
variables have the same names, the prefix this. is attached to the instance variables to distinguish
between the two (Line 8 and 9). The getters are overridden in Lines 11-18. — Listing 17.2 The code for PizzaSimple The class has a declaration, implements PizzaSimpleInt (Line 1). The instance variables are declared in Lines 3 and 4 as private variables. The constructor receives the name and price as parameters, and stores their values in the instance variables. Since the parameters and the instance variables have the same names, the prefix this. is attached to the instance variables to distinguish between the two (Line 8 and 9). The getters are overridden in Lines 11-18.

Fig. 17.4 The code for PizzaSimpleCollection (part 2). The method read
OR II OILED III IIE FELD ION IS IID III IID NIE IDI DI NII DE EE

After the initialization, the method read uses a for-loop to read the remainder of the file contents
in pairs of lines. The first line of a pair is the name of the pizza (Line 28) and the second line is the
price (Line 29). The method uses Double .parseDoub1e to convert the second line to a double
value, instantiates a PizzaSimple object with the name and price, and stores it in its designated
position in the array (Line 30). After completing the process of reading information, the method closes
the Scanner object (Line 32). — Fig. 17.4 The code for PizzaSimpleCollection (part 2). The method read OR II OILED III IIE FELD ION IS IID III IID NIE IDI DI NII DE EE After the initialization, the method read uses a for-loop to read the remainder of the file contents in pairs of lines. The first line of a pair is the name of the pizza (Line 28) and the second line is the price (Line 29). The method uses Double .parseDoub1e to convert the second line to a double value, instantiates a PizzaSimple object with the name and price, and stores it in its designated position in the array (Line 30). After completing the process of reading information, the method closes the Scanner object (Line 32).

Listing 17.7 The code for PizzaSimpleCollection (part 5). The method delte
17.1.2.8 Viewing the Elements of the List — Listing 17.7 The code for PizzaSimpleCollection (part 5). The method delte 17.1.2.8 Viewing the Elements of the List

Listing 17.9 The code for PizzaSimpleMain
Jata.view() (Line 26). If the character is ‘A’, the method receives the name (Lines 28 and 29)
and the price (Lines 30 and 31) from the user, stores them in variables, name and price, and
calls data.add( name, price ) (Line 32). If the character is ’D’, the method receives an
input line from the user, converts it to an integer on the fly using Integer.parseInt, and
calls data.delete with this integer as the actual parameter (Lines 35 and 36). If the character
is ‘Q’, nothing happens inside the switch statement, and the loop is terminated (Line 38). Before
halting the program, the program calls data.write() to save the data. Double.parseInt and
Integer .parselInt are used to read the price of the new pizza and the index to the element to be
removed. — Listing 17.9 The code for PizzaSimpleMain Jata.view() (Line 26). If the character is ‘A’, the method receives the name (Lines 28 and 29) and the price (Lines 30 and 31) from the user, stores them in variables, name and price, and calls data.add( name, price ) (Line 32). If the character is ’D’, the method receives an input line from the user, converts it to an integer on the fly using Integer.parseInt, and calls data.delete with this integer as the actual parameter (Lines 35 and 36). If the character is ‘Q’, nothing happens inside the switch statement, and the loop is terminated (Line 38). Before halting the program, the program calls data.write() to save the data. Double.parseInt and Integer .parselInt are used to read the price of the new pizza and the index to the element to be removed.

The data file has been updated. If we execute the cat command on the file, we see that there are

Ee eC eR + Sen erred — The data file has been updated. If we execute the cat command on the file, we see that there are Ee eC eR + Sen erred

Fig. 17.1 The two interfaces and the two classes. The pointy arrows represent extensions and the circle-head arrows
represent implementations
public interface PizzaComplexInt extends PizzaSimpleInt — Fig. 17.1 The two interfaces and the two classes. The pointy arrows represent extensions and the circle-head arrows represent implementations public interface PizzaComplexInt extends PizzaSimpleInt

Listing 17.11 The code for PizzaComplex (part 1). The header, the instance variable, and the constructor

Listing 17.14 The code for PizzaComplex (part 4). The implementation of the method encodeIngredients

Listing 17.15 The code for PizzaComplexCollection (part 1). The header, the constants, the instance variables
and the constructor
In PizzaComplexCollection, the type of the pizza array is PizzaComplexIt [] (Line 5).
The class defines two delimiters to be used as a parameter for the method encodeIngredients
of PizzaComplexInt. The delimiters are called SEPARATOR and COMMA. SEPARATOR is used
when recording the data in a file and its value is "\t" (Line 8). COMMA is used when printing the
ingredients on the screen, and its value is ", " (Line 9). As before, there are two constructors, one
that receives a file path (Line 11) and the other that takes a File object (Line 15). The order between
the two is deliberately switched in this version, to emphasize that the order of appearance of the two
constructors can be arbitrary. — Listing 17.15 The code for PizzaComplexCollection (part 1). The header, the constants, the instance variables and the constructor In PizzaComplexCollection, the type of the pizza array is PizzaComplexIt [] (Line 5). The class defines two delimiters to be used as a parameter for the method encodeIngredients of PizzaComplexInt. The delimiters are called SEPARATOR and COMMA. SEPARATOR is used when recording the data in a file and its value is "\t" (Line 8). COMMA is used when printing the ingredients on the screen, and its value is ", " (Line 9). As before, there are two constructors, one that receives a file path (Line 11) and the other that takes a File object (Line 15). The order between the two is deliberately switched in this version, to emphasize that the order of appearance of the two constructors can be arbitrary.

The method read is similar to the previous one. To split the ingredient line to an array, read calls
the method split for String with SEPARATOR as the delimiter (Line 33). The name, price, and
ingredients that are read from the file are then given to the constructor of PizzaComplex, and the
PizzaComplex object generated by the constructor is stored in the list (Line 34). — The method read is similar to the previous one. To split the ingredient line to an array, read calls the method split for String with SEPARATOR as the delimiter (Line 33). The name, price, and ingredients that are read from the file are then given to the constructor of PizzaComplex, and the PizzaComplex object generated by the constructor is stored in the list (Line 34).

Listing 17.16 The code for PizzaComplexCollection (part 2). Reading from file

17.5 Interface Comparable
By using Integer instead, we can make max assume the role of the boolean variable.
We use the disjunction || in the first condition inside the while-loop to truncate the conditional
evaluation. At the end of the loop-body, we set the value of noNumbersYet to false, so the
second time around, the second condition, max < number, is tested.

Runeneo Tntaqgqaenr inctead we ran make may acame the role af the han] aan variahle — 17.5 Interface Comparable By using Integer instead, we can make max assume the role of the boolean variable. We use the disjunction || in the first condition inside the while-loop to truncate the conditional evaluation. At the end of the loop-body, we set the value of noNumbersYet to false, so the second time around, the second condition, max < number, is tested. Runeneo Tntaqgqaenr inctead we ran make may acame the role af the han] aan variahle

Listing 17.22 The code for PizzaUltraCollection (part 1)
Now that we have implemented Comparable, we can sort any pizza list. We specifically
use the capability at two occasions. One is after reading the data from the data file. The
other is after adding a new pizza. The code for the collection class is essentially the same as
before, with the use of PizzaUltra. Since the elements of the array are now PizzaUltra,
at the end of the methods add and read, the array is sorted using Arrays.sort. The
source code for PizzaUltraCollection is presented next with the differences from
PizzaComplexCollection highlighted: — Listing 17.22 The code for PizzaUltraCollection (part 1) Now that we have implemented Comparable, we can sort any pizza list. We specifically use the capability at two occasions. One is after reading the data from the data file. The other is after adding a new pizza. The code for the collection class is essentially the same as before, with the use of PizzaUltra. Since the elements of the array are now PizzaUltra, at the end of the methods add and read, the array is sorted using Arrays.sort. The source code for PizzaUltraCollection is presented next with the differences from PizzaComplexCollection highlighted:

Listing 17.25 The code for PizzaUltraMain (part 1)

Listing 18.2 The class Merchandise (part 2). The getters, the setters, and the comparator
Listing 18.1 The class Merchandise (part 1). The class header, the instance variables, and the constructor
18.1.3 The Comparator Class — Listing 18.2 The class Merchandise (part 2). The getters, the setters, and the comparator Listing 18.1 The class Merchandise (part 1). The class header, the instance variables, and the constructor 18.1.3 The Comparator Class

Listing 18.6 The class MerchandiseCollection (part 3). The “setters”

hese choices neatly. The choices are presented in a table-like manner with three choices appearing in
yne line, as shown next:
The source code of print Prompt appears next. — hese choices neatly. The choices are presented in a table-like manner with three choices appearing in yne line, as shown next: The source code of print Prompt appears next.

Listing 18.11 The class MerchandiseMain (part 3). The part that handles adding and removing an item
cannot be converted to an integer, a run-time error of NumberFormatException occurs. This
error is handled by a catch-clause appearing in Lines 91 and 92. NumberFormatException may
occur in other places of the code, and all of them are handled by this catch-clause. For removing

an item (Line 38), the program receives the position of the item to be removed (Lines 39 and 40), and
then calls the method remove (Line 41). — Listing 18.11 The class MerchandiseMain (part 3). The part that handles adding and removing an item cannot be converted to an integer, a run-time error of NumberFormatException occurs. This error is handled by a catch-clause appearing in Lines 91 and 92. NumberFormatException may occur in other places of the code, and all of them are handled by this catch-clause. For removing an item (Line 38), the program receives the position of the item to be removed (Lines 39 and 40), and then calls the method remove (Line 41).

Listing 18.10 The class MerchandiseMain (part 2). The start of the method main, including the variable
declarations, the start of the loop, and the try-clause — Listing 18.10 The class MerchandiseMain (part 2). The start of the method main, including the variable declarations, the start of the loop, and the try-clause

Listing 18.12 The class MerchandiseMain (part 4). The part that handles sorting and viewing the data

Listing 18.13 The class MerchandiseMain (part 5). The part that is responsible for changing the name and the

Sheep
18.1.5.6 File Read/Write
If the choice is 9, the program receives a file path from the user, and then calls the method read
(Lines 80-83). If the choice is 10, the program receives a file path from the user and calls the method
write (Lines 84-87). In the case where the choice is 0, the program prints a message to inform that
the program will terminate (Lines 88 and 89). — Listing 18.13 The class MerchandiseMain (part 5). The part that is responsible for changing the name and the Sheep 18.1.5.6 File Read/Write If the choice is 9, the program receives a file path from the user, and then calls the method read (Lines 80-83). If the choice is 10, the program receives a file path from the user and calls the method write (Lines 84-87). In the case where the choice is 0, the program prints a message to inform that the program will terminate (Lines 88 and 89).

Starting with this file, we can manipulate the data as follows:

Listing 18.15 The class MerchandiseMain (part 7). The catch clauses

The execution example has resulted in the following revised data file, propertyData2.txt:

Listing 18.18 The class TopKTest (part 1). Top 10 of 1, ..., 10,000
Here is a source code for testing the class TopK. The program instantiates a TopK<Integer>
object top with the value of k set to 10 (Line 6). The program then adds integers 1, ..., 10,000
one after another in top (Lines 7-10), and then retrieves the recorded top ten elements (Line 1|1-
14). Since the elements appear in increasing order. The program generates ranks from 1 to 10 with a
variable named i (Line 11), and prints the element located at rank i (Line 13). — Listing 18.18 The class TopKTest (part 1). Top 10 of 1, ..., 10,000 Here is a source code for testing the class TopK. The program instantiates a TopK<Integer> object top with the value of k set to 10 (Line 6). The program then adds integers 1, ..., 10,000 one after another in top (Lines 7-10), and then retrieves the recorded top ten elements (Line 1|1- 14). Since the elements appear in increasing order. The program generates ranks from 1 to 10 with a variable named i (Line 11), and prints the element located at rank i (Line 13).

Listing 18.19 The class TopKTest (part 2). Testing with random real numbers

8.3. The Java Collection Framework
The List and its implementation ArrayList belong to a large group of interfaces, abstract
classes, and concrete classes, called the Java Collection Framework. The Java Collection Framework
provides various tools for dynamically maintaining a collection of data through such actions as
adding, removing, and searching. Some interfaces and classes in the framework are shown in Fig. 18.1.
Like ArrayList, all interfaces and classes in the framework take a generic type parameter. In the
following description, we use E to refer to the generic type parameter. — 8.3. The Java Collection Framework The List and its implementation ArrayList belong to a large group of interfaces, abstract classes, and concrete classes, called the Java Collection Framework. The Java Collection Framework provides various tools for dynamically maintaining a collection of data through such actions as adding, removing, and searching. Some interfaces and classes in the framework are shown in Fig. 18.1. Like ArrayList, all interfaces and classes in the framework take a generic type parameter. In the following description, we use E to refer to the generic type parameter.

Fig. 18.1 The Java Collection Framework. The squashed rectangles represent interfaces and the rectangles represent
classes. The arrows represent extensions and the round-head arrows represent implementations — Fig. 18.1 The Java Collection Framework. The squashed rectangles represent interfaces and the rectangles represent classes. The arrows represent extensions and the round-head arrows represent implementations

Fig. 18.2 A LinkedList. X, Y, Z,and W are the data elements in the collection. next and previous present the
references to the “next” and “previous” elements — Fig. 18.2 A LinkedList. X, Y, Z,and W are the data elements in the collection. next and previous present the references to the “next” and “previous” elements

18.3.3 A Demonstration
We present a program that demonstrates how the interfaces List, Queue, and Set operate. List — 18.3.3 A Demonstration We present a program that demonstrates how the interfaces List, Queue, and Set operate. List

Listing 18.20 The class Collection!
and the method printfInfo

Experiment (part 1). The method main, the array constant SEQU.

ENC — Listing 18.20 The class Collection! and the method printfInfo Experiment (part 1). The method main, the array constant SEQU. ENC

Listing 18.22 The class CollectionExperiment (part 3). The experiment with a Queue<String> data
Listing 18.21 The class CollectionExperiment (part 2). The experiment with a List<String> dats — Listing 18.22 The class CollectionExperiment (part 3). The experiment with a Queue<String> data Listing 18.21 The class CollectionExperiment (part 2). The experiment with a List<String> dats

Listing 18.23 The class CollectionExperiment (part 4). The experiment with a Set<String> data
The method setExperiment (Line 74) instantiates a HashSet<String> object, and then
assigns the object to a Set <String> variable named myQueue (Line 77). The method then adds
each element of SEQUENCE successively twice using the method add of Set <String> (Lines 78-
82). Next, the method removes "Suzie" using the method remove and Set <String> (Lines 83
and 84). Finally, the method calls print Info to generate a report about mySet (Line 85). — Listing 18.23 The class CollectionExperiment (part 4). The experiment with a Set<String> data The method setExperiment (Line 74) instantiates a HashSet<String> object, and then assigns the object to a Set <String> variable named myQueue (Line 77). The method then adds each element of SEQUENCE successively twice using the method add of Set <String> (Lines 78- 82). Next, the method removes "Suzie" using the method remove and Set <String> (Lines 83 and 84). Finally, the method calls print Info to generate a report about mySet (Line 85).

The tokens obtained from this String are "System", "out", "printf", "s", "n", anc
"abc". Here is the output of the program with the source code of TopK. java as the input. — The tokens obtained from this String are "System", "out", "printf", "s", "n", anc "abc". Here is the output of the program with the source code of TopK. java as the input.

Listing 19.1 The initialization and the update in the computation of the Fibonacci numbers
An online algorithm uses a set of variables that is initialized and updated during the execution of
the algorithm. Their initialization is very important. For the computation of Fibonacci numbers, the
initialization consists of storing the value of 1 to both fp and fpp. Here we recall the program from
Chap. 7 that we used to compute the Fibonacci numbers. — Listing 19.1 The initialization and the update in the computation of the Fibonacci numbers An online algorithm uses a set of variables that is initialized and updated during the execution of the algorithm. Their initialization is very important. For the computation of Fibonacci numbers, the initialization consists of storing the value of 1 to both fp and fpp. Here we recall the program from Chap. 7 that we used to compute the Fibonacci numbers.

Listing 19.2 A program that computes the maximum and the minimum in a series of numbers. This part of the code
is from Chap. 7
19.1.2 Computing Recurrences — Listing 19.2 A program that computes the maximum and the minimum in a series of numbers. This part of the code is from Chap. 7 19.1.2 Computing Recurrences

We extend the program to handle second-order recurrences of the form:
Here is an execution example of the code: — We extend the program to handle second-order recurrences of the form: Here is an execution example of the code:

Listing 19.3 A program for computing a first-order linear recurrence

where so and sj are integers, and a, b, and c are integer coefficients.

Like the programs for computing the Fibonacci sequence, the computation is dependent on
two previous numbers in the sequence. We use two long variables, previous for s,—;, and
previousPrevious for s;_2.
Listing 19.4 A program for computing a second-order linear recurrence — where so and sj are integers, and a, b, and c are integer coefficients. Like the programs for computing the Fibonacci sequence, the computation is dependent on two previous numbers in the sequence. We use two long variables, previous for s,—;, and previousPrevious for s;_2. Listing 19.4 A program for computing a second-order linear recurrence

If the program receives | for each of so, 51, a, and b, and receives 0 for c, the sequence generated 1
equal to the Fibonacci sequence.
19.1.3 Computing the Factorial Function
For a positive integer n, the factorial of n, denoted by n!, is the product of all integers between 1 and
n. For integers n less than or equal to 0, the factorial of n is defined to be 1. Here are some first few
values of the factorial: — If the program receives | for each of so, 51, a, and b, and receives 0 for c, the sequence generated 1 equal to the Fibonacci sequence. 19.1.3 Computing the Factorial Function For a positive integer n, the factorial of n, denoted by n!, is the product of all integers between 1 and n. For integers n less than or equal to 0, the factorial of n is defined to be 1. Here are some first few values of the factorial:

Listing 19.5 A program that computes the factorial function using an online algorithm

Here is an execution example of the program:

Listing 19.6 A program that approximates the factorial function using doub1e in place of long
If computing approximate values of factorials (instead of their exact values) is acceptable, we
can use double instead of long to obtain factorials for much larger values of n. To generate an
output that is easy to read, we use the printf format of %e. This is a format for the exponential
representation, where a floating point number is presented as AeB, where A is a real number with
precisely one digit before the decimal point and B is an integer. A and B collective mean “A x 10
raised to the power of B”. For instance, 1. 346201e+241 means 1.346201 x 10°4!. The format for
the number i is changed from %2d to 33d. — Listing 19.6 A program that approximates the factorial function using doub1e in place of long If computing approximate values of factorials (instead of their exact values) is acceptable, we can use double instead of long to obtain factorials for much larger values of n. To generate an output that is easy to read, we use the printf format of %e. This is a format for the exponential representation, where a floating point number is presented as AeB, where A is a real number with precisely one digit before the decimal point and B is an integer. A and B collective mean “A x 10 raised to the power of B”. For instance, 1. 346201e+241 means 1.346201 x 10°4!. The format for the number i is changed from %2d to 33d.

Here is how the program computes the factorial, with the middle 130 lines of output omitted:

The program can compute the approximate factorial if n as large as 170, which is the limit.
Infinity is a special value of the boxed class Doub1e that represents the positive infinity. — The program can compute the approximate factorial if n as large as 170, which is the limit. Infinity is a special value of the boxed class Doub1e that represents the positive infinity.

Listing 19.7 A program that computes the factorial function recursively doub1e in place of long

Fig. 19.5 The value passing that occurs during the computation of the factorial (part 5)
Fig. 19.4 The value passing that occurs during the computation of the factorial (part 4) — Fig. 19.5 The value passing that occurs during the computation of the factorial (part 5) Fig. 19.4 The value passing that occurs during the computation of the factorial (part 4)

Fig. 19.3. The value passing that occurs during the computation of the factorial (part 3)

Fig. 19.1 The value passing that occurs during the computation of the factorial (part 1)

Fig. 19.6 The value passing that occurs during the computation of the factorial (part 6)

Fig. 19.8 The value passing that occurs during the computation of the factorial (part 8)
Fig. 19.7 The value passing that occurs during the computation of the factorial (part 7) — Fig. 19.8 The value passing that occurs during the computation of the factorial (part 8) Fig. 19.7 The value passing that occurs during the computation of the factorial (part 7)

Fig. 19.10 The value passing that occurs during the computation of the factorial (part 10:
Fig. 19.9 The value passing that occurs during the computation of the factorial (part 9) — Fig. 19.10 The value passing that occurs during the computation of the factorial (part 10: Fig. 19.9 The value passing that occurs during the computation of the factorial (part 9)

Fig. 19.11 The value passing that occurs during the computation of the factorial (part 11
19.2.2 The Greatest Common Divisor of Two Integers — Fig. 19.11 The value passing that occurs during the computation of the factorial (part 11 19.2.2 The Greatest Common Divisor of Two Integers

Listing 19.9 A program that computes the GCD using recursive calls

19.2.3 The Tower of Hanoi
Legend says that there is a temple in a remote place in Hanoi, where the monks are counting the time
by moving 64 disks (Fig. 19.12). The monks can move one disk at a time on the tick of a clock. The
disks have a hole in the middle, and they are placed on a pole through their holes. There are three
poles at the site. The 64 disks were originally placed on the first pole, in the decreasing order of their
diameters, with the smallest disk at the top. The monks have been given the task of moving all 64
disks to the second pole. In moving the disks, the monks have to abide by the following rule: no disk
can be placed on a disk with a smaller diameter. In other words, during the execution of the task, on
each of the three poles, the disks are placed in the decreasing order of their diameters.
Legend has it that the world ends when the monks have completed the task.
Legend says that there is a temple in a remote place in Hanoi, where the monks are counting the time
Fig. 19.12 An example of
the tower of Hanoi — 19.2.3 The Tower of Hanoi Legend says that there is a temple in a remote place in Hanoi, where the monks are counting the time by moving 64 disks (Fig. 19.12). The monks can move one disk at a time on the tick of a clock. The disks have a hole in the middle, and they are placed on a pole through their holes. There are three poles at the site. The 64 disks were originally placed on the first pole, in the decreasing order of their diameters, with the smallest disk at the top. The monks have been given the task of moving all 64 disks to the second pole. In moving the disks, the monks have to abide by the following rule: no disk can be placed on a disk with a smaller diameter. In other words, during the execution of the task, on each of the three poles, the disks are placed in the decreasing order of their diameters. Legend has it that the world ends when the monks have completed the task. Legend says that there is a temple in a remote place in Hanoi, where the monks are counting the time Fig. 19.12 An example of the tower of Hanoi

The solution for moving two disks is as follows:
We formalize the problem as follows: We assign the position numbers 0, 1, and 2 to the three poles.
We assign the names L, M, and R to them. We use the phrase “move 2 to L and R” to mean the action
of moving the 2nd smallest disk from Pole L to Pole R. We envision that M is the final destination of
the disks. — The solution for moving two disks is as follows: We formalize the problem as follows: We assign the position numbers 0, 1, and 2 to the three poles. We assign the names L, M, and R to them. We use the phrase “move 2 to L and R” to mean the action of moving the 2nd smallest disk from Pole L to Pole R. We envision that M is the final destination of the disks.

References (135)

There are four syntax errors in the code:
the String literal in line 7 does not have a closing double quotation mark, 3. the colon at the end of line 7 should be a semicolon, and 4. There should be one more "}" at the end. At the compilation step, we encounter the following error messages: BuggyHelloWorld.java:2: error: '{' expected public class BuggyHelloWorld BuggyHelloWorld.java:8: error: unclosed string literal System.out.pritnln( "Hello, World! );
BuggyHelloWorld.java:8: error: ';' expected System.out.pritnln( "Hello, World! );
BuggyHelloWorld.java:9: error: illegal start of expression System.out.printin( Hello, Class!" );
BuggyHelloWorld.java:9: error: ';' expected System.out.printin( Hello, Class!" );
BuggyHelloWorld.java:9: error: ')' expected System.out.printin( Hello, Class!" );
BuggyHelloWorld.java:9: error: unclosed string literal System.out.printin( Hello, Class!" );
BuggyHelloWorld.java:10: error: ';' expected System.out.printin( "Hello, its' me!" ): BuggyHelloWorld.java:10: error: ';' expected System.out.printin( "Hello, its' me!" ): BuggyHelloWorld.java:13: error: class, interface, or enum expected } 10 errors Each error message consists of the source file name, theHere is an execution example: 1 Enter one number: 4
45 System . out . printf ( " Your input :% n%s% nThe counts :% n" , input );
46 printInfo ( " Period " , nPeriod );
47 printInfo ( " Comma " , nComma );
48 printInfo ( " Question Mark " , nQuestion );
49 printInfo ( " Exclamation Mark " , nExclamation );
50 printInfo ( " Colon " , nColon );
51 printInfo ( " Semicolon " , nSemicolon );
52 printInfo ( " Others " , nOthers );
53 } 54 } Listing 10.9 A program that counts punctuations (part 4). The part for generating a report 10.2 Using a char Data in a Switch-Statement Round=015,Value=1.414260864257813
Round=016,Value=1.414222717285156
Round=017,Value=1.414203643798828
Round=018,Value=1.414213180541992
Round=019,Value=1.414217948913574
Round=020,Value=1.414215564727783
Round=021,Value=1.414214372634888
Round=022,Value=1.414213776588440
Round=023,Value=1.414213478565216
Round=024,Value=1.414213627576828
Round=025,Value=1.414213553071022
Round=026,Value=1.414213590323925
Round=027,Value=1.414213571697474
Round=028,Value=1.414213562384248
Round=029,Value=1.414213557727635
Round=030,Value=1.414213560055941
Round=031,Value=1.414213561220095
Round=032,Value=1.414213561802171
Round=033,Value=1.414213562093210
Round=034,Value=1.414213562238729
Round=035,Value=1.414213562311488
Round=036,Value=1.414213562347868
Round=037,Value=1.414213562366058
Round=038,Value=1.414213562375153
Round=039,Value=1.414213562370605
Round=040,Value=1.414213562372879
Round=041,Value=1.414213562374016
Round=042,Value=1.414213562373448
Round=043,Value=1.414213562373163
Round=044,Value=1.414213562373021
Round=045,Value=1.414213562373092
Round=002,Value=0.875000000000000
Round=003,Value=1.312500000000000
Round=004,Value=1.531250000000000
Round=005,Value=1.640625000000000
Round=006,Value=1.695312500000000
Round=007,Value=1.722656250000000
Round=008,Value=1.736328125000000
Round=009,Value=1.729492187500000
Round=010,Value=1.732910156250000
Round=011,Value=1.731201171875000
Round=012,Value=1.732055664062500
Round=013,Value=1.731628417968750
Round=014,Value=1.731842041015625
Round=015,Value=1.731948852539063
Round=016,Value=1.732002258300781
Round=017,Value=1.732028961181641
Round=018,Value=1.732042312622070
Round=019,Value=1.732048988342285
Round=020,Value=1.732052326202393
Round=021,Value=1.732050657272339
Round=022,Value=1.732051491737366
Round=023,Value=1.732051074504852
Round=024,Value=1.732050865888596
Round=025,Value=1.732050761580467
Round=026,Value=1.732050813734531
Round=027,Value=1.732050787657499
Round=028,Value=1.732050800696015
Round=029,Value=1.732050807215273
Round=030,Value=1.732050810474902
Round=031,Value=1.732050808845088
Round=032,Value=1.732050808030181
Round=033,Value=1.732050807622727
Round=034,Value=1.732050807419000
Round=035,Value=1.732050807520864
Round=036,Value=1.732050807571795
Round=037,Value=1.732050807546330
Round=038,Value=1.732050807559062
Round=039,Value=1.732050807565429
Round=040,Value=1.732050807568612
Round=041,Value=1.732050807570204
Round=042,Value=1.732050807569408
Round=043,Value=1.732050807569010
Round=044,Value=1.732050807568811
Round=045,Value=1.732050807568911
Round=046,Value=1.732050807568861
Root=1.732050807568861, Square=2.999999999999943 Enter your guess: 123 No.Hits=0, No.Misses=0 Enter your guess: 456 No.Hits=2, No.Misses=0 Enter your guess: 457 No.Hits=1, No.Misses=1 Enter your guess: 467 No.Hits=0, No.Misses=2 Enter your guess: 478 No.Hits=0, No.Misses=1 Enter your guess: 567 No.Hits=0, No.Misses=3 Enter your guess: 756
Congratulations! You've guessed it right! 12 Arrays 53:241 54:251 55:257 56:263 57:269 58:271 59:277 60:281 61:283 62:293 63:307 64:311 65:313 66:317 67:331 68:337 69:347 70:349 71:353 72:359 73:367 74:373 75:379 76:383 77:389 78:397 79:401 80:409 81:419 82:421 83:431 84:433 85:439 86:443 87:449 88:457 89:461 90:463 91:467 92:479 93:487 94:491 95:499 96:503 97:509 98:521 99:523 100:541 101:547 102:557 103:563 104:569 105:571 106:577 107:587 108:593 109:599 110:601 111:607 112:613 113:617 114:619 115:631 116:641 117:643 118:647 119:653 120:659 121:661 122:673 123:677 124:683 125:691 126:701 127:709 128:719 129:727 130:733 131:739 132:743 133:751 134:757 135:761 136:769 137:773 138:787 139:797 140:809 141:811 142:821 143:823 144:827 145:829 146:839 147:853 148:857 149:859 150:863 151:877 152:881 153:883 154:887 155:907 156:911 157:919 158:929 159:937 160:941 161:947 162:953 163:967 164:971 165:977 166:983 167:991 168:997 12.5 String Methods That Return an Array 317 23 4 Emily 81.00
Instantiate a new temporary array, say newArray.
For all indexes i that are strictly smaller than p, copy oldArray[ i ] to newArray[ i ].
Place x in newArray[ p ].
For all indexes i that are strictly greater than p, copy oldArray[ i ] to newArray[ i + 1 ].
Assign newArray to oldArray. Figure 13.5 visualizes this action. In the middle three steps, there is no overlap among the destinations of the elements, so the orders of the three steps can be permuted. To remove the element at some index p, we execute the following algorithm:
Instantiate a new temporary array with a different name, say newArray.
For all indexes i that are strictly smaller than p, copy oldArray[ i ] to newArray[ i ].
3 Joanne Brackeen (born July 26, 1938) is an American jazz pianist and composer. Terri Lyne Carrington (born August 4, 1965) is an American jazz drummer, composer, and producer. Carmen Mercedes McRae (April 8, 1922 to November 10, 1994) was an American jazz singer. Linda May Oh (born 1984 in Malaysia) is a Jazz bassist and composer. Esperanza Emily Spalding (born October 18, 1984) is an American jazz bassist and singer. Blossom Dearie (April 28, 1924 to February 7, 2009) was an American jazz singer, composer, and pianist.
1 Rectangular Arrays 14.1.1 Defining Multi-Dimensional Arrays Arrays may have more than one dimension. We call arrays having more than one dimension multi- dimensional arrays. For an integer N ≥ 1, an N -dimensional array as a type is declared with N pairs of brackets []. In the following code, mDouble is declared as a two-dimensional array of double and myFlags is declared as a three-dimensional array of boolean. 1 double [][] myDouble ;
myFlags ; In an instantiation of a multi-dimensional array, the length must be specified for at least one dimension, but not necessarily for all of them. In the following code, the first line instantiates a two- dimensional array whose first dimension has length 11 and whose second dimension has length 35, and the second line instantiates a three-dimensional array whose first dimension has length 3. In the second array, the three elements myFlags[ 0 ], myFlags[ 1 ], and myFlags[ 2 ] are expected to be two-dimensional arrays, but they are presently null and so their shapes are unknown yet. 3 myDouble = new double [ 11 ][ 35 ];
In an instantiation of a multi-dimensional array, if one dimension is without length specification, so must be its subsequent dimensions. Therefore, myDouble = new double [][ 7 ];
myFlags = new boolean [ 5 ][][ 4 ];
are both syntactically incorrect.
M. Ogihara, Fundamentals of Java Programming, https://doi.org/10.1007/978-3-319-89491-1_14
Enter two paths : tmp1 tmp2
----Their initial state 6 Existence : tmp1 = false , tmp2 = false 7
----Create File1 -> true
----Create File2 -> true 10 Existence : tmp1 = true , tmp2 = true 11 12 ----Rename File1 to File1 -> true 13 ----Rename File1 to File2 -> true 14 Existence : tmp1 = false , tmp2 = true 15 16 ----Create File1 as Directory -> true 17 ----Create File2 as Directory -> false 18 Existence : tmp1 = true , tmp2 = true 19 20 ----Delete File1 -> true
Parent: Documents
Absolute Path: /Users/nancy/Documents
Parent's File List
------------------ 8 Index: Exec? Read?Write?IsDir?IsFil? Size Name 9 00000: false true true false true 18436 .DS_Store 10 00001: false true true false true 0 .localized 11 00002: true true true true false 476 archives 12 00003: true true true true false 204 classical.txt 13 00004: true true true true false 136 cranium 14 00005: true true true true false 714 CSC120 15 00006: true true true true false 578 CSC527 16 00007: true true true true false 204 easy 17 00008: false true true false true 132102 eceSeminarOct2017.docx 18 00009: true true true true false 272 fiances 19 00010: true true true true false 306 frank 20 00011: true true true true false 612 globaltheme 21 00012: true true true true false 204 india.txt 22 00013: true true true true false 102 letters 23 00014: true true true true false 204 Microsoft User Data 24 00015: true true true true false 204 MitsuCollection.txt 25 00016: false true true false true17438298 Mult_Pattern_2_EdXX.docx 26 00017: true true true true false 204 MyCollection.txt 27 00018: true true true true false 170 papers 28 00019: true true true true false 782 pdfs 29 00020: true true true true false 340 Projects 30 00021: true true true true false 1020 Resume 31 00022: true true true true false 442 reviews 32 00023: true true true true false 578 temp 33 00024: true true true true false 374 temporary 'f':35 'g':-27 'h':-39 'i':8 'j':2 'k':-21 'l':-37 'm':-22 'n':-9 'o':13 'p':7 'q':-1 'r':-16 's':-31 't':-30 'u':-29 'v':-3 'w':-1 'x':3 'y':-27 '{':5 '|':-2 '}':5 17 Enter your choice: 1 18 Enter account index: 0
------ 21 0: My Saving has the balance of $150,000.00 22 1: My Checking has the balance of $1,000.00 23 2: Her Saving has the balance of $200,000.00
Enter account origination index: 2 31 Enter account destination index: 1 32 Enter amount: 5000000
------ 34 0: My Saving has the balance of $150,000.00 35 1: My Checking has the balance of $51,000.00 36 2: Her Saving has the balance of $150,000.00
Quit 42 Enter your choice: 2 43 Enter account index: 2 44 Enter amount: 999900
------ 46 0: My Saving has the balance of $150,000.00 47 1: My Checking has the balance of $51,000.00 48 2: Her Saving has the balance of $140,001.00
% java PizzaComplexMain 2 Enter data file name: pizzaComplexData.txt 3 Enter your choice by first letter 4 View, Add, Delete, Search, Quit: V 5 0:Four Cheese:$14.00:Mozzarella, Parmesan, Ricotta, Gorgonzola 6 1:Pepperoni:$10.00:Pepperoni 7 2:Nettuno:$14.00:Tuna, Pasta Sauce, Onion, Green Pepper 8 3:Capricciosa:$14.50:Olive, Ham, Mozzarella, Artichoke 9 4:Meat Lovers:$15.00:Pepperoni, Ham, Sausage, Bacon, Mozzarella 10 5:Veggie:$12.50:Onion, Green Pepper, Tomato, Mozzarella, Olive 11 Enter your choice by first letter 12 View, Add, Delete, Search, Quit: A 13 Enter name: Hawaiian 14 Enter price: 13.00 15 Enter ingredients separated by comma: Ham,Pineapple 16 Enter your choice by first letter 17 View, Add, Delete, Search, Quit: V 18 0:Four Cheese:$14.00:Mozzarella, Parmesan, Ricotta, Gorgonzola 19 1:Pepperoni:$10.00:Pepperoni 20 2:Nettuno:$14.00:Tuna, Pasta Sauce, Onion, Green Pepper 21 3:Capricciosa:$14.50:Olive, Ham, Mozzarella, Artichoke 22 4:Meat Lovers:$15.00:Pepperoni, Ham, Sausage, Bacon, Mozzarella 23 5:Veggie:$12.50:Onion, Green Pepper, Tomato, Mozzarella, Olive 24 6:Hawaiian:$13.00:Ham, Pineapple 25 Enter your choice by first letter 26 View, Add, Delete, Search, Quit: S 27 Enter key: ham 28 3:Capricciosa:$14.50:Olive, Ham, Mozzarella, Artichoke 29 4:Meat Lovers:$15.00:Pepperoni, Ham, Sausage, Bacon, Mozzarella 30 6:Hawaiian:$13.00:Ham, Pineapple 31 Enter your choice by first letter 32 View, Add, Delete, Search, Quit: Q ----Choose action to be performed----
choice: 1 Enter the name: 2 Atkins Road Enter the price: 280000 ----Choose action to be performed----
choice: 4 0: 1 Presidential Place : $1,535,000 1: 10 Wilkinson Road : $343,450 2: 11 Wilkinson Drive : $766,000 3: 2 Atkins Road : $280,000 4: 2 Marigold Terrace : $615,000 5: 34 Coral Way : $807,500 6: 7000 Flamingo Drive : $790,000 7: 71 Canary Drive : $199,700 8: 7900 Plainview Drive : $195,500
----Choose action to be performed----
choice: 2 Enter the position: 2 ----Choose action to be performed----
----Choose action to be performed----
choice : 8 Enter the position : 7 The item is : 7900 Plainview Drive : $195 ,500 Enter the new price : 205000 ----Choose action to be performed ----
----Choose action to be performed ----
choice : 10 Enter an output file path : propertyData2 . txt ----Choose action to be performed ----
choice : 0 ... Terminating 19 Online and Recursive Algorithms 9:3.628800e+05 10:3.628800e+06 ... 140:1.346201e+241 141:1.898144e+243 142:2.695364e+245 143:3.854371e+247 144:5.550294e+249 145:8.047926e+251 146:1.174997e+254 147:1.727246e+256 148:2.556324e+258 149:3.808923e+260 150:5.713384e+262 The program can compute the approximate factorial if n as large as 170, which is the limit. % java FactorialDouble Enter a positive integer: 173 ... 151:8.627210e+264 152:1.311336e+267 153:2.006344e+269 154:3.089770e+271 155:4.789143e+273 156:7.471063e+275 157:1.172957e+278 158:1.853272e+280 159:2.946702e+282 160:4.714724e+284 161:7.590705e+286 162:1.229694e+289 163:2.004402e+291 164:3.287219e+293 165:5.423911e+295 166:9.003692e+297 167:1.503617e+300 168:2.526076e+302 169:4.269068e+304 170:7.257416e+306 171:Infinity 172:Infinity 173:Infinity % Infinity is a special value of the boxed class Double that represents the positive infinity.
The "size" of each input to the problem can be measured as a nonnegative integer.
Declare a long variable, returnValue, and store 1 in it (Line 7).
If n > 1, replace the value of returnValue with the product of compute( n -1 ) and n (Lines 8-11). A recursive call appears in Line 10.
Print the values of n and returnValue using the format n=%-4dn!=%30d.

Fundamentals of Java Programming

Sign up for access to the world's latest research

Abstract

Related papers

References (135)