1.15 String Methods

TLDR

String manipulation in AP Computer Science A means creating String objects and using built-in methods like length, substring, indexOf, equals, and compareTo to work with text. The big idea is that Strings are immutable, so methods return new String objects instead of changing the original. You combine Strings with the + and += operators, and indices run from 0 to length() - 1.

Why This Matters for the AP Computer Science A Exam

String work shows up across the exam. In multiple-choice questions, you trace concatenation, predict what substring returns, and figure out the result of indexOf and equals. In free-response code writing, the first question focuses on methods and control structures, and that question type can require you to call String methods inside an algorithm. The String methods tested here are listed in the Java Quick Reference, so practice using that resource the way you will on exam day. Getting comfortable with zero-based indexing, exclusive end indices, and immutability now prevents avoidable mistakes later.

Key Takeaways

• Create Strings with a literal like "Alice" or with the String constructor; literals are the normal choice, and String is available by default from java.lang.
• Strings are immutable, so capture the return value of any String method if you want to use the result.
• Concatenation with + or += builds a new String, and a primitive joined to a String is converted to a String automatically.
• Valid indices run from 0 to length() - 1; going outside that range throws a StringIndexOutOfBoundsException.
• substring(from, to) includes from but excludes to, so the result has to - from characters.
• Use equals to compare String contents and compareTo to order Strings alphabetically; never use == to compare contents.

Creating String Objects

A String object holds a sequence of characters. You can create one with a string literal:

</>Java
String name = "Alice";

You can also call the String constructor:

</>Java
String name = new String("Alice");

The literal form is the normal choice and reads more cleanly. The String class is part of java.lang, so it is available by default with no import. Strings are so common in programming that you will use them in nearly every program.

String Concatenation

The + operator with Strings joins them together. Writing "Hello" + "World" produces a new String "HelloWorld". This is called concatenation.

When you concatenate a primitive value with a String, Java converts the primitive to a String automatically. So "Score: " + 95 produces "Score: 95". Concatenating any object with a String implicitly calls that object's toString method to get its String form.

The += operator appends to an existing String variable:

</>Java
String message = "Hello";
message += " there"; // message now refers to "Hello there"

Because Strings are immutable, += does not change the original String object. It creates a new String and reassigns the variable.

Understanding String Indices

Every character in a String has an index, starting at 0. In "Hello", 'H' is at index 0 and 'o' is at index 4. The last character is always at index length() - 1.

This zero-based indexing matches how arrays work. If you access an index that is negative or greater than or equal to the length, you get a StringIndexOutOfBoundsException, which is a run-time error.

Essential String Methods

These methods are part of the Java Quick Reference you will have on the exam.

int length() returns the number of characters in the String. An empty String "" has length 0.

String substring(int from, int to) returns the substring beginning at index from and ending at index to - 1. The character at to is not included, so "Hello".substring(1, 4) returns "ell" (indices 1, 2, and 3).

String substring(int from) returns the substring from from to the end of the String. It is the same as substring(from, length()).

int indexOf(String str) returns the index of the first occurrence of str, or -1 if str is not found. The -1 return value is the standard way to check whether something exists in a String.

boolean equals(Object other) returns true if the two Strings have the same sequence of characters and false otherwise. This is the correct way to compare String contents.

int compareTo(String other) returns a value less than 0 if this String comes before other, zero if they are equal, and a value greater than 0 if this String comes after other. Strings are ordered based on the alphabet.

A single-character String at a given index can be created with substring(index, index + 1).

Working with Immutability

Immutability means a String object never changes after it is created. When you call a method on a String, you get a new String back; the original is untouched.

This makes Strings safe to pass around and share, since no method can alter them. The practical rule: always capture the return value if you want the result.

</>Java
String text = "alice";
text.substring(0, 1); // result is discarded, text is unchanged
String first = text.substring(0, 1); // captures "a"

Code Examples

String creation and basic methods:

</>Java
public class StringBasics {
    public static void main(String[] args) {
        // Create strings using literals (most common)
        String greeting = "Hello World";
        String empty = "";  // Valid empty string

        // Using length() method
        System.out.println(greeting.length());  // 11
        System.out.println(empty.length());     // 0

        // Concatenation examples
        String firstName = "Alice";
        String lastName = "Smith";
        String fullName = firstName + " " + lastName;  // "Alice Smith"

        // Concatenation with a primitive value
        int score = 95;
        String result = "Your score: " + score + "%";  // "Your score: 95%"

        // Using += operator
        String message = "Hello";
        message += " there";  // Creates new string "Hello there"
        System.out.println(message);
    }
}

Using substring to extract parts of strings:

</>Java
public class SubstringDemo {
    public static void main(String[] args) {
        String email = "student@school.edu";

        // Find username before the @ symbol
        int atIndex = email.indexOf("@");
        String username = email.substring(0, atIndex);  // "student"

        // Extract domain after the @ symbol
        String domain = email.substring(atIndex + 1);   // "school.edu"

        // Extract file extension
        String filename = "document.pdf";
        int dotIndex = filename.indexOf(".");
        String extension = filename.substring(dotIndex + 1);  // "pdf"

        // Working with fixed positions
        String phoneNumber = "123-456-7890";
        String areaCode = phoneNumber.substring(0, 3);   // "123"
        String exchange = phoneNumber.substring(4, 7);   // "456"
        String number = phoneNumber.substring(8);        // "7890"
    }
}

Searching and comparison:

</>Java
public class StringSearching {
    public static void main(String[] args) {
        String sentence = "The quick brown fox jumps over the lazy dog";

        // Using indexOf to search
        int foxIndex = sentence.indexOf("fox");         // 16
        int catIndex = sentence.indexOf("cat");         // -1 (not found)

        // Check if substring exists
        if (sentence.indexOf("quick") != -1) {
            System.out.println("Found 'quick' in the sentence");
        }

        // String equality - the right way
        String password = "secret123";
        String userInput = "secret123";

        if (password.equals(userInput)) {  // Correct way to compare contents
            System.out.println("Password correct");
        }

        // Using compareTo for ordering
        String word1 = "apple";
        String word2 = "banana";

        int comparison = word1.compareTo(word2);  // Negative value
        if (comparison < 0) {
            System.out.println(word1 + " comes before " + word2);
        }
    }
}

A common manipulation pattern using only Quick Reference methods:

</>Java
public class StringManipulation {
    // Get the single character at a position as a String
    public static String getSingleCharAt(String str, int index) {
        return str.substring(index, index + 1);
    }

    // Find the first space and split a name into two parts
    public static String swapNameOrder(String fullName) {
        int spaceIndex = fullName.indexOf(" ");
        if (spaceIndex == -1) {
            return fullName; // no space, return as is
        }
        String first = fullName.substring(0, spaceIndex);
        String last = fullName.substring(spaceIndex + 1);
        return last + ", " + first;
    }
}

Note on finding more than one occurrence: the single-argument indexOf(String) always searches from the start, so to find a later occurrence you search a substring of the original and adjust the returned index. For example, after finding the first space, search fullName.substring(spaceIndex + 1) and add spaceIndex + 1 to the result to get the next space's real index.

Common Errors and Debugging

StringIndexOutOfBoundsException

This run-time error occurs when you access a position that does not exist in the String.

</>Java
String text = "Hello";
String sub = text.substring(2, 10);  // Error! 10 is beyond the string length

Common causes:

• Off-by-one errors (forgetting indices start at 0)
• Not checking the String length before accessing
• Calling substring with an end index greater than length()

Prevention:

</>Java
// Validate both indices before calling substring
if (start >= 0 && end <= text.length() && start <= end) {
    String sub = text.substring(start, end);
}

Using == Instead of equals()

The == operator checks whether two references point to the same object, not whether they hold the same characters. Use equals for content.

</>Java
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1 == s2);      // false - different objects

System.out.println(s1.equals(s2)); // true - same content

Rule: use .equals() to compare String contents. Only use == when you specifically need to check whether two variables reference the exact same object.

Forgetting String Immutability

Calling a method without storing the result does nothing useful, because the original String cannot change.

</>Java
String name = "alice";
name.substring(0, 1); // result discarded, name is unchanged
System.out.println(name);  // still prints "alice"

// Correct approach: store the result
String firstLetter = name.substring(0, 1);

Think of String methods as producing new Strings based on the original, not as tools that change the existing String.

Off-By-One Errors with substring

The end index of substring is exclusive.

</>Java
String text = "Hello";
// Want characters at positions 1, 2, 3
String sub = text.substring(1, 4);  // CORRECT - gets positions 1, 2, 3

Remember: substring(from, to) includes from but excludes to. The number of characters extracted is always to - from.

Practice Problems

Problem 1: Email Parser

Write a method that extracts the username and domain from an email address and returns them in the format "Username: [username], Domain: [domain]".

</>Java
public static String parseEmail(String email) {
    // Handle missing @ symbol
    if (email.indexOf("@") == -1) {
        return "Invalid email";
    }

    int atIndex = email.indexOf("@");
    String username = email.substring(0, atIndex);
    String domain = email.substring(atIndex + 1);

    return "Username: " + username + ", Domain: " + domain;
}

// Test cases:
System.out.println(parseEmail("john.doe@example.com"));
// Output: "Username: john.doe, Domain: example.com"

System.out.println(parseEmail("student123@school.edu"));
// Output: "Username: student123, Domain: school.edu"

Problem 2: Password Length and Digit Check

Create a method that checks whether a password is at least 8 characters long and contains at least one digit. You can test each character by pulling it out as a single-character substring and comparing it to "0" and "9".

</>Java
public static boolean isValidPassword(String password) {
    if (password.length() < 8) {
        return false;
    }

    for (int i = 0; i < password.length(); i++) {
        String ch = password.substring(i, i + 1);
        if (ch.compareTo("0") >= 0 && ch.compareTo("9") <= 0) {
            return true;  // Found a digit
        }
    }
    return false;  // No digits found
}

Problem 3: Swap First and Last Name

Write a method that takes a name like "john doe" and returns "doe, john". Assume there is exactly one space.

</>Java
public static String swapName(String fullName) {
    int spaceIndex = fullName.indexOf(" ");
    if (spaceIndex == -1) {
        return fullName; // no space found
    }
    String first = fullName.substring(0, spaceIndex);
    String last = fullName.substring(spaceIndex + 1);
    return last + ", " + first;
}

// Test:
System.out.println(swapName("john doe"));   // "doe, john"
System.out.println(swapName("mary smith")); // "smith, mary"

How to Use This on the AP Computer Science A Exam

MCQ

String questions are common in multiple choice. Expect to trace concatenation, predict what substring returns, and figure out what indexOf gives back. Pay close attention to boundary cases: empty Strings, a not-found result of -1, and index calculations. Questions often test immutability by calling a method without storing its result, then asking what the original String contains. The answer is that it is unchanged.

Free Response

Free-response code-writing tasks can require calling String methods inside an algorithm. These problems often combine String methods with loops and conditionals, such as walking through a String one character at a time using substring(i, i + 1), or repeatedly using indexOf to find occurrences. Keep the Java Quick Reference method names and behavior fresh so you call them correctly.

Code Tracing

When tracing, write out the index of each character before you predict a substring result, and remember the end index is excluded. Track every reassignment, since immutability means the value only changes when you assign a method's return value back to a variable.

Common Trap

The biggest trap is assuming a String method changes the original String. It never does. If you call text.substring(0, 3) and do not assign the result, text keeps its old value. A second frequent trap is using == to compare String contents; that compares references, not characters, so use equals for content. Finally, watch the exclusive end index in substring(from, to): the character at to is not part of the result, and the length of the result is always to - from.

Common Misconceptions

• "String methods change the String." They do not. Strings are immutable, so methods return a new String and leave the original unchanged. Always store the return value.
• "== compares String contents." It compares whether two references point to the same object. Use equals to compare the actual characters.
• "substring(from, to) includes the character at to." It does not. The result ends at index to - 1, so it contains to - from characters.
• "indexOf returns 0 when the text is missing." It returns -1 when the search String is not found. A return of 0 means the match starts at the very first index.
• "Indices start at 1." String indices start at 0 and end at length() - 1. Accessing outside that range throws a StringIndexOutOfBoundsException.
• "You can use indexOf with a starting position to skip ahead." The version of indexOf covered here searches from the start of the String. To find a later occurrence, search a substring and adjust the returned index.

Related AP Computer Science A Guides

• 1.4 Assignment Statements and Input
• 1.14 Calling a Void Method
• 1.6 Compound Assignment Operators
• 1.9 Calling a Void Method With Parameters
• 1.1 Why Programming? Why Java?
• 1.11 Using the Math Class