lect11a
practice for-each
lect11a

Quiz or Exam coming up: Apr.02 (before the Withdraw-deadline)

Review

We have seen LinkedLists, as a great way to store any number of items. To process the contents of a list, we use for-each:

java.util.LinkedList<Double> dubs = new java.util.LinkedList<Double>();
// ... add items to dubs

double sumSoFar = 0.0;
for ( Double dd : dubs ) {
  sumSoFar = sumSoFar + dd.doubleValue();
  }

// At this point, sumSoFar contains the sum of all numbers in dubs.

Prounounced “for each Double dd in dubs”.
Realize that the purpose of a loop is to do some task over-and-over. The first line (for) gives the loop's control structure: it indicates exactly what over-and-over means. The part between curly-braces is the body of the loop, specifying what needs to be done over and over.
The for statement is pretty fancy: it causes Java to evaluate the loop-body repeatedly; each time it contrives to have dd be (a reference to) a different item in the list.
When writing a loop, ask yourself:
- What is the individual task you want to do over and over? Write that one task, assuming you're given one variable which refers to one particular element of the collection.
  That is, ask yourself what the loop's body is, without yet worrying about the control structure.
- What is the loop's control structure?
  That is, what is “over and over”? How to get Java to give us the loop variable, which ranges over the collection one-by-one? This is a separate question from “what is in the body of the loop”.
- What initialization needs to be done, before the loop ever starts?
- More generally, what is the loop invariant -- a statement which is true every time through the loop? For the above loop, the invariant is: “The variable sumSoFar contains the sum of the doubleValue of each Double processed so far.”
  Note that this invariant is true (a) before the loop even begins, (b) after the 20th iteration (presuming the loop goes at least 20 steps), and (c) the moment the loop finishes. ² Being forced to write down a concise loop invariant forces you to really understand what your loop is doing. (We'll see examples later, where the invariant is more involved, and not necessarily obvious.)
Loops are neat, since there is no limit on how many times the body might be performed, depending on the List being looped over. What is the least number of times the body might be performed?
As written, the local-variable sumSoFar is declared and initialized before we start the loop. What would happen, if we put it inside the loop?
The local-variable dd is actually declared as part of the loop statement. It's scope is the loop-body (only!). After the loop finishes, you can't access dd. ⁴

java source, all files (source), all files (.jar).

Lists hold references

Try the following in Code Pad: Create a few Dog objects (stored in variables d1, d2, d3) and then:

import java.util.LinkedList;    // The only time you don't use angle-brackets.

Dog d1 = new Dog();
Dog d2 = new Dog();
Dog d3 = new Dog();
d2.ageOneYear();


LinkedList<Dog> doggies = new LinkedList<Dog>();
doggies.add(d1)
doggies.add(d2)
doggies.add(d3)

// Draw a picture.  
//  (How many Dog objects exist?  How many LinkedLists?)
//    How many variables?)


doggies.add(d2)
doggies.toString()

d2.ageOneYear();
doggies.toString()

reminder: Sometimes people confuse the variable referring to the list, with the loop-variable which refers to an element of the list. They are very different!

You don't confuse an apple with a bag-of-apples; you don't confuse a bus-passenger with a bus; so similarly don't confuse an item with a collection-of-items.

Searching

Given a list of Dogs, …

Write a loop to compute how many one-year-old Dogs are in the list.
Write a method to determine whether a given list contains any one-year-old Dog. (Two versions.) Ian: strongly de-emphasize returning from the middle of loop; it makes the problem look unlike any other loop, where we always had an accumulator variable.
Write a method to return the oldest Dog in the list. (More precisely, an oldest Dog.) What needs to be true, in order to guarantee this problem makes sense? (You'll answer this when you make your test cases!)

A directory is a list of files

Here's a method which gives a directory-listing: It gives a list of files (and their sizes), for each file inside a directory.

  /** Return The sum of the length of each file immediately inside directoryName.
   *    Doesn't recur into any sub-directories (but does include any size a directory
   *    itself takes up, aside from its sub-contents).
   * @param  directoryName  The pathname of a directory. 
   * @return The sum of the length of each file immediately inside directoryName.
   */
  public long directoryListing( String directoryName ) {
    // Convert the directoryName into a File object, so we can get its size etc.:
    File theDirectory = new File( directoryName );
    // import java.io.File at the top of this file, so we don't need to use its full name.


    long sizeSoFar = 0; // Accumulate the sum of all immediate file sizes.

    for ( File f : theDirectory.listFiles() ) {  // For each `f' in the directory,
      sizeSoFar = sizeSoFar + f.length();        // Add f's length to our sum.
      }

    return sizeSoFar;
    }

(Full program w/ examples of the data)
(Note that this code does not descend into sub-folders. In fact, file-structures are a bit weird, in that they distinguish between the disk-space needed to store basic information about a folder, and the size of everything held inside that folder. Can you make an analogy of this, in terms of objects and references?)

building new lists, based on old lists

We will work through one or two of these problems in class; you should use the others as practice.

Modify the directory-size method above to instead return a LinkedList<String> of filenames.
Modify the directory-size method above to instead return a LinkedList<java.io.File> of all files bigger than 1MB.
Write a method which, given a list of Dogs, returns another list of newly-created Dogs, each of which is twice as old as the corresponding Dog in the original list. (That is, given the list whose String representation is "[[Dog: age: 4, sound: \"woof\"], [Dog: age: 1, sound: \"arf\"]]", return the list "[[Dog: age: 8, sound: \"woof\"], [Dog: age: 2, sound: \"arf\"]]". (Do not change any of the Dogs in the original input list.)
Write a method which, given a list of Dogs, returns a list of all one-year-old Dogs within the list. (It should contain identically the same Dog references as stored in the original input list.)

building lists with fewer items than others

Write a method which returns a list of Strings -- the names of each file larger than 1MB.

(Really, it'd be more appropriate to return a list of java.io.Files; that way whoever calls our method can do what they want with the files -- whether it is just get their filenames, or something fancier like moving them to a different directory. (You are strongly advised not to write any programs which try to modify your disk files at all!) )

²There are also two other steps, to be technically correct: (0) the invariant holds before the loop even begins, and (3) the loop will eventually halt. ↩

¹When trying to convince somebody your loop is correct, there are two important ² steps: (1) In the case that the loop isn't done yet, argue that the loop-invariant being true before the loop begins implies that the loop-invariant holds again after the entire body finishes. (2) In the case that the loop is finished, then the loop invariant is enough to prove that you have computed what you claimed to compute. Although rarely do other people ask you to show these facts about your loops, it does help you understand your loop, to be forced to write down your loop invariant. ↩

⁴ It's usually poor style to write a loop which needs to refer to this last value. (For example, if your code goes back and un-does the last iteration of the loop body, this is sloppy. It also is problematic when the loop body is never performed even once (such as when you have an empty list).) ↩

³ Technically, you can write a for loop where you don't declare a new local variable, and instead mention an existing variable to hold the loop value. In that case, that variable still exists after the loop finishes, and it holds the ⁴ the most recent value through the loop. ↩

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2007, Ian Barland, Radford University
Last modified 2007.Aug.27 (Mon) Please mail any suggestions
(incl. typos, broken links)
to iba�rlandrad�ford.edu