Thinking in Java - 4th Edition
1079 pág.

Thinking in Java - 4th Edition

Disciplina:Programação Orientada a Objetos1.261 materiais32.119 seguidores
Pré-visualização50 páginas
5);
 print(result);
 }
} /* Output:
1
-1
0
*///:~

In the middle of test( ), you’ll also see an “else if,” which is not a new keyword but just an
else followed by a new if statement.

Although Java, like C and C++ before it, is a “free-form” language, it is conventional to indent
the body of a control flow statement so the reader can easily determine where it begins and
ends.

Iteration
Looping is controlled by while, do-while and for, which are sometimes classified as
iteration statements. A statement repeats until the controlling Boolean-expression evaluates
to false. The form for a while loop is:

while(Boolean-expression)
 statement

The Boolean-expression is evaluated once at the beginning of the loop and again before each
further iteration of the statement.

Here’s a simple example that generates random numbers until a particular condition is met:

//: control/WhileTest.java
// Demonstrates the while loop.
public class WhileTest {
 static boolean condition() {
 boolean result = Math.random() < 0.99;
 System.out.print(result + ", ");
 return result;
 }
 public static void main(String[] args) {
 while(condition())
 System.out.println("Inside ‘while’");
 System.out.println("Exited ‘while’");
 }
} /* (Execute to see output) *///:~

94 Thinking in Java Bruce Eckel

The condition( ) method uses the static method random( ) in the Math library, which
generates a double value between 0 and 1. (It includes 0, but not 1.) The result value comes
from the comparison operator <, which produces a boolean result. If you print a boolean
value, you automatically get the appropriate string “true” or “false.” The conditional
expression for the while says: “repeat the statements in the body as long as condition( )
returns true.”

do-while

The form for do-while is

do
 statement
while(Boolean-expression);

The sole difference between while and do-while is that the statement of the do-while
always executes at least once, even if the expression evaluates to false the first time. In a
while, if the conditional is false the first time the statement never executes. In practice, do-
while is less common than while.

for

A for loop is perhaps the most commonly used form of iteration. This loop performs
initialization before the first iteration. Then it performs conditional testing and, at the end of
each iteration, some form of “stepping.” The form of the for loop is:

for(initialization; Boolean-expression; step)
 statement

Any of the expressions initialization, Boolean-expression or step can be empty. The
expression is tested before each iteration, and as soon as it evaluates to false, execution will
continue at the line following the for statement. At the end of each loop, the step executes.

for loops are usually used for “counting” tasks:

//: control/ListCharacters.java
// Demonstrates "for" loop by listing
// all the lowercase ASCII letters.
public class ListCharacters {
 public static void main(String[] args) {
 for(char c = 0; c < 128; c++)
 if(Character.isLowerCase(c))
 System.out.println("value: " + (int)c +
 " character: " + c);
 }
} /* Output:
value: 97 character: a
value: 98 character: b
value: 99 character: c
value: 100 character: d
value: 101 character: e
value: 102 character: f
value: 103 character: g
value: 104 character: h
value: 105 character: i
value: 106 character: j
...

Controlling Execution 95 

*///:~

Note that the variable c is defined at the point where it is used, inside the control expression
of the for loop, rather than at the beginning of main( ). The scope of c is the statement
controlled by the for.

This program also uses the java.lang.Character “wrapper” class, which not only wraps the
primitive char type in an object, but also provides other utilities. Here, the static
isLowerCase( ) method is used to detect whether the character in question is a lowercase
letter.

Traditional procedural languages like C require that all variables be defined at the beginning
of a block so that when the compiler creates a block, it can allocate space for those variables.
In Java and C++, you can spread your variable declarations throughout the block, defining
them at the point that you need them. This allows a more natural coding style and makes
code easier to understand.

Exercise 1: (1) Write a program that prints values from 1 to 100.

Exercise 2: (2) Write a program that generates 25 random int values. For each value,
use an if-else statement to classify it as greater than, less than, or equal to a second
randomly generated value.

Exercise 3: (1) Modify Exercise 2 so that your code is surrounded by an “infinite” while
loop. It will then run until you interrupt it from the keyboard (typically by pressing Control-
C).

Exercise 4: (3) Write a program that uses two nested for loops and the modulus
operator (%) to detect and print prime numbers (integral numbers that are not evenly
divisible by any other numbers except for themselves and 1).

Exercise 5: (4) Repeat Exercise 10 from the previous chapter, using the ternary operator
and a bitwise test to display the ones and zeroes, instead of Integer.toBinaryString( ).

The comma operator

Earlier in this chapter I stated that the comma operator (not the comma separator, which is
used to separate definitions and method arguments) has only one use in Java: in the control
expression of a for loop. In both the initialization and step portions of the control
expression, you can have a number of statements separated by commas, and those
statements will be evaluated sequentially.

Using the comma operator, you can define multiple variables within a for statement, but
they must be of the same type:

//: control/CommaOperator.java
public class CommaOperator {
 public static void main(String[] args) {
 for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
 System.out.println("i = " + i + " j = " + j);
 }
 }
} /* Output:
i = 1 j = 11
i = 2 j = 4

96 Thinking in Java Bruce Eckel

i = 3 j = 6
i = 4 j = 8
*///:~

The int definition in the for statement covers both i and j. The initialization portion can
have any number of definitions of one type. The ability to define variables in a control
expression is limited to the for loop. You cannot use this approach with any of the other
selection or iteration statements.

You can see that in both the initialization and step portions, the statements are evaluated in
sequential order.

Foreach syntax
Java SE5 introduces a new and more succinct for syntax, for use with arrays and containers
(you’ll learn more about these in the Arrays and Containers in Depth chapter). This is often
called the foreach syntax, and it means that you don’t have to create an int to count through
a sequence of items—the foreach produces each item for you, automatically.

For example, suppose you have an array of float and you’d like to select each element in that
array:

//: control/ForEachFloat.java
import java.util.*;
public class ForEachFloat {
 public static void main(String[] args) {
 Random rand = new Random(47);
 float f[] = new float[10];
 for(int i = 0; i < 10; i++)
 f[i] = rand.nextFloat();
 for(float x : f)
 System.out.println(x);
 }
} /* Output:
0.72711575
0.39982635
0.5309454
0.0534122
0.16020656
0.57799757
0.18847865
0.4170137
0.51660204
0.73734957
*///:~

The array is populated using the old for loop, because it must be accessed with an index. You
can see the foreach syntax in the line:

for(float x : f) {

This defines a variable x of type float and sequentially assigns each element of f to x.

Any method that returns an array is a candidate for use with foreach. For example, the
String class has a method toCharArray( ) that returns an array of char, so you can easily
iterate through the characters