Java Tutorial

Comparisons And Flow Control Structures

Controlling Program Flow

Boolean-Valued Expressions

Java has a data type called boolean

• possible values are true or false
• can be operated on with logical or bitwise operators, but cannot be treated as a 0 or 1 mathematically
• can be specified as a parameter type or return value for a method
• a boolean value will print as true or false

The result of a conditional expression (such as a comparison operation) is a boolean value

• simple comparisons, such as greater than, equal to, etc.
• values returned from functions
• complex combinations of simpler conditions

Condition expressions are used for program control

• branching to another section of the program under specified conditions
• repeating loops of the same section of code

Comparison Operators

• note that it is unwise to use == or != with floating-point data types, as they can be imprecise

Comparing Objects

The operators == and != test if two references point to exactly the same object in memory - they test that the numeric values of the two references are the same

The equals(Object o) method compares the contents of two objects to see if they are the same (you can override this method for your classes to perform any test you want)

Conditional Expression Examples

a = 3; b = 4;

a == b will evaluate to false

a != b will evaluate to true

a > b will evaluate to false

a < b will evaluate to true

a >= b will evaluate to false

a <= b will evaluate to true

String s = "Hello";
String r = "Hel";
String t = r + "lo";

s == t will evaluate to false

s != t will evaluate to true (they are not the same object - they are two different objects that have the same contents)

s.equals(t) will evaluate to true

String s = "Hello";
String t = s;

s == t will evaluate to true

s != t will evaluate to false (they are the same object)

s.equals(t) will evaluate to true

Note: Java will intern a literal String that is used more than once in your code; that is, it will use the same location for all occurrences of that String

String s = "Hello";
String t = "Hello";

s == t will evaluate to true, because the String object storing "Hello" is stored only once, and both s and t reference that location

s != t will evaluate to false (they are the same object)

s.equals(t) will evaluate to true

Complex boolean Expressions

Java has operators for combining boolean values with AND and OR logic, and for negating a value (a NOT operation)

• there are also bitwise operators for AND, OR and bitwise inversion (changing all 1 bits to 0, and vice versa)
• since a boolean is stored as one bit, the bitwise AND and OR operators will give the same logical result, but will be applied differently (see below)
• for some reason, the bitwise NOT cannot be applied to a boolean value

Examples:

The && and || operations are called short-circuiting, because if the first condition determines the final outcome, the second condition is not evaluated

• to force both conditions to be evaluated, use & and | for AND and OR, respectively

Example: to test if a reference is null before calling a boolean valued method on it

String s = request.getParameter("shipovernite");
if (s != null && s.equalsIgnoreCase("YES")) { . . . }

equalsIgnoreCase will only be called if the reference is not null

Simple Branching

The result of a conditional expression can be used to control program flow

if Statement

if (condition) statement;

or

if (condition) {
 zero to many statements;
}

• causes "one thing" to occur when a specified condition is met
• the one thing may be a single statement or a block of statements in curly braces
• the remainder of the code (following the if and the statement or block it owns) is then executed regardless of the result of the condition.

The conditional expression is placed within parentheses

The following flowchart shows the path of execution:

if Statement Examples

Absolute Value

If we needed the absolute value of a number (a number that would always be positive):

public class If1 {
 public static void main(String[] args) {
  int a = 5;
  System.out.println("original number is: " + a);
  if ( a < 0 ) { a = -a; }
  System.out.println("absolute value is: " + a);
  a = -10;
  System.out.println("original number is: " + a);
  if ( a < 0 ) { a = -a; }
  System.out.println("absolute value is: " + a);
 }
}

Random Selection

Task: write a brief program which generates a random number between 0 and 1. Print out that the value is in the low, middle, or high third of that range (Math.random() will produce a double value from 0.0 up to but not including 1.0).

• although it is a bit inefficient, just do three separate tests: (note that Math.random() will produce a number greater than or equal to 0.0 and less than 1.0)

public class If2 {
 public static void main(String[] args) {
  double d = Math.random();
  System.out.print("The number " + d);
  if (d < 1.0/3.0) 
   System.out.println(" is low");
  if (d >= 1.0/3.0 && d < 2.0/3.0) 
   System.out.println(" is middle");
  if (d >= 2.0/3.0) 
   System.out.println(" is high");
 }
}

Two Mutually Exclusive Branches

if ... else statement

if (condition) statement; or block
else statement; or block

• does "one thing" if a condition is true, and a different thing if it is false
• it is never the case that both things are done
• the "one thing" may be a single statement or a block of statements in curly braces
• a statement executed in a branch may be any statement, including another if or if ... else statement.

This program tells you that you are a winner on average once out of every four tries:

public class IfElse1 {
 public static void main(String[] args) {
  double d = Math.random();
  if (d < .25) System.out.println("You are a winner!");
  else System.out.println("Sorry, try again!");
 }
}

Nested if ... else Statements - Comparing a Number of Mutually Exclusive Options

Nested if ... else statements

• the else clause can contain any type of statement, including another if or if ... else
• you can test individual values or ranges of values
• once an if condition is true, the rest of the branches will be skipped
• you could also use a sequence of if statements without the else clauses (but this doesn't by itself force the branches to be mutually exclusive)

Here is the low/middle/high example rewritten using if ... else

public class IfElse2 {
 public static void main(String[] args) {
  double d = Math.random();
  System.out.print("The number " + d);
  if (d < 1.0/3.0) 
   System.out.println(" is low");
  else if (d < 2.0/3.0) 
   System.out.println(" is middle");
  else 
   System.out.println(" is high");
 }
}

• note that we only need one test for the middle value - if we reach that point in the code, d must be greater than 1.0/3.0
• similarly, we do not any test at all for the high third
• the original version worked because there was no chance that more than one message would print - that approach is slightly less efficient because all three tests will always be made, where in the if ... else version comparing stops once a match has been made.

Comparing a Number of Mutually Exclusive Options - The switch Statement

switch statement

• a switch expression (usually a variable) is compared against a number of possible values
• used when the options are each a single, constant, value that is exactly comparable (called a case)
• the switch expression must be a byte, char, short, or int
• cases may only be byte, char, short, or int values, in addition, their magnitude must be within the range of the switch expression data type
• cannot be used with floating-point datatypes or long
• cannot compare an option that is a range of values, unless it can be stated as a list of possible values, each treated as a separate case
• cases are listed under the switch control statement, within curly braces, using the case keyword
• once a match is found, all executable statements below that point are executed, including those belonging to later cases - this allows stacking of multiple cases that use the same code
• the break; statement is used to jump out of the switch block, thus skipping executable steps that are not desired
• the default case keyword catches all cases not matched above
• note that, technically speaking, the cases are labeled lines; the switch jumps to the first label whose value matches the switch expression

Usage

switch ( expression ) {
 case constant1:  
  statements;
  break;
 case constant2:
   statements;
  break;
 . . .
 case constant3:  
 case constant4MeansTheSameAs3:
   statements;
  break;
 . . .
 [default:
  statements;]
}

switch Statement Examples

Example - code that tests a character variable against several possible cases

import util.KeyboardReader;

public class Switch1 {
 public static void main(String[] args) {
  int c = 'X';
  c = KeyboardReader.getPromptedChar("Enter a letter a - d: ");
  switch (c) {
   case 'a':
   case 'A': System.out.println("A is for Aardvark");
        break;
   case 'b':
   case 'B': System.out.println("B is for Baboon");
        break;
   case 'c':
   case 'C': System.out.println("C is for Cat");
        break;
   case 'd':
   case 'D': System.out.println("D is for Dog");
        break;
   default:  System.out.println("Not a valid choice");
  }
 }
}

Points to note:

• stacking of cases for uppercase and lowercase letters allows both possibilities
• break; statements used to separate code for different cases
• default: clause used to catch all other cases not explicitly handled

Another example - taking advantage of the "fall-though" behavior without a break statement

import util.KeyboardReader;

public class Christmas {
 public static void main(String[] args) {
  int day = KeyboardReader.getPromptedInt("What day of Christmas? ");
  System.out.println(
    "On the " + day + " day of Christmas, my true love gave to me:");
  switch (day) {
   case 12: System.out.println("Twelve drummers drumming,"); 
   case 11: System.out.println("Eleven pipers piping,"); 
   case 10: System.out.println("Ten lords a-leaping,"); 
   case 9: System.out.println("Nine ladies dancing,"); 
   case 8: System.out.println("Eight maids a-milking,"); 
   case 7: System.out.println("Seven swans a-swimming,"); 
   case 6: System.out.println("Six geese a-laying,"); 
   case 5: System.out.println("Five golden rings,"); 
   case 4: System.out.println("Four calling birds,"); 
   case 3: System.out.println("Three French hens,"); 
   case 2: System.out.println("Two turtle doves, and a "); 
   case 1: System.out.println("Partridge in a pear tree!");
  }
 }
}

Comparing Objects

When comparing two objects, the == operator compares the references, to see if they are the same object (i.e., occupying the same spot in memory)

• and != tests to see if they are two different objects (even if they happen to have the same internal values)

The Object class defines an equals(Object) method intended to compare the contents of the objects

• the code written in the Object class simply compares the references using ==
• this method is overridden for most API classes to do an appropriate comparison
• for example, with String objects, the method compares the actual characters up to the end of the string
• for classes you create, you would override this method to do whatever comparisons you deem appropriate

public class Rectangle {
 private int height;
 private int width;
 
 public Rectangle(int height, int width) {
  this.height = height;
  this.width = width;
 }
 
 public boolean equals(Object other) {
  if (other instanceof Rectangle) {
   Rectangle otherRect = (Rectangle) other;
   return this.height == otherRect.height && this.width == otherRect.width;
  }
  else return false;
 }
}

The equals method compares another object to this object.

This example is necessarily somewhat complicated. It involves a few concepts we haven't covered yet, including inheritance. Because the equals method inherited from Object takes a parameter which is an Object, we need to keep that that type for the parameter (technically, we don't need to do it by the rules of Java inheritance, but because other tools in the API are coded to pass an Object to this method). But, that means that someone could call this method and pass in something else, like a String.

So, the first thing we need to do is test that the parameter was actually a Rectangle. If so, we can work with it - if not, there is no way it could be equal, so we return false.

We will cover instanceof later, but, for now, we can assume it does what it implies - test that the object we received was an instance of Rectangle. Even after that test, in order to treat it as a Rectangle, we need to do a typecast to explicitly store it into a Rectangle variable (and again, we will cover object typecasting later). Once we have it in a Rectangle variable, we can check its height and width properties.

As an aside, note that private data in one instance of a class is visible to other instances of the same class - it is only other classes that cannot see the private elements.

class ObjectEquivalenceIdentity {
 
 public static void main(String[] args) {
  Rectangle r1 = new Rectangle(10, 20);
  Rectangle r2 = new Rectangle(10, 20);
  if (r1 == r2)
   System.out.println("Same object");
  else
   System.out.println("Different objects");
  if (r1.equals(r2))
   System.out.println("Equal");
  else
   System.out.println("Not equal"); 
 }
}

Since all the important work is done in Rectangle, all we need to do here is instantiate two and compare them using both == and the equals method to see the differing results.

The output should be:

Different objects
Equal

Testing Strings for Equivalence

Example - write a brief program which has a word stored as a string of text. Print a message asking for a word, read it, then test if they are the same or not.

• you can preset the message assuming that they are incorrect, then change it if they are correct

import util.KeyboardReader;

public class StringEquals {
 public static void main(String[] args) {
  String s = "Hello";
  String t = KeyboardReader.getPromptedString("Enter a string: ");
  String message = "That is incorrect";
  if (s.equals(t)) message = "That is correct";
  System.out.println(message);
 }
}

• try this, then change equals(t) to equalsIgnoreCase(t)

Conditional Expression

Java uses the same conditional expression as C and C++

condition ? expressionIfTrue : expressionIfFalse

This performs a conditional test in an expression, resulting in the first value if the condition is true, the second if the condition is false

Note: due to operator precedence issues, it is often best to enclose the entire expression in parentheses

Example

public class Conditional {
 public static void main(String[] args) {
  int i = -6;
  String s;
  s = "i is " + ((i >= 0) ? "positive" : "negative");
  System.out.println(s);
 }
}

Note that the parentheses around the test are not necessary by the operator precedence rules, but may help make the code clearer

The parentheses around the entire conditional expression are necessary; without them, precedence rules would concatenate the boolean result onto the initial string, and then the ? operator would be flagged as an error, since the value to its left would not be a boolean.

while and do . . . while Loops

Again, the loops in Java are pretty much the same as in C - with the exception that the conditional expressions must evaluate to boolean values

while loops

while (condition) statement;

or

while (condition){
 block of statements 
}

• the loop continues as long as the expression evaluates to true
• the condition is evaluated before the start of each pass
• it is possible that the body of the loop never executes at all (if the condition is false the first time)

do ... while loops

do statement; while (condition);

or

do {
 block of statements
} while (condition);

• the condition is evaluated after the end of each pass
• the body of the loop will always execute at least once, even if the condition is false the first time

for Loops

A for loop uses a counter to progress through a series of values

• a value is initialized, tested each time through, and then modified (usually incremented) at the end of each pass, before it is tested again
• the for loop does not do anything that cannot be done with a while loop, but it puts everything that controls the looping at the top of the block

for (initialize; condition; change)
 statement;

or

for (initialize; condition; change) {
 block of statements
}

for loops often use a variable with block-level scope (existing only for the duration of the loop), created in the control portion of the loop

int j;
for (j = 0; j < 12; j++ )
 System.out.print("j = " + j);

for (int j = 0; j < 12; j++ )
 System.out.print("j = " + j);

A for loop may use multiple control variables by using the sequence operator, the comma ( , )

for (int j = 0, k = 12; j <= 12; j++, k-- )
 System.out.println(j + " " + k);

Note: if you use a block-scope variable (such as above) for the first counter, the additional ones will be block scope as well, and also will be the same type of data - i.e., the variable k above also exists only for the duration of the block. There is no way to declare two counters of different types at block-level scope..

ForEach Loops

Java 5 introduced a new type of loop, the for-each loop. When you have an array or collection class instance, you can loop through it using a simplified syntax

for (type variable : arrayOrCollection) {
 body of loop
}

The looping variable is not a counter - it will contain each element of the array or collection in turn (the actual value, not an index to it, so its type should be the same as the type of items in the array or collection). You can read the : character as if it was the word "from". We will cover this type of loop in more depth in the Arrays section.

For some reason, the looping variable must be declared within the parentheses controlling the loop - you cannot use a preexisting variable.

public class Loops1 {
 public static void main(String[] args) {
  int i = 1;
  
  System.out.println("While loop:");
  while (i <= 512) {
   System.out.println("i is " + i);
   i *= 2;
  }
  System.out.println("i is now " + i);
  
  System.out.println("Do while loop:");
  do {
   i = i - 300;
   System.out.println("i is now " + i);
  }
  while (i > 0);
  
  System.out.println("For loop:");
  for (i = 0; i < 12; i++) 
   System.out.print(" " + i);
  System.out.println();
  
  System.out.println("For loop that declares a counter:");
  for (int j = 0; j < 12; j++) 
   System.out.print(" " + j);
  System.out.println();
  
  System.out.println("ForEach loop:");
  String[] names = { "Jane", "John", "Bill" };
  for (String oneName : names) 
   System.out.println(oneName.toUpperCase());
 }
}

Additional Loop Control: break and continue

Breaking Out of a Loop

The break statement will end a loop early

• execution jumps to the first statement following the loop
• the following example prints random digits until a random value is less than 0.1

public class Break {
 public static void main(String[] args) {
  for ( ; ; ) { // creates an infinite loop
          // no initialization, no test, no increment
   double x = Math.random();
   if (x < 0.1) break;
   System.out.print((int) (x * 10) + " ");
  }
  System.out.println("Done!");
 }
}

This code loops, generating and printing a random number for each iteration. If the number is less than 0.1, we break out before printing it.

import util.*;

public class Continuer {
 public static void main(String[] args) throws IOException {
  int count = 0;
  do {
   int num = KeyboardReader.getPromptedInt("Enter an integer: ");
   if (num < 0) continue;
   count++;
   System.out.println("Number " + count + " is " + num);
  } while (count < 10);
  System.out.println("Thank you");
 }

/*
 // a better way

 public static void main(String[] args) throws IOException {
  int count = 0;
  do {
   int num = KeyboardReader.getPromptedInt("Enter an integer: ");
   if (num >= 0) {
    count++;
    System.out.println("Number " + count + " is " + num);
   }
  } while (count < 10);
  System.out.println("Thank you");
 }
*/

}

public class BreakOuter {
 public static void main(String[] args) {

  outer: for (int r = 0; r < 10; r++) {
   for (int c = 0; c < 20; c++) {
    double x = Math.random();

    //if (x < 0.02) break;
    if (x < 0.02) break outer;
    System.out.print((int) (x * 10) + " ");
   }
   System.out.println();
  }
  System.out.println("Done!");
 }
}

javac -cp c:\Webucator\Java102\ClassFiles\utilities.jar;. *.java
java -cp c:\Webucator\Java102\ClassFiles\utilities.jar;. Payroll

jar -cvf utilities.jar util\*.class

javac -d destination FileList