Chapter 6

Iteration


Chapter Goals

Investment with Compound Interest

Invest $10,000, 5% interest, compounded annually
Year
Balance
0
$10,000
1
$10,500
2
$11,025
3
$11,576.25
4
$12,155.06
5
$12,762.82

When will the balance be at least $20,000?

while Statement

while (condition)
   statement;


repeats the statement while the condition is true

while (balance < targetBalance)
{
   year++;
   double interest = balance * rate / 100;
   balance = balance + interest;
}

File Investment.java

1/**
2   A class to monitor the growth of an investment that 
3   accumulates interest at a fixed annual rate
4*/
5public class Investment
6{
7   /**
8      Constructs an Investment object from a starting balance and
9      interest rate.
10      @param aBalance the starting balanece
11      @param aRate the interest rate in percent
12   */
13   public Investment(double aBalance, double aRate)
14   {
15      balance = aBalance;
16      rate = aRate;
17      years = 0;
18   }
19
20   /**
21      Keeps accumulating interest until a target balance has
22      been reached.
23      @param targetBalance the desired balance
24   */
25   public void waitForBalance(double targetBalance)
26   {
27      while (balance < targetBalance)
28      {
29         years++;   
30         double interest = balance * rate / 100;
31         balance = balance + interest;
32      }
33   }
34
35   /**
36      Gets the current investment balance.
37      @return the current balance
38   */
39   public double getBalance()
40   {
41      return balance;
42   }
43
44   /**
45      Gets the number of years this investment has accumulated
46      interest.
47      @return the number of years since the start of the investment
48   */
49   public int getYears()
50   {
51      return years;
52   }
53
54   private double balance;
55   private double rate;
56   private int years;
57}

File InvestmentTest.java

1/**
2   This program computes how long it takes for an investment
3   to double.
4*/
5public class InvestmentTest
6{
7   public static void main(String[] args)
8   {
9      final double INITIAL_BALANCE = 10000;
10      final double RATE = 5;
11      Investment invest = new Investment(INITIAL_BALANCE, RATE);
12      invest.waitForBalance(2 * INITIAL_BALANCE);
13      int years = invest.getYears();
14      System.out.println("The investment doubled after "
15         + years + " years");
16   }   
17}

Flowchart for while Loop



Syntax 6.1. The while Statement

  while (condition)
   statement

Example:

 
while (balance < targetBalance)
{
   year++;
   double interest = balance * rate / 100;
   balance = balance + interest;
}

Purpose:

To execute a statement while a condition is true

Common Error: Infinite Loop

while (year < 20)

   balance = balance +
      balance * rate / 100; 
}

while (year > 0)

   year++; // oops, meant --
   . . .
}

Loops run forever--must kill program

Common Error: Off-by-1 Error

Avoiding Off-by-1 Error


do Statement

Executes loop body at least once:
do 
statement
while (condition);

Example: Validate input

double value;
do
{
String input = JOptionPane.showInputDialog(
"Please enter a positive number");
value = Integer.parseInt(input);
}
while (input <= 0);

Flowchart for do Loop


for Statement

Flowchart for for Loop


File Investment.java

1/**
2   A class to monitor the growth of an investment that 
3   accumulates interest at a fixed annual rate
4*/
5public class Investment
6{
7   /**
8      Constructs an Investment object from a starting balance and
9      interest rate.
10      @param aBalance the starting balanece
11      @param aRate the interest rate in percent
12   */
13   public Investment(double aBalance, double aRate)
14   {
15      balance = aBalance;
16      rate = aRate;
17      years = 0;
18   }
19
20   /**
21      Keeps accumulating interest until a target balance has
22      been reached.
23      @param targetBalance the desired balance
24   */
25   public void waitForBalance(double targetBalance)
26   {
27      while (balance < targetBalance)
28      {
29         years++;   
30         double interest = balance * rate / 100;
31         balance = balance + interest;
32      }
33   }
34
35   /**
36      Keeps accumulating interest for a given number of years.
37      @param n the number of years
38   */
39   public void waitYears(int n)
40   {
41      for (int i = 1; i <= n; i++)
42      {
43         double interest = balance * rate / 100;
44         balance = balance + interest;
45      }
46      years = years + n;
47   }
48
49   /**
50      Gets the current investment balance.
51      @return the current balance
52   */
53   public double getBalance()
54   {
55      return balance;
56   }
57
58   /**
59      Gets the number of years this investment has accumulated
60      interest.
61      @return the number of years since the start of the investment
62   */
63   public int getYears()
64   {
65      return years;
66   }
67
68   private double balance;
69   private double rate;
70   private int years;
71}

File InvestmentTest.java

1/**
2   This program computes how much an investment grows in
3   a given number of years.
4*/
5public class InvestmentTest
6{
7   public static void main(String[] args)
8   {
9      final double INITIAL_BALANCE = 10000;
10      final double RATE = 5;
11      final int YEARS = 20;
12      Investment invest = new Investment(INITIAL_BALANCE, RATE);
13      invest.waitYears(YEARS);
14      double balance = invest.getBalance();
15      System.out.println("The balance after " + YEARS + 
16         " years is " + balance);
17   }   
18}

Syntax 6.2. The for Statement

  for (initialization; condition; update )
   statement

Example:

  for (int i = 1; i <= n; i++)
{
   double interest = balance * rate / 100;
   balance = balance + interest;
}

Purpose:

To execute an initialization, then keep executing a statement and updating an expression while a condition is true

Common Errors: Semicolons

Nested Loops

File Triangle.java

1/**
2   This class describes triangle objects that can be displayed
3   as shapes like this:
4   []
5   [][]
6   [][][]
7*/
8public class Triangle
9{
10   /**
11      Constructs a triangle.
12      @param aWidth the number of [] in the last row of the triangle.
13   */
14   public Triangle(int aWidth)
15   {
16      width = aWidth;
17   }
18
19   /**
20      Computes a string representing the triangle.
21      @return a string consisting of [] and newline characters
22   */
23   public String toString()
24   {
25      String r = "";
26      for (int i = 1; i <= width; i++)
27      {  
28         // make triangle row
29         for (int j = 1; j <= i; j++)
30            r = r + "[]";
31         r = r + "\n";
32      }
33      return r;
34   }
35
36   private int width;
37}

File TriangleTest.java

1/**
2   This program tests the Triangle class.
3*/
4public class TriangleTest
5{
6   public static void main(String[] args)
7   {
8      Triangle small = new Triangle(3);
9      System.out.println(small.toString());
10
11      Triangle large = new Triangle(15);
12      System.out.println(large.toString());
13   }
14}

Reading Input Values

General pattern:
boolean done = false;
while (!done)
{
String input = read input;
if (end of input indicated)
done = true;
else
{
process input
}
}

"Loop and a half"

File DataSet.java

1/**
2   Computes the average of a set of data values.
3*/
4public class DataSet
5{
6   /**
7      Constructs an empty data set.
8   */
9   public DataSet()
10   {
11      sum = 0;
12      count = 0;
13      maximum = 0;
14   }
15
16   /**
17      Adds a data value to the data set
18      @param x a data value
19   */
20   public void add(double x)
21   {
22      sum = sum + x;
23      if (count == 0 || maximum < x) maximum = x;
24      count++;
25   }
26
27   /**
28      Gets the average of the added data.
29      @return the average or 0 if no data has been added
30   */
31   public double getAverage()
32   {
33      if (count == 0) return 0;
34      else return sum / count;
35   }
36
37   /**
38      Gets the largest of the added data.
39      @return the maximum or 0 if no data has been added
40   */
41   public double getMaximum()
42   {
43      return maximum;
44   }
45
46   private double sum;
47   private double maximum;
48   private int count;
49}

File InputTest.java

1import javax.swing.JOptionPane;
2
3/**
4   This program computes the average and maximum of a set
5   of input values.
6*/
7public class InputTest
8{  
9   public static void main(String[] args)
10   {  
11      DataSet data = new DataSet();
12
13      boolean done = false;
14      while (!done)
15      {  
16         String input = JOptionPane.showInputDialog("Enter value, Cancel to quit");
17         if (input == null)
18            done = true;
19         else
20         {  
21            double x = Double.parseDouble(input);
22            data.add(x);
23         }
24      }
25
26      System.out.println("Average = " + data.getAverage());
27      System.out.println("Maximum = " + data.getMaximum());
28   }
29}

String Tokenization

File InputTest.java

1import java.util.StringTokenizer;
2import javax.swing.JOptionPane;
3
4/**
5   This program computes the average and maximum of a set
6   of input values that are entered on a single line.
7*/
8public class InputTest
9{  
10   public static void main(String[] args)
11   {  
12      DataSet data = new DataSet();
13
14      String input = JOptionPane.showInputDialog("Enter values:");
15      StringTokenizer tokenizer = new StringTokenizer(input);
16      while (tokenizer.hasMoreTokens())
17      {  
18         String token = tokenizer.nextToken();
19   
20         double x = Double.parseDouble(token);
21         data.add(x);
22      }
23
24      System.out.println("Average = " + data.getAverage());
25      System.out.println("Maximum = " + data.getMaximum());
26   }
27}

Traversing Characters in String

Random Numbers


File Die.java

1import java.util.Random;
2
3/**
4   This class models a die that, when cast, lands on a random
5   face.
6*/
7public class Die
8{
9   /**
10      Constructs a die with a given number of sides
11      @param s the number of sides, e.g. 6 for a normal die
12   */
13   public Die(int s)
14   {
15      sides = s;
16      generator = new Random();
17   }
18
19   /**
20      Simulates a throw of the die
21      @return the face of the die 
22   */
23   public int cast()
24   {
25      return 1 + generator.nextInt(sides);
26   }
27
28   
29   private Random generator;
30   private int sides;
31}

File DieTest.java

1/**
2   This program simulates casting a die ten times.
3*/
4public class DieTest
5{
6   public static void main(String[] args)
7   {
8      Die d = new Die(6);
9      final int TRIES = 10;
10      for (int i = 1; i <= TRIES; i++)
11      {  
12         int n = d.cast();
13         System.out.print(n + " ");
14      }
15      System.out.println();
16   }
17}

Buffon Needle Experiment


Needle Position


File Needle.java

1import java.util.Random;
2
3/**
4   This class simulates a needle in the Buffon needle experiment.
5*/
6public class Needle
7{
8   /**
9      Constructs a needle.
10   */
11   public Needle()
12   {
13      hits = 0;
14      generator = new Random();
15   }
16
17   /**
18      Drops the needle on the grid of lines and 
19      remembers whether the needle hit a line.
20   */
21   public void drop()
22   {
23      double ylow = 2 * generator.nextDouble();
24      double angle = 180 * generator.nextDouble();
25      
26      // compute high point of needle
27      
28      double yhigh = ylow + Math.sin(Math.toRadians(angle));
29      if (yhigh >= 2) hits++;    
30      tries++;
31   }
32
33   /**
34      Gets the number of times the needle hit a line.
35      @return the hit count
36   */
37   public int getHits()
38   {
39      return hits;
40   }
41
42   /**
43      Gets the total number of times the needle was dropped.
44      @return the try count
45   */
46   public int getTries()
47   {
48      return tries;
49   }
50        
51   private Random generator;
52   private int hits;
53   private int tries;
54}

File NeedleTest.java
1/**
2   This program simulates the Buffon needle experiment 
3   and prints the resulting approximations of pi.
4*/
5public class NeedleTest
6{
7   public static void main(String[] args)
8   {
9      Needle n = new Needle();
10      final int TRIES1 = 10000;
11      final int TRIES2 = 100000;
12
13      for (int i = 1; i <= TRIES1; i++)
14         n.drop();
15      System.out.println("Tries / Hits = "
16         + (double)n.getTries() / n.getHits());
17
18      for (int i = TRIES1 + 1; i <= TRIES2; i++)
19         n.drop();
20      System.out.println("Tries / Hits = "
21         + (double)n.getTries() / n.getHits());           
22   }
23}