09/09/10
17:40:30 1
06
CS 61B: Lecture 6
Friday, September 10, 2010
Today’s reading: Sierra & Bates pp. 282-285.
MORE ARRAYS
===========
Automatic Array Construction
----------------------------
Last lecture, we used a loop to construct all the arrays that the top-level
array references. This was necessary to construct a triangular array. But if
you want a rectangular multi-dimensional array, rather than a triangular one,
Java can create all of the arrays for you at once.
int[][] table = new int[x][y];
This declaration creates an array of x references to arrays. It also creates x
arrays of y ints. The variable "table" references the array of arrays; and
each entry in the array of arrays references one of the arrays of ints. All
the arrays are created for you at once. Similarly, Java can create three- or
ten-dimensional arrays for you, memory permitting.
We could have used a square array to store Pascal’s Triangle, but that would
have unnecessarily wasted memory. If you have enough memory, you might not
care.
When you declare a variable, you can also create array entries by using
initializers.
Human[] b = {kayla, rishi, new Human("Paolo")};
int[][] c = {{7, 3, 2}, {x}, {8, 5, 0, 0}, {y + z, 3}};
In the second example, Java constructs a non-rectangular two-dimensional array,
composed of one array of arrays and four arrays of ints.
Sadly, you can only use this notation in a declaration. You can’t write
d = {3, 7}; // Compile-time ERROR.
f({1, 2, 3}); // Compile-time ERROR.
Another subtlety of array declarations is the following.
int[] a, b, c; // a, b, and c all reference arrays.
int a[], b, c[][]; // a is 1D; c is 2D; b is not a reference/array.
int[] a, b[]; // a references a 1D array; b references a 2D array.
Arrays of Objects
-----------------
When you create a multi-dimensional array, Java can create all the arrays for
you. But when you create an array of objects, Java does not create the objects
automatically. The array contains space for references to the objects. You
must create the objects yourself.
String[] sentence = new String[3];
sentence[0] = "Word";
sentence[2] = new String();
--- -------------------- ---
sentence |.+----->| . | null | .--+---->| |
--- ---+---------------- --- empty String
|
| --------
\---->| Word |
--------
main()’s Parameter
------------------
What is the array of Strings that the main() method takes as a parameter?
It’s a list of command-line arguments sent to your Java program. Consider the
following program.
class Echo {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
If we compile this and type "java Echo kneel and worship Java", java prints
kneel
and
worship
Java
MORE LOOPS
==========
"do" Loops
----------
A "do" loop has just one difference from a "while" loop. If Java reaches
a "do" loop, it _always_ executes the loop body at least once. Java doesn’t
check the loop condition until the end of the first iteration. "do" loops are
appropriate for any loop you always want executed at least once, especially if
the variables in the condition won’t have meaningful assignments until the loop
body has been executed.
do {
s = keybd.readLine();
process(s);
} while (s.length() > 0); // Exit loop if s is an empty String.
The "break" and "continue" Statements
-------------------------------------
A "break" statement immediately exits the innermost loop or "switch" statement
enclosing the "break", and continues execution at the code following the loop
or "switch".
In the loop example above, we might want to skip "process(s)" when s is a
signal to exit (in this case, an empty String). We want a "time-and-a-half"
loop--we want to enter the loop at a different point in the read-process cycle
than we want to exit the loop at. Here are two alternative loops that do the
right thing. They behave identically. Each has a different disadvantage.
s = keybd.readLine(); | while (true) { // Loop forever.
while (s.length() > 0) { | s = keybd.readLine();
process(s); | if (s.length() == 0) {
s = keybd.readLine(); | break;
} | }
| process(s);
Disadvantage: The line "s = keybd..." | }
is repeated twice. It’s not really |
a disadvantage here, but if input | Disadvantage: Somewhat obfuscated for
took 100 lines of code, the | the reader, because the loop isn’t
duplication would make the code harder | aligned with its natural endpoint.
to maintain. Why? Because a
programmer improving the code might change one copy of the duplicated code
without noticing the need to change the other to match.
