The String Toolkit: Iteration, indexOf, and substring

1. The String Toolkit: Iteration, indexOf, and substring

Title

Think Java 2e · Chapter 6 · Loops and Strings

Sections 6.7-6.11 · pp. 98-103

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 6 (Loops and Strings), Sections 6.7-6.11, pp. 98-103. Everything on these slides can be checked against those pages.

1. Iterate over the characters of a string with a for loop and length().

2. Explain why the last character is at index length() - 1, and name the exception you get otherwise.

3. Use indexOf to search for a character or a substring, and interpret a return value of -1.

4. Use substring with one or two arguments, and say which index is excluded.

5. Compare strings with equals and compareTo, and say why == gives the wrong answer.

6. Use String.format to build a formatted string without displaying it.

• 6.7 — String Iteration
• 6.8 — The indexOf Method
• 6.9 — Substrings
• 6.10 — String Comparison
• 6.11 — String Formatting

3. Retrieve before you read

Warm-up

One picture from the previous lesson decides everything in this one.

4. Four things you do to a string

Concept

Some of the most interesting problems in computer science involve searching and manipulating text. Although the examples here are short, the techniques work the same whether you have one word or one million.

• 6.7 — iterate: visit every character in turn
• 6.8 — search: indexOf finds where something is
• 6.9 — extract: substring copies part of it out
• 6.10 — compare: equals and compareTo, never ==
• 6.11 — build: String.format makes formatted text without printing it

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 6 (Loops and Strings), Sections 6.7-6.11, pp. 98-103 — Sections 6.7-6.11, printed pages 98-103.

5. Iterating over a string

Section

Section 6.7

6. length() and charAt() together

Concept

Strings provide a method called length that returns the number of characters. Combined with charAt and a for loop, that lets you visit every character in turn.

String fruit = "banana";
for (int i = 0; i < fruit.length(); i++) {
    char letter = fruit.charAt(i);
    System.out.println(letter);
}

Because length is a method, you have to invoke it with parentheses — there are no arguments, but the parentheses are still required. When i is equal to the length, the condition becomes false and the loop terminates.

7. Why the condition uses < and not <=

Notation

This is the single most important line in the lesson, and the reason is entirely about where the numbering starts.

Learn i < s.length() as a single unit. Almost every string loop you write for the rest of the book begins with it, and the version with <= is a bug every time.

8. Finding the last character

Worked example

The natural first attempt compiles, runs, and throws. Working out why is the whole point of the index ruler.

int length = fruit.length();
char last = fruit.charAt(length);        // wrong!

char last = fruit.charAt(length - 1);    // correct

9. What does charAt(length()) do?

Prediction

fruit holds "banana".

int len = fruit.length();
char c = fruit.charAt(len);

10. Reading one string and building another

Concept

Many string algorithms involve reading one string and building another. To reverse a string, concatenate one character at a time — iterating the indexes in reverse order.

public static String reverse(String s) {
    String r = "";
    for (int i = s.length() - 1; i >= 0; i--) {
        r += s.charAt(i);
    }
    return r;
}

empty string — The string "", which contains no characters and has a length of zero.

The initial value of r is "", the empty string. Each pass the += operator appends the next character, and when the loop exits r contains the characters of s in reverse order — so reverse("banana") is "ananab".

11. Looping to length instead of length - 1

Trap

for (int i = 0; i <= fruit.length(); i++) {
    System.out.println(fruit.charAt(i));
}

for (int i = 0; i < fruit.length(); i++) {
    System.out.println(fruit.charAt(i));
}

12. Iterate over every character

Fill the middle

Print each character of s on its own line.

13. What does reverse return?

Prediction

Trace the loop backwards.

public static String reverse(String s) {
    String r = "";
    for (int i = s.length() - 1; i >= 0; i--) {
        r += s.charAt(i);
    }
    return r;
}

14. Why does length need parentheses?

Socratic

It takes no arguments, so the parentheses look redundant.

15. The indexOf method

Section

Section 6.8

16. Search for a character and get its index

Concept

To search for a specific character you could write a for loop using charAt. But the String class already provides a method for exactly that.

String fruit = "banana";
int index = fruit.indexOf('a');        // returns 1
int index2 = fruit.indexOf('a', 2);    // returns 3
int missing = fruit.indexOf('z');      // returns -1
int word = fruit.indexOf("nan");       // returns 2

The letter 'a' appears three times, so it is not obvious what indexOf should do. According to the documentation, it returns the index of the first appearance.

17. Searching from a starting index

Picture it

A second argument says where in the string to start looking. Drawing it makes the answer obvious.

If the character happens to appear at the starting index, that index is the answer — so fruit.indexOf('a', 5) returns 5 rather than skipping past it.

18. Finding every occurrence

Worked example

The two-argument form exists so you can keep searching. Use it in a loop to find all three 'a's.

String fruit = "banana";
int index = fruit.indexOf('a');
while (index != -1) {
    System.out.println("found at " + index);
    index = fruit.indexOf('a', index + 1);
}

19. What does this return?

Prediction

fruit is "banana".

fruit.indexOf('n', 3)

20. Why -1 means not found

Concept

A method that returns an index has to be able to say there is no index. Returning -1 is a convention, and it works because of a fact about indexes.

Since indexes cannot be negative, this value indicates the character was not found. The convention depends on that: -1 can never be confused with a real answer. It also means you must always check for it — using an unchecked indexOf result as an index is how a search failure turns into an exception.

21. Using an indexOf result without checking it

Trap

String fruit = "banana";
int i = fruit.indexOf('z');      // -1
char c = fruit.charAt(i);        // charAt(-1)

int i = fruit.indexOf('z');
if (i != -1) {
    char c = fruit.charAt(i);
    System.out.println("found " + c + " at " + i);
} else {
    System.out.println("not found");
}

22. What does indexOf return when it fails?

Prediction

The character is not in the string.

"banana".indexOf('z')

23. Match each call to its result

Matching

All on the string "banana".

24. What would happen without the + 1?

Edge cases

The find-all loop searches from index + 1. Remove it.

25. Substrings

Section

Section 6.9

26. Copy part of a string out

Concept

In addition to searching strings, we often need to extract parts of them. The substring method returns a new string copying letters from an existing one, given a pair of indexes.

String fruit = "banana";
fruit.substring(0, 3)    // "ban"
fruit.substring(2, 5)    // "nan"
fruit.substring(6, 6)    // ""

The character indicated by the second index is not included. That looks arbitrary and is not: defining substring this way simplifies some common operations.

27. Where the two indexes point

Picture it

Think of the indexes as pointing at the gaps between characters rather than at the characters themselves. Then the exclusive end stops being strange.

The useful consequence: the length of the result is second index minus first. So to select a substring of length len starting at index i, you write fruit.substring(i, i + len) — which is why excluding the end is convenient rather than awkward.

28. The one-argument form

Worked example

Like most string methods, substring is overloaded — there are other versions with different parameters. Invoked with one argument it returns everything from that index to the end.

fruit.substring(0)    // "banana"
fruit.substring(2)    // "nana"
fruit.substring(6)    // ""

29. What does this return?

Prediction

fruit is "banana".

fruit.substring(1, 4)

30. substring never changes the original

Concept

It returns a new string that copies letters from the existing one. The original is untouched — which is a property of every String method you will meet.

String fruit = "banana";
String part = fruit.substring(0, 3);
System.out.println(part);    // ban
System.out.println(fruit);   // banana - unchanged

This matters more than it looks. fruit.substring(0, 3); on a line by itself does nothing useful — the new string is created and immediately discarded, exactly like the ignored return value in Lesson 4b. Chapter 9 gives this behaviour its proper name: Strings are immutable.

31. Expecting the end index to be included

Trap

String fruit = "banana";
// wanting the first three letters, "ban":
String first = fruit.substring(0, 2);   // "ba" - too short

fruit.substring(0, 3)        // "ban" - 3 characters
fruit.substring(2, 5)        // "nan" - 3 characters
fruit.substring(i, i + len)  // len characters, starting at i

32. Take the first three characters

Fill the middle

Get "ban" from "banana".

33. How many characters does each return?

Definition probe

The length is always the second index minus the first.

34. Why exclude the end index?

Explain it to yourself

It looks like a design mistake until you use it.

35. Comparing strings

Section

Section 6.10

36. == almost never works on strings

Concept

When comparing strings it is tempting to use == and !=. But that will almost never work. The following code compiles and runs, and always displays Goodbye! regardless of what the user types.

System.out.print("Play again? ");
String answer = in.nextLine();
if (answer == "yes") {          // wrong!
    System.out.println("Let's go!");
} else {
    System.out.println("Goodbye!");
}

The problem is that == checks whether the two operands refer to the same object. Even if the answer is "yes", it refers to a different object in memory than the literal "yes" in your code. Chapter 7 explains objects and references properly.

37. Same characters, different objects

Picture it

Two strings can hold identical characters and still be two separate things in memory. == asks about the things; equals asks about the characters.

The correct way to compare strings is with the equals method: answer.equals("yes"). It returns true if the strings contain the same characters, and false otherwise.

38. compareTo, and what its number means

Worked example

If two strings differ, compareTo says which comes first in alphabetical order — and the number it returns is more informative than a simple yes or no.

String name1 = "Alan Turing";
String name2 = "Ada Lovelace";
int diff = name1.compareTo(name2);
if (diff < 0) {
    System.out.println("name1 comes before name2.");
} else if (diff > 0) {
    System.out.println("name2 comes before name1.");
} else {
    System.out.println("The names are the same.");
}

39. What does this print?

Prediction

The user types exactly yes.

String answer = in.nextLine();
if (answer == "yes") {
    System.out.println("Let's go!");
} else {
    System.out.println("Goodbye!");
}

40. Why == compiles at all

Concept

If == is almost never right for strings, it would be helpful if the compiler rejected it. It cannot, and the reason is worth knowing.

For primitive types — int, char, double, boolean — == compares values and is exactly right. For objects it compares identity, and a String is an object. The comparison is legal in both cases, which is why the compiler cannot help and why the rule has to be learned.

41. Comparing user input with ==

Trap

String answer = in.nextLine();
if (answer == "yes") {
    System.out.println("Let's go!");
}

String answer = in.nextLine();
if (answer.equals("yes")) {
    System.out.println("Let's go!");
}

42. What does compareTo return?

Prediction

The sign is what matters.

"apple".compareTo("banana")

43. == or equals?

Discrimination

== compares values for primitives and identity for objects.

44. Is == on strings ever true?

Counterexample

'Almost never work' is a careful phrase. Find the exception.

45. String formatting

Section

Section 6.11

46. Build a formatted string without printing it

Concept

Section 3.5 showed how to display formatted output with printf. Sometimes a program needs to create strings formatted a certain way without displaying them immediately, or ever.

public static String timeString(int hour, int minute) {
    String ampm;
    if (hour < 12) {
        ampm = "AM";
        if (hour == 0) {
            hour = 12;              // midnight
        }
    } else {
        ampm = "PM";
        hour = hour - 12;
    }
    return String.format("%02d:%02d %s", hour, minute, ampm);
}

String.format takes exactly the same arguments as System.out.printf — a format string followed by a sequence of values. The only difference is what happens to the result.

47. Reading timeString

Notation

This method uses almost everything from the last three chapters. Worth going through slowly.

Notice how much of the book is in this one method: a conditional chain, a nested if, a modified parameter, a return value, and a format string.

48. printf or String.format

Worked example

The two do the same formatting. Choosing between them is a decision about who decides what happens to the text.

// prints immediately, returns nothing
System.out.printf("%02d:%02d %s%n", hour, minute, ampm);

// returns the text, prints nothing
String t = String.format("%02d:%02d %s", hour, minute, ampm);
System.out.println(t);          // the CALLER decides

49. What does timeString(19, 5) return?

Prediction

Trace the branches.

public static String timeString(int hour, int minute) {
    String ampm;
    if (hour < 12) {
        ampm = "AM";
        if (hour == 0) {
            hour = 12;              // midnight
        }
    } else {
        ampm = "PM";
        hour = hour - 12;
    }
    return String.format("%02d:%02d %s", hour, minute, ampm);
}

50. Read the documentation before reinventing

Concept

Think Java closes the chapter with advice worth taking literally: be sure to skim through the documentation for String. Knowing what other methods are there will help you avoid reinventing the wheel.

Every one of these could be written by hand with charAt and a loop — and the first section of this lesson did exactly that for searching, before revealing indexOf. Writing it once yourself is how you understand it; using the library version is how you write correct code afterwards.

51. Using printf where a String was needed

Trap

public static void timeString(int hour, int minute) {
    System.out.printf("%02d:%02d%n", hour, minute);
}

// the caller cannot do anything else with it:
// String t = timeString(19, 5);     <- there is nothing to assign

public static String timeString(int hour, int minute) {
    ...
    return String.format("%02d:%02d %s", hour, minute, ampm);
}

// now the caller has choices:
System.out.println(timeString(19, 5));
String header = "Departs at " + timeString(19, 5);

52. What does timeString(0, 30) return?

Prediction

The midnight special case.

if (hour < 12) {
    ampm = "AM";
    if (hour == 0) {
        hour = 12;              // midnight
    }
}

53. printf or String.format?

Discrimination

One displays; the other returns.

54. Which of these have you now written by hand?

Real world

This lesson wrote a search loop and then revealed indexOf, and wrote a reverse method the library does not have.

55. The String methods from this lesson

Comparison

Fill the blanks. Every one of these takes or returns an index or a string.

Four of the five involve an index, and three of the five have an off-by-one waiting in them. Drawing the ruler is not a beginner's crutch — it is the fastest way to get these right.

56. The pattern to carry away

Pattern

Nearly every string operation is one of three loops or one library call. Learn the loops, then use the calls.

// visit every character
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
}

// visit them backwards
for (int i = s.length() - 1; i >= 0; i--) {
    char c = s.charAt(i);
}

// build a new string as you go
String result = "";
for (int i = 0; i < s.length(); i++) {
    result += s.charAt(i);
}

• i < s.length() — learn it as one unit.
• A String is an object, so compare with equals, never ==.
• Every String method returns a new string; the original never changes.
• String.format is printf that returns instead of printing.

57. Check: the last character

Check

Work it out before you click.

String s = "hello";
char c = s.charAt(s.length() - 1);

58. Check: substring

Check

Work it out before you click.

String s = "programming";
String part = s.substring(3, 7);

59. Check: comparing strings

Check

Work it out before you click.

String a = in.nextLine();     // the user types: yes
if (a == "yes") {
    System.out.println("A");
} else if (a.equals("yes")) {
    System.out.println("B");
} else {
    System.out.println("C");
}

60. Off-by-one, the most famous bug class there is

Real world

This lesson has three separate off-by-one hazards in it: the loop condition, the last index, and substring's exclusive end.

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, drawing as you go.

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

Five sections that turn a string from something you print into something you can search, take apart and rebuild.

• length() is a method and needs parentheses; indexes run from 0 to length() - 1.
• for (int i = 0; i < s.length(); i++) visits every character exactly once.
• charAt(s.length()) throws StringIndexOutOfBoundsException — subtract one for the last character.
• indexOf returns the first occurrence, or -1 when there is none; a second argument says where to start.
• substring excludes its end index, so the result's length is end minus start.
• Methods are overloaded: substring with one argument runs to the end of the string.
• Compare strings with equals, never == — == asks whether they are the same object.
• compareTo gives the sign of the alphabetical difference, and both methods are case-sensitive.
• String.format is printf that returns the text instead of displaying it.