Random Numbers, Histograms, and the Enhanced for Loop

1. Random Numbers, Histograms, and the Enhanced for Loop

Title

Think Java 2e · Chapter 7 · Arrays and References

Sections 7.6-7.9 · pp. 115-121

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 7 (Arrays and References), Sections 7.6-7.9, pp. 115-121. Everything on these slides can be checked against those pages.

1. Use java.util.Random to fill an array with pseudorandom values, and say what nextInt(n) returns.

2. Explain what deterministic means and why pseudorandom is not the same as random.

3. Write a counting reduce that counts elements falling in a range.

4. Build a histogram in a single pass by using a value as an index into a counter array.

5. Write an enhanced for loop, and say when it cannot be used.

6. Convert a character to an array index with letter - 'a', and explain why that works.

• 7.6 — Random Numbers
• 7.7 — Building a Histogram
• 7.8 — The Enhanced for Loop
• 7.9 — Counting Characters

3. Retrieve before you read

Warm-up

One fact from the previous lesson decides how the histogram is built.

4. Using a value as an index

Concept

The chapter opened with a problem: counting 26 letters without declaring 26 variables. This lesson finishes it. The key move is to stop thinking of an index as a position and start thinking of it as a name for a counter.

• 7.6 — random numbers, and how to fill an array with them
• 7.7 — histograms: counting in ranges, then counting in one pass
• 7.8 — the enhanced for loop
• 7.9 — counting characters, and the complete doubloon program

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 7 (Arrays and References), Sections 7.6-7.9, pp. 115-121 — Sections 7.6-7.9, printed pages 115-121.

5. Random numbers

Section

Section 7.6

6. Computers cannot be truly random

Concept

Most programs do the same thing every time they run; such programs are deterministic. Usually that is a good thing — we expect the same calculation to yield the same result. But games, and scientific simulations, need the computer to be unpredictable.

import java.util.Random;

Random random = new Random();
int n = random.nextInt(100);     // 0 to 99 inclusive

deterministic — Doing the same thing every time it runs.

pseudorandom — Produced by an algorithm that generates an unpredictable-looking sequence, which is not truly random.

Making a program nondeterministic turns out to be hard, because it is impossible for a computer to generate truly random numbers. But there are algorithms producing unpredictable sequences called pseudorandom numbers, and for most applications they are as good as random.

7. What nextInt(n) actually promises

Notation

The range is the detail people get wrong, and it is the same off-by-one shape as everything else in this chapter.

If you generate a long series of random numbers, every value should appear approximately the same number of times. Testing that claim is exactly what the histogram in the next section does.

8. Filling an array with random values

Worked example

This method creates an int array and fills it with random numbers between 0 and 99. The argument gives the desired size, and the return value is a reference to the new array.

public static int[] randomArray(int size) {
    Random random = new Random();
    int[] a = new int[size];
    for (int i = 0; i < a.length; i++) {
        a[i] = random.nextInt(100);
    }
    return a;
}

9. What range does nextInt(6) produce?

Prediction

The argument is the number of possible values.

Random random = new Random();
int n = random.nextInt(6);

10. Returning an array from a method

Concept

randomArray is the first method in the book to return an array, and it is worth being precise about what crosses the boundary.

The array was created inside the method, yet it survives the method returning — unlike the local variables in Lesson 4a, which vanish with their frame. What vanishes is the method's variable a; the array itself lives on because the caller now holds a reference to it. Chapter 10's garbage collection section explains when it is finally cleaned up.

11. Creating a new Random inside the loop

Trap

int[] a = new int[size];
for (int i = 0; i < a.length; i++) {
    Random random = new Random();     // inside the loop
    a[i] = random.nextInt(100);
}

public static int[] randomArray(int size) {
    Random random = new Random();
    int[] a = new int[size];
    for (int i = 0; i < a.length; i++) {
        a[i] = random.nextInt(100);
    }
    return a;
}

12. Roll a die

Fill the middle

Produce a value from 1 to 6.

13. Why can't a computer be truly random?

Socratic

Think Java says it is impossible. Work out why.

14. Where does each declaration belong?

Definition probe

Inside the loop, or outside it?

15. Counting in ranges

Section

Section 7.7

16. A histogram is a set of counters

Concept

If those random values were exam scores, a teacher might present them as a histogram — in statistics, a set of counters that keeps track of the number of times each value appears.

public static int inRange(int[] a, int low, int high) {
    int count = 0;
    for (int i = 0; i < a.length; i++) {
        if (a[i] >= low && a[i] < high) {
            count++;
        }
    }
    return count;
}

This pattern should look familiar: it is another reduce operation from Lesson 7a. Notice that low is included with >= but high is excluded with < — this design keeps us from counting any score twice.

17. Why the ranges must not overlap

Picture it

Half-open ranges — include the bottom, exclude the top — are the same convention as substring in Lesson 6b, and they exist for the same reason.

With half-open ranges the boundaries line up: the top of one range is the bottom of the next, so the ranges tile the whole scale with no gaps and nothing counted twice.

18. Counting the grade ranges

Worked example

With inRange written, counting the five grade bands is five calls. This code is repetitive, and acceptable as long as the number of ranges is small.

int[] scores = randomArray(30);
int a = inRange(scores, 90, 100);
int b = inRange(scores, 80, 90);
int c = inRange(scores, 70, 80);
int d = inRange(scores, 60, 70);
int f = inRange(scores, 0, 60);

19. Which scores does inRange(a, 70, 80) count?

Prediction

Low is included, high is excluded.

if (a[i] >= low && a[i] < high) {
    count++;
}

20. The version that does not scale

Concept

Suppose you wanted to track how many times each individual score appears. With the inRange approach you would have to write 100 lines of code.

int count0 = inRange(scores, 0, 1);
int count1 = inRange(scores, 1, 2);
int count2 = inRange(scores, 2, 3);
// ...
int count99 = inRange(scores, 99, 100);

What we need is a way to store 100 counters, preferably so we can use an index to access them. As Think Java puts it: wait a minute — that is exactly what an array does. This is the same realisation the chapter opened with, about 26 letter counters.

21. Ranges that overlap or leave gaps

Trap

// counting with <= at both ends
if (a[i] >= 80 && a[i] <= 90) countB++;
if (a[i] >= 90 && a[i] <= 100) countA++;

if (a[i] >= low && a[i] < high) {
    count++;
}

22. Which traversal pattern is inRange?

Definition probe

The three shapes from Lesson 7a.

23. How many traversals for 100 counters?

Estimation

Each call to inRange walks the whole array.

24. Why does the check 'counts add to length' work?

Explain it to yourself

A cheap test that catches both kinds of range error.

25. The histogram in one pass

Section

Section 7.7, continued

26. Use the value itself as the index

Concept

The inRange version works but is not as efficient as it could be. For each score, we already know which range it falls in — the score itself. So we can use that value to increment the corresponding counter directly.

int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    int index = scores[i];
    counts[index]++;
}

Each pass selects one element from scores and uses it as an index to increment the corresponding element of counts. Because this traverses the scores array only once, it is much more efficient.

27. A value pointing at its own counter

Picture it

This is the conceptual jump of the chapter. An index has been a position until now; here it is a name, and the value chooses which counter to bump.

It works because the counts array was made with exactly as many elements as there are possible values — new int[100] for scores 0 to 99. The value and the index range line up by construction.

28. Comparing the two versions

Worked example

Both produce the same histogram. The difference is how much work they do, and it is not a small difference.

// version 1: correct, but 100 traversals
int[] counts = new int[100];
for (int i = 0; i < counts.length; i++) {
    counts[i] = inRange(scores, i, i + 1);
}

// version 2: one traversal
int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    counts[scores[i]]++;
}

29. What does counts[62] hold?

Prediction

The single-pass histogram, run on four scores.

int[] scores = {62, 15, 62, 99};
int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    counts[scores[i]]++;
}

30. Using the loop variable three ways

Concept

Version 1 is worth one more look, because it uses the same variable for three different jobs in three consecutive positions.

for (int i = 0; i < counts.length; i++) {
    counts[i] = inRange(scores, i, i + 1);
}

Think Java points this out explicitly: notice that we are using the loop variable i three times. It works because the counter at index i counts exactly the score i — the correspondence between index and value is the whole design. Version 2 exploits that correspondence directly instead of restating it.

31. A value outside the counter array's range

Trap

int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    counts[scores[i]]++;        // what if a score is 100? or -1?
}

int[] counts = new int[100];          // one counter per possible score
for (int score : scores) {
    if (score >= 0 && score < counts.length) {
        counts[score]++;
    } else {
        System.err.println("out of range: " + score);
    }
}

32. Which array does the loop go over?

Discrimination

The two versions loop over different arrays, and that is the whole difference.

33. How does the cost grow?

Scale up

Compare the two versions as the amount of data increases.

Both double — the counter array's size is fixed, so version 1's cost is scores times 100 and version 2's is scores. Version 1 is a hundred times slower at every size, which is a constant factor rather than a different growth rate. Constant factors of 100 still decide whether a program is usable.

34. Where else is a value used as an index?

Real world

This technique — let the data choose the slot — is far more general than histograms.

35. The enhanced for loop

Section

Section 7.8

36. For each value in values

Concept

Since traversing arrays is so common, Java provides an alternative syntax that makes the code more compact. It is called the enhanced for loop, also known as the for each loop.

// the standard form
for (int i = 0; i < values.length; i++) {
    int value = values[i];
    System.out.println(value);
}

// the enhanced form
for (int value : values) {
    System.out.println(value);
}

The single line for (int value : values) replaces the first two lines of the standard form. It hides the details of iterating each index, and focuses on the values themselves.

37. Naming, and what is hidden

Notation

The convention makes the loop read as English, and what the form leaves out is exactly what decides when you can use it.

Enhanced for loops often make the code more readable, especially for accumulating values. The question to ask before using one is simply: do I need the index?

38. Rewriting the histogram

Worked example

Using the enhanced for loop and removing the temporary variable, the histogram code becomes about as short as it can be.

// before
int[] counts = new int[100];
for (int i = 0; i < scores.length; i++) {
    int index = scores[i];
    counts[index]++;
}

// after
int[] counts = new int[100];
for (int score : scores) {
    counts[score]++;
}

39. What is the array after this loop?

Prediction

The loop variable is assigned to.

int[] a = {1, 2, 3};
for (int value : a) {
    value = 0;
}

40. When you cannot use it

Concept

Enhanced for loops are not helpful when you need to refer to the index, as in search operations.

for (double d : array) {
    if (d == target) {
        // array contains d, but we don't know where
    }
}

The first row is the common case, which is why the enhanced form is worth reaching for by default. The remaining four are exactly the situations where the standard form is not merely preferable but necessary.

41. Assigning to the loop variable

Trap

int[] a = {1, 2, 3};
for (int value : a) {
    value = value * 2;        // changes the copy only
}
// a is still {1, 2, 3}

int[] a = {1, 2, 3};
for (int i = 0; i < a.length; i++) {
    a[i] = a[i] * 2;          // writes into the array
}
// a is now {2, 4, 6}

42. Enhanced for, or standard for?

Definition probe

Ask whether you need the index.

43. Write an enhanced for loop

Fill the middle

Sum an int array.

44. Could the enhanced loop have allowed writing?

Counterexample

It is a deliberate design decision. Ask what it prevents.

45. Counting characters

Section

Section 7.9

46. Turning a letter into an index

Concept

Now the problem the chapter opened with. A word is a doubloon if every letter that appears in it appears exactly twice. The plan is an array of 26 counters — and the missing piece is how to get from a letter to an index.

int[] counts = new int[26];
String lower = s.toLowerCase();

for (int i = 0; i < lower.length(); i++) {
    char letter = lower.charAt(i);
    int index = letter - 'a';
    counts[index]++;
}

Java allows you to perform arithmetic on characters. Subtracting 'a' from a lowercase letter gives its position in the alphabet: if letter is 'a' the index is 0, if 'b' then 1, and so on.

47. Why subtracting 'a' works

Picture it

It looks like a trick and it is arithmetic. Lesson 6a's point that a char is a number underneath is what makes it possible.

This works because the lowercase letters are consecutive in Unicode — the same property that let for (char c = 'a'; c <= 'z'; c++) walk the alphabet in Lesson 6a. It is a fact about the encoding, not a general truth about alphabets.

48. The complete doubloon method

Worked example

Two traversals: one to build the histogram, one to check it. Neither is complicated, and together they solve the problem the chapter opened with in a single pass over the word.

public class Doubloon {

    public static boolean isDoubloon(String s) {
        // count the number of times each letter appears
        int[] counts = new int[26];
        String lower = s.toLowerCase();
        for (char letter : lower.toCharArray()) {
            int index = letter - 'a';
            counts[index]++;
        }

        // determine whether the given word is a doubloon
        for (int count : counts) {
            if (count != 0 && count != 2) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isDoubloon("Mama"));    // true
        System.out.println(isDoubloon("Lama"));    // false
    }
}

This example uses methods, if statements, for loops, arithmetic and logical operators, integers, characters, strings, booleans and arrays. It is worth a moment to notice how much that is.

49. What index does 'd' give?

Prediction

Character arithmetic.

char letter = 'd';
int index = letter - 'a';

50. Two early returns, doing different jobs

Concept

The checking loop returns from inside the loop and again after it. Both are deliberate, and the pattern is the same as search in Lesson 7a.

for (int count : counts) {
    if (count != 0 && count != 2) {
        return false;      // one bad count is enough
    }
}
return true;               // every count was fine

The asymmetry is worth naming: to prove false you need one counterexample; to prove true you must check everything. That is why the false case can return early and the true case cannot — and it is the same shape as returning -1 only after a search loop completes.

51. Forgetting to lowercase first

Trap

int[] counts = new int[26];
for (char letter : s.toCharArray()) {    // no toLowerCase
    int index = letter - 'a';
    counts[index]++;
}

String lower = s.toLowerCase();
for (char letter : lower.toCharArray()) {
    int index = letter - 'a';
    counts[index]++;
}

52. Is 'Mama' a doubloon?

Prediction

Lowercase it first, then count.

isDoubloon("Mama")

53. Annotate the doubloon method

Error analysis

Five decisions in fifteen lines, each with a reason.

Nothing here is advanced. What makes it satisfying is that it is the whole chapter — arrays, traversal, using a value as an index, and the enhanced for loop — solving a problem that was impractical at the start of it.

54. What does isDoubloon return for an empty string?

Edge cases

Test the method at its edges.

55. The two histogram versions

Comparison

Same output, very different cost. Fill the blanks.

Both are correct. The second is a hundred times cheaper because it stops asking how many scores equal this? and starts saying this score belongs here.

56. The pattern to carry away

Pattern

Counting anything into buckets is the same four lines, whatever the values are — as long as you can turn a value into an index.

// 1. one counter per possible value
int[] counts = new int[NUMBER_OF_POSSIBLE_VALUES];

// 2. one pass over the data
for (int value : data) {
    counts[value]++;          // the value names its own counter
}

// for letters, map them into range first:
for (char letter : s.toLowerCase().toCharArray()) {
    counts[letter - 'a']++;
}

• nextInt(n) returns 0 to n-1 — the same range as the indexes of an array of length n.
• Half-open ranges tile exactly: include the low end, exclude the high.
• letter - 'a' maps a lowercase letter to 0 through 25.
• Enhanced for to read, standard for to write.

57. Check: nextInt's range

Check

Work it out before you click.

58. Check: the enhanced for loop

Check

Work it out before you click.

int[] a = {5, 10, 15};
int total = 0;
for (int n : a) {
    total += n;
    n = 0;
}

59. Check: character arithmetic

Check

Work it out before you click.

int[] counts = new int[26];
String lower = "bee".toLowerCase();
for (char letter : lower.toCharArray()) {
    counts[letter - 'a']++;
}

60. Counting with an array is everywhere

Real world

The histogram technique — one counter per possible value, one pass over the data — is one of the most reused ideas in programming.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Four sections that finish the chapter and answer the question it opened with: how to count 26 things without declaring 26 variables.

• Programs are deterministic; java.util.Random produces pseudorandom numbers, which are not truly random.
• nextInt(n) returns 0 to n-1 — the same range as the indexes of an array of length n.
• Create one Random object outside the loop, like any other state that must survive across passes.
• A histogram is a set of counters, and half-open ranges keep them from overlapping.
• Use a value as an index to count in one pass instead of one pass per counter.
• The counter array's length must be the number of possible values, or an out-of-range value throws.
• The enhanced for loop reads for each value in values and hides the index — so it cannot search or write.
• letter - 'a' maps a lowercase letter to 0 through 25, because the letters are consecutive in Unicode.