ITEC 120 2010fall ibarland

home—info—lects—labs—exams—hws
tutor/PIs—breeze (snow day)
Object120 + its docs—java.lang docs—java.util docs

lect10c
searching for max
and, reading from a Scanner

The remaining weeks' topics, jfyi:

• arrays (objects whose fields are 'named' 0,1,2,3,4,...);
• Objects containing objects
• inheritance

Shorthand notation:

• (Review:) indx = indx + 1 can be abbreviated indx += 1.
  Similarly, what does someNum *= 3 do?
  How about ssf += s.nextInt()?
• The full-name of classes can be pretty long — “java.util.Scanner”, “java.util.Random”, (especially because we use the full name to the type when declaring a local-variable, the type when declaring a parameter, as well as to call the constructor).
  You can tell the compiler you're on a first-name basis with other classes by using “import”:

  import java.util.Scanner; import java.util.Random; import java.util.List; /** Comments for MyClass must immediately precede the class, as always. * (Don't put `import` statements *between* the comment and what it's describing). * @author Me McMyself */ class MyClass { static java.util.Scanner s = new java.util.Scanner( System.in ); ⋮ }

  Note that import doesn't do anything mysterious/fundamental — it only saves you typing!
  It's a win if you use the class frequently, but we don't always do that -- e.g. for both Scanner and Random, we tend to have one static field, and so we only mention their name twice (to declare the field, and to call the constructor). (How many characters do you save by importing these classes?)

Consider the following function:

  static String mystery( String s, int a, int b ) {
    String somethingSoFar = "";
    for ( int i=a;  i < b && i < s.length();  i += 1 ) {
      somethingSoFar += s.charAt(i);
    }
    return somethingSoFar;
  }

• By hand, trace through exactly what happens when you call mystery("programming", 3, 7 ).
• What does mystery("Shenanigan", 1, 3) return?
  How about mystery("abcde", 3, 11) return?
• What is a better name for this function, and for its accumulator variable?

We will go through some of these in lecture; on your own work through the remaining problems (seeing me or a peer instructor if you have difficulties/questions). (These are all eminently reasonable questions for an exam!)
In all cases, come up with at least 3 test cases.

• Write indexOf(String,char), which returns the index of a given character within a given String. (What interesting case to worry about?)
  (Do it without calling the built-in java.lang.String#indexOf.)
  Looper.java#indexOf
• Write contains(String,char), which returns whether a given character occurs in a given String.
  (Do it without calling the built-in java.lang.String#contains.)
• Write equals(String,String).
  (Do it without calling the built-in java.lang.String#equals.)
• write contains(String,String), which returns whether one string contains another anywhere, as a substring.
  (Do it without calling the built-in java.lang.String#contains.)
• write long powerTwoBiggerThan(long), which returns the first power of two which is bigger than the given number.
  (You can do this with or without calling java.lang.Math#pow; what are the relative merits of each approach?)

If we finish these examples, we will talk about:

• Recall: to read numbers from the keyboard repeatedly, we could use the Scanner methods hasNextInt() and nextInt():

  import java.util.Scanner; class Lect10c { void echoNumbers() { Scanner s = new Scanner( System.in ); // s will gather chars from the keyboard System.out.println( "Please type in numbers, followed by a word (or, ^D)." ); while (s.hasNextInt()) { System.out.println( "Read " + s.nextInt() ); // Usually we update our index variable, to update // our notion of where we are in the process; // but in this case calling 'nextInt' already udpated // what characters had been consumed from the input stream. } System.out.println( "There isn't an int to read next." ); } }

Task: Read numbers from keyboard (as long as hasNextInt()), and return the largest number typed.

• First, some test cases. These are a bit difficult, since the problem will read numbers which get typed in at run-time. So we'll describe what a user (like my mom) might type in, and decide what the answer should be:

  input typed by the user	expected result of calling maxFromKeyboard
  3 17 9 2 21 bye-bye	21
  -3 -17 -9 -2 -21 stoppity-stop	-2
  3 bye-bye	3
  bye-bye	no conceivable answer -- a run-time error perhaps?

  What do our test cases tell us, about the fewest number of times our loop might happen? One — because the max of zero items isn't defined!

• // ATTEMPT 1 -- does not work correctly // Read the maximum integer typed at the keyboard. // Keep reading until some non-integer gets typed. // THERE MUST BE AT LEAST ONE INTEGER TYPED else our program will cause an error. // int maxFromKeyboard() { Scanner s = new Scanner( System.in ); int maxSoFar; while (s.hasNextInt()) { if (maxSoFar < s.nextInt()) { maxSoFar = s.nextInt(); } // else do nothing. } return maxSoFar; }

  This has a couple of problems. Can you find them? In both cases, we find the problems by working the some test inputs by hand.

• One problem is that we don't initiailze our accumulator maxSoFar. (If we don't initialize a local, Java won't even let us compile.¹)

  However, it's not clear what to initialize it to? Clearly, 0 won't work: our second test case wouldn't pass. (Why not?)
  Something like negative infinity would work in this case, but the technique doesn't generalize (suppose you wanted to find the minimum-length string that is typed in — there is no 'infinite-string' value).
  A clever solution (possibly inspired by how you'd solve this problem in real life): Use the very first value, as your maxSoFar! We know that there is always going to be such a first value (since max is undefined on the empty sequence of numbers):

• Okay, we still have a problem; work through a test-input or two to find it.

  // ATTEMPT 2 -- compiles, but still does not work correctly // Read the maximum integer typed at the keyboard. // Keep reading until some non-integer gets typed. // THERE MUST BE AT LEAST ONE INTEGER TYPED else our program will cause an error. // int maxFromKeyboard() { Scanner s = new Scanner( System.in ); int maxSoFar = s.nextInt(); // If there isn't an int to read, the scanner will blow up, but that's okay: // our comment clearly states there must be at least one integer. while (s.hasNextInt()) { if (maxSoFar < s.nextInt()) { maxSoFar = s.nextInt(); } // else do nothing. } return maxSoFar; }

  The glitch is that s.nextInt() gives back a new number each time it is called -- so the value we assign to maxSoFar is not the same value we just compared against!

  The solution is pretty easy: store the result of the first s.nextInt() in a variable, and then use that one variable twice:

  // ATTEMPT 3 -- works! // Read the maximum integer typed at the keyboard. // Keep reading until some non-integer gets typed. // THERE MUST BE AT LEAST ONE INTEGER TYPED else our program will cause an error. // int maxFromKeyboard() { Scanner s = new Scanner( System.in ); int maxSoFar = in.nextInt(); // If there isn't an int to read, the scanner will blow up, but that's okay: // our comment clearly states there must be at least one integer. while (s.hasNextInt()) { int currentNum = s.nextInt(); if (maxSoFar < currentNum) { maxSoFar = currentNum; } // else do nothing. } return maxSoFar; }

  
  However, it's also worth wondering why this error happened: It's because the method nextInt() does two things: returns a value, and changes state (namely, what input has been consumed). There's nothing fundamentally wrong with that, but it tends to lead to errors like the above: other programmers call the program for the return value, forgetting that there is also some side-effect. That's why our code should follow this principle (which Scanner doesn't quite):

  design principle: A method should either return a value or mutate state, but not both.
  (Use two different methods — a getter and a mutator — if you want to do these two different things.)

• Note that using Math.max is a sneaky way to avoid the if, which obviates the need for a local variable:

  while (s.hasNextInt()) { maxSoFar = Math.max( maxSoFar, s.nextInt() ); }

  (While Math.max is a handy method, it's of course not guaranteed to get rid of all your need of local variables.)

• Walking through characters in a string — find the largest character.
• Loops which might stop “early”: Does a string contain the letter 'X'? Note that we still have an accumulator “so-far” variable and an index variable — but we can get fancier in our condition if we want. Does the program run much quicker, when we are fancy and stop earlier? (For what inputs is it a big win?)

home—info—lects—labs—exams—hws
tutor/PIs—breeze (snow day)
Object120 + its docs—java.lang docs—java.util docs

©2010, Ian Barland, Radford University Last modified 2010.Nov.05 (Fri)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu