AP Computer Science: String Manipulation

Text is everywhere in software, from user inputs and file contents to data streams and configuration settings. Mastering string manipulation—the process of accessing, modifying, and analyzing sequences of characters—is a cornerstone of programming. In Java, this involves understanding the unique properties of the String class and knowing when to use the more flexible StringBuilder. This skill is directly tested on the AP exam through questions that require you to traverse, dissect, and reconstruct text data.

Understanding String Immutability and Object Creation

Before diving into methods, you must grasp a fundamental concept: string immutability. In Java, a String object, once created, cannot be changed. When you see an operation like myString.concat("!"), it does not modify the original myString. Instead, it creates and returns a brand new String object. Consider this code:

String word = "Hello";
word.toUpperCase();
System.out.println(word); // Prints "Hello", not "HELLO"

The toUpperCase() method returned a new string ("HELLO"), but we didn't assign it to a variable. The original word remains unchanged. This immutability is why operations that seem to modify a string, like repeated concatenation in a loop, are inefficient. Each concatenation creates a new object, consuming time and memory. This leads directly to the need for StringBuilder, which we'll explore later.

Core String Methods: Inspection and Extraction

The String class provides a toolkit for examining and extracting parts of text. These methods are your first line of inquiry for any string problem.

• length(): Returns an int representing the number of characters. Remember, indices run from 0 to length() - 1.
• charAt(int index): Returns the char at the specified index. A primary tool for processing strings character by character, often using a for loop: for (int i = 0; i < str.length(); i++) { char c = str.charAt(i); }.
• substring(int start, int end): Crucial for extraction. It returns a new string from index start up to, but not including, index end. A one-parameter version substring(int start) goes from start to the end. Remember: "start is inclusive, end is exclusive."
• indexOf(String str): Returns the int index of the first occurrence of the substring str. Returns -1 if not found. The related lastIndexOf finds the last occurrence.
• equals(String other): This is how you must compare string content. Using == compares object references (memory addresses), not content, and will often give incorrect results. "hello".equals(myString) is the safe pattern.
• compareTo(String other): Used for lexicographic (dictionary) ordering. It returns an int: 0 if equal, a negative number if the calling string comes before other, and a positive number if it comes after.

These methods are often combined. For example, to find the first word in a sentence up to a space: sentence.substring(0, sentence.indexOf(" ")).

Building and Modifying Strings: Concatenation and StringBuilder

You can build strings using the + operator or the concat method. This is fine for one-off operations: String name = "Ms." + " " + "Smith";. However, due to immutability, avoid + or concat inside loops. This is inefficient:

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "a"; // Creates 1000 new String objects!
}

The solution is the StringBuilder class, which represents a mutable sequence of characters. You can change its content without creating new objects.

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("a"); // Modifies the same StringBuilder object
}
String finalResult = sb.toString(); // Convert to String when done

Key StringBuilder methods include append(), insert(int pos, ...), delete(int start, int end), and reverse(). For any AP problem involving building or modifying a string through iteration, StringBuilder is almost certainly the correct and efficient choice.

Applied Text Processing Strategies

AP exam questions integrate these tools into larger text processing problems. A common pattern is traversing a string to identify, count, or transform specific character sequences.

Example Problem: Write a method that returns a new string where every instance of a given target substring is replaced by a replacement substring.

public static String replaceSubstring(String original, String target, String replacement) {
    StringBuilder result = new StringBuilder();
    int i = 0;
    while (i < original.length()) {
        int foundIndex = original.indexOf(target, i); // Search starting at i
        if (foundIndex == -1) { // No more found
            result.append(original.substring(i));
            break;
        }
        // Append the part before the target
        result.append(original.substring(i, foundIndex));
        // Append the replacement
        result.append(replacement);
        // Move index past the target we just replaced
        i = foundIndex + target.length();
    }
    return result.toString();
}

This solution showcases critical skills: using indexOf with a starting index for iteration, managing indices for substring, and using StringBuilder for efficient assembly of the final result.

Common Pitfalls

1. Using == Instead of equals for Comparison: This is perhaps the most frequent trap. == checks if two references point to the exact same object in memory. Two separate String objects with identical content are not the same object. Always use .equals() for content comparison.

1. Off-by-One Errors with substring and charAt: Remember that string indices start at 0. The last character is at str.length() - 1. The substring(start, end) method does not include the character at the end index. Accessing str.charAt(str.length()) will throw a StringIndexOutOfBoundsException.

1. Inefficient String Building in Loops: As discussed, repeatedly using += or concat inside a loop creates many intermediate String objects, slowing down your program. The AP exam expects you to recognize this inefficiency and know that StringBuilder is the proper tool.

1. Forgetting String Immutability: Assuming a method like toUpperCase() or trim() changes the original string will lead to logic errors. These methods return a new string; you must assign the result to a variable to use it: String caps = word.toUpperCase();.

Summary

• Strings are immutable in Java; operations that seem to modify them actually create new objects, making repeated concatenation in loops inefficient.
• Core inspection methods like length(), charAt(), substring(), and indexOf() allow you to traverse and extract portions of text data.
• Always compare string content using the .equals() method, not the == operator.
• Use StringBuilder for building or modifying strings within loops or when multiple changes are required, converting to a String with .toString() at the end.
• Complex text processing problems on the AP exam are solved by combining these tools—often using a loop with indexOf to find patterns and a StringBuilder to construct the output.