String Manipulation

Almost every program works with text: names, messages, passwords, file names, answers typed by a user. Since Topic 1.3 you have been writing text as string literals and printing it. In Topics 1.12 to 1.14 you learned that String is a class, so text in a Java program is stored as objects. This chapter is about what you can do with those objects. First, though, how does a String object come into existence?

A String object holds a sequence of characters: letters, digits, spaces, punctuation, one after another in a fixed order. "Number 23" is nine characters long: N, u, m, b, e, r, a space, 2, and 3. The digits in it are characters, not a number you can do arithmetic with.

There are two ways to make one:

1. Write a string literal, text inside double quotes. Java creates a String object holding that text.
2. Call the String class’s constructor with new, the same way you created objects in Topic 1.13. Passing a literal, as in new String("Denver"), creates a new String object with the same characters.

public class CreateStrings
{
    public static void main(String[] args)
    {
        String team = "Falcons";
        String city = new String("Denver");
        String jersey = "Number 23";
        System.out.println(team);
        System.out.println(city);
        System.out.println(jersey);
    }
}

Falcons
Denver
Number 23

Now notice something that is not in this program: an import statement. When you used Scanner in Topic 1.4, the program needed import java.util.Scanner; at the top, because Scanner lives in the java.util package (a named group of related classes). String lives in a package called java.lang, and Java makes every class in java.lang available to every program automatically. Java does this because classes like String are needed by nearly every program, so requiring an import for them would just be clutter.

public class MissingQuotes
{
    public static void main(String[] args)
    {
        String team = Falcons;
        System.out.println(team);
    }
}

Suppose a program knows a student’s first name and last name in two separate variables, and it needs to print the full name. Or it needs to build a message like Hello, Ada! from pieces. You need a way to glue strings together.

In plain words: put the second string’s characters right after the first string’s characters, with nothing added and nothing removed. Joining strings end to end is called concatenation. In Java, the + operator concatenates when it is used with a String. The result is a new String object; the two original strings are left exactly as they were.

String first = "Ada";
String last = "Lovelace";
String full = first + " " + last;
System.out.println(full);
System.out.println(first);

Ada Lovelace
Ada

Now vary the tool. Compound assignment from Topic 1.6 works with strings too: greeting += name; means greeting = greeting + name;. It concatenates, creates a new String, and makes the variable refer to that new object. This is handy for building a message one piece at a time:

String name = "Ada";
String greeting = "Hello";
greeting += ", ";
greeting += name;
greeting += "!";
System.out.println(greeting);

Hello, Ada!

Each += made a brand-new String object and moved greeting to it. You will see why that matters in 1.15.7.

String first = "Ada";
String last = "Lovelace";
System.out.println(first + last);

AdaLovelace

String playlist = "Rock";
String genre = "Jazz";
playlist += " and ";
playlist += genre;
genre = "Pop";
System.out.println(playlist);
System.out.println(genre);

Rock and Jazz
Pop

Programs constantly mix text with values: Score: 95, Price: $4.5, Passed: true. The number 95 is an int, not a String. Can + join them?

Yes. When one side of + is a String and the other side is a primitive value (int, double, or boolean), Java first turns the primitive into its text form, then concatenates. The int 95 becomes the characters 9 and 5. Java does this on its own, without you asking, so it is called an implicit conversion.

int score = 95;
double price = 4.5;
boolean passed = true;
System.out.println("Score: " + score);
System.out.println("Price: $" + price);
System.out.println("Passed: " + passed);

Score: 95
Price: $4.5
Passed: true

The tricky part is that + has two jobs. With two numbers it adds; with a String on either side it concatenates. Java decides one + at a time, moving left to right (the same left-to-right rule for equal-precedence operators you learned in Topic 1.3). So the order of the pieces changes the result:

System.out.println("Total: " + 3 + 4);
System.out.println(3 + 4 + " points");
System.out.println("Total: " + (3 + 4));
System.out.println("Half: " + 7 / 2);

Total: 34
7 points
Total: 7
Half: 3

Once the running result is a String, every later + in that chain concatenates. Before that, + between two numbers still adds. Precedence still applies too: *, /, and % happen before any +.

int goals = 2;
int assists = 3;
System.out.println("Points: " + goals + assists);
System.out.println(goals + assists + " points");
System.out.println(1 + 2 + "3" + 4 + 5);

Points: 23
5 points
3345

To work with part of a string, such as its first letter or the text after an @, you need a way to say where in the string you mean. Java numbers the positions.

Each character in a string has a position number called its index (plural: indices). The first character is at index 0, not 1. Then each character, including spaces and punctuation, gets the next number. Think of the index as “how many characters come before this one”: the first character has zero characters before it.

index:      0 1 2 3 4 5
character:  p l a n e t

The length of a string is how many characters it has. You get it by calling the instance method length(), whose header is int length(): it takes no arguments and returns an int. You call it with the dot operator from Topic 1.14, as in word.length(). "planet" has length 6, but its last index is 5, because counting started at 0.

String word = "planet";
String cheer = "Go Bears!";
String empty = "";
System.out.println(word.length());
System.out.println(cheer.length());
System.out.println(empty.length());

6
9
0

index:      0 1 2 3 4 5 6 7 8
character:  G o   B e a r s !

With indices you can describe any part of a string. Now you need a method that hands that part back to you: the first three letters of a word, everything after the @ in an email address, one single letter. A part of a string is called a substring, and the String method that gets one has the same name.

substring comes in two versions. They are on the Java Quick Reference, the sheet of method headers you can look at during the AP exam:

Take the two-parameter version apart:

• from is the index of the first character you want. It is included.
• to is the index where you stop. The character at to is not included; the last character you get is at to - 1.
• So the result has to - from characters.

Why stop just before to? Because then to - from is the length of the result, and substring(0, word.length()) is the whole word without any “minus one.” The one-parameter version is a shortcut: word.substring(from) gives the same result as word.substring(from, word.length()).

index:      0 1 2 3 4 5 6 7 8
character:  s u n f l o w e r

String word = "sunflower";
System.out.println(word.substring(0, 3));
System.out.println(word.substring(3, 6));
System.out.println(word.substring(3));
System.out.println(word.substring(4, 5));

sun
flo
flower
l

Now vary the indices to the edges. What happens when from equals to, or when from is the length?

String word = "sunflower";
System.out.println("[" + word.substring(9) + "]");
System.out.println("[" + word.substring(2, 2) + "]");
System.out.println("[" + word.substring(8) + "]");

[]
[]
[r]

The brackets are concatenated around each result so you can see it. substring(9) starts at index 9, which is just past the last character, so there is nothing to take: the result is the empty string. substring(2, 2) asks for “from 2, stopping before 2,” which is also zero characters. And substring(8) starts at the last index, so it returns the last character, "r". Both empty results are legal; the next subsection shows which indices are not.

String word = "sunflower";
String part = word.substring(3, 6);
System.out.println(part);

flo

String word = "sunflower";
String part = word.substring(3, 7);
System.out.println(part);

flow

String sport = "basketball";
System.out.println(sport.substring(6));
System.out.println(sport.substring(0, 6));
System.out.println(sport.substring(2, 3));
System.out.println(sport.substring(5, 7) + sport.substring(0, 1));

index:      0 1 2 3 4 5 6 7 8 9
character:  b a s k e t b a l l

ball
basket
s
tbb

String day = "Saturday";
String shortName = day.substring(0, 2);
System.out.println(shortName);

String shortName = day.substring(0, 3);

What if the program asks for characters that are not there, such as index 7 of a six-letter word? In Topic 1.1 you saw that some impossible requests are not caught by the compiler but crash the program while it runs. Asking for a missing index is one of them.

The rules, for a string of length n:

• A single character position must be from 0 to n - 1.
• For substring(from, to), both values must be from 0 to n, and from must not be bigger than to. (to may equal n because the character at to is never taken.)
• For substring(from), from must be from 0 to n.

Break a rule and Java throws a StringIndexOutOfBoundsException, a run-time error whose name says exactly what happened: a string index was out of bounds (outside the allowed range). The compiler cannot catch it, because it checks only that you passed int values, not what those values will be when the line runs.

public class BadSubstring
{
    public static void main(String[] args)
    {
        String word = "planet";
        System.out.println("Word: " + word);
        System.out.println(word.substring(0, 7));
        System.out.println("Done");
    }
}

Word: planet
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 6
	at BadSubstring.main(BadSubstring.java:7)

Now vary which rule is broken. Each of these also compiles and then throws the same exception:

String word = "planet";
System.out.println(word.substring(7));

String word = "planet";
System.out.println(word.substring(4, 2));

String word = "planet";
System.out.println(word.substring(-1, 3));

Compare those with calls that sit right at the edge and are fine:

String word = "planet";
System.out.println("[" + word.substring(0, 6) + "]");
System.out.println("[" + word.substring(6) + "]");
System.out.println("[" + word.substring(5, 6) + "]");

[planet]
[]
[t]

substring(0, 6) uses to = 6, the length, which is allowed. substring(6) starts at the length and returns the empty string. substring(5, 6) is the single-character pattern for the last index.

String word = "planet";
System.out.println(word.substring(0, word.length() - 1));
System.out.println(word.substring(0, word.length()));

plane
planet

You have called substring and used += many times now. Here is a question you may not have asked: when you call word.substring(0, 3), does word lose its other letters?

No. A String object can never be changed once it is created. Every method you call on a string leaves that string exactly as it was and returns a new string as its answer. An object that cannot be changed after it is created is immutable. Methods like substring are like asking someone to read you part of a page: you get the words, but the page is not torn.

Why would Java design strings this way? Because several variables can refer to the same String object (Topic 1.13: a reference variable holds the object’s address, and copying the variable copies the address). If one part of a program could change the object, every other variable referring to it would see its text change unexpectedly. Because strings are immutable, sharing them is always safe.

String original = "cat";
String other = original;
original += "s";
System.out.println(original);
System.out.println(other);

cats
cat

Now vary it: call a method but do nothing with what it returns.

String word = "sunflower";
word.substring(0, 3);
System.out.println(word);

sunflower

Line 2 runs. substring builds the new string "sun" and returns it, but nothing stores the result, so it is thrown away. word still refers to the original, unchanged "sunflower".

String word = "sunflower";
word = word.substring(0, 3);
System.out.println(word);

sun

String motto = "Practice daily";
String copy = motto;
motto.substring(9);
copy = copy.substring(0, 8);
System.out.println(motto);
System.out.println(copy);

Practice daily
Practice

substring needs index numbers, but often you do not know them in advance. Where does the username end in an email address? Where is the space in a full name? You need to search for the text and get back where it is.

The method int indexOf(String str) searches the string for str and returns the index where its first occurrence starts. If str is not in the string anywhere, it returns -1. Java uses -1 because it can never be a real index (indices start at 0), so it can only mean “not found.”

index:      0 1 2 3 4 5 6 7 8 9 ...
character:  t h e   c a t   s a ...

String sentence = "the cat sat on the mat";
System.out.println(sentence.indexOf("the"));
System.out.println(sentence.indexOf("at"));
System.out.println(sentence.indexOf("dog"));
System.out.println(sentence.indexOf("The"));

0
5
-1
-1

Now combine indexOf with substring. The @ in an email address separates the user name from the domain, but its position depends on the address. Let indexOf find it:

String email = "ada@school.org";
int at = email.indexOf("@");
String user = email.substring(0, at);
String domain = email.substring(at + 1);
System.out.println(at);
System.out.println(user);
System.out.println(domain);

3
ada
school.org

at is 3. substring(0, at) takes indices 0 to 2, stopping right before the @. substring(at + 1) starts one past the @ and runs to the end. This code works for any address with an @, however long the user name is.

public class NoAtSign
{
    public static void main(String[] args)
    {
        String email = "ada.school.org";
        int at = email.indexOf("@");
        System.out.println(at);
        String user = email.substring(0, at);
        System.out.println(user);
    }
}

-1
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: Range [0, -1) out of bounds for length 14
	at NoAtSign.main(NoAtSign.java:8)

String song = "Here Comes the Sun";
int spot = song.indexOf("the");
System.out.println(spot);
System.out.println(song.substring(spot));
System.out.println(song.indexOf("sun"));

11
the Sun
-1

Programs need to compare text: did the user type the right password? Which of two names comes first alphabetically? Two String methods answer these questions. Both are on the Java Quick Reference.

equals: the same characters?

boolean equals(Object other) returns true if the string has exactly the same sequence of characters as other, and false otherwise. The parameter type is Object, the class every class extends (Topic 1.12), but in this course you will always pass it a String. “Exactly the same” means same length, same characters, same order, same capitalization.

String password = "Tiger42";
System.out.println(password.equals("Tiger42"));
System.out.println(password.equals("tiger42"));
System.out.println(password.equals("Tiger42 "));
System.out.println(password.equals(new String("Tiger42")));

true
false
false
true

compareTo: which comes first?

int compareTo(String other) compares two strings by dictionary (alphabetical) order and returns an int:

Only the sign matters. The method promises negative, zero, or positive; do not try to memorize particular numbers.

System.out.println("apple".compareTo("banana"));
System.out.println("apple".compareTo("cherry"));
System.out.println("banana".compareTo("apple"));
System.out.println("pear".compareTo("pear"));
System.out.println("car".compareTo("cart"));

-1
-2
1
0
-1

One detail of “alphabetical”: Java puts every uppercase letter before every lowercase letter, so "Zoo" comes before "apple":

System.out.println("Zoo".compareTo("apple"));
System.out.println("zoo".compareTo("apple"));

-7
25

With all-lowercase (or all-uppercase) words, Java’s order matches the dictionary.

In 1.15.3 you saw that + turns a number into text. What happens if the thing on the other side of + is an object that is not a String, such as a Scanner? Java still needs text to concatenate, so it needs some way to ask any object for a text version of itself.

Topic 1.12 told you that every class in Java is a subclass of the Object class. Object has a method String toString() that returns a string representing the object. Because every class is a subclass of Object, every object has a toString method. So when you concatenate a String with any object, Java calls that object’s toString method for you and joins the text it returns.

The toString that Object provides is very general. Many classes replace it with their own version that describes their objects better. When a subclass has a public method with the same signature as a public method in its superclass but its own behavior, that is called method overriding. String overrides toString to return the string’s own characters, and Scanner overrides it to return a description of the scanner. (Writing your own toString is not part of this course; you only need to know that Java calls it.)

import java.util.Scanner;

public class ScannerText
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        String note = "Input: " + input;
        String described = input.toString();
        System.out.println(note.substring(0, 24));
        System.out.println(described.substring(0, 17));
        System.out.println(note.indexOf("["));
    }
}

Input: java.util.Scanner
java.util.Scanner
24

Now vary the object. A String made with the constructor is also an object, and its toString returns its own characters:

String city = new String("Denver");
String label = "City: " + city;
System.out.println(label);
System.out.println(city.toString());

City: Denver
Denver

That is why concatenating two strings works the way you expect: the text String’s toString returns is just the string itself.

A school’s sign-up page builds a username from a full name: the first letter of the first name, then the whole last name, then the number of characters in the full name. Here is the code, using indexOf, substring, concatenation, length(), and compareTo:

String fullName = "Grace Hopper";
int space = fullName.indexOf(" ");
String first = fullName.substring(0, space);
String last = fullName.substring(space + 1);
String username = first.substring(0, 1) + last + fullName.length();
System.out.println(username);
System.out.println(first.compareTo(last));
System.out.println(fullName);

Index diagram for "Grace Hopper" (length 12):

index:      0 1 2 3 4 5 6 7 8 9 10 11
character:  G r a c e   H o p p e  r

GHopper12
-1
Grace Hopper

Every method call returned a new value and left fullName alone, which is why line 8 still prints the full name. If the name had no space, indexOf would return -1 and line 3 would throw a StringIndexOutOfBoundsException, as in 1.15.8.

The Watch Out boxes explain each mistake. This table is a quick lookup for every String method in this chapter: what it returns and when it fails.

And for every method: the original string never changes. Store the result if you want to keep it.

• A String is an immutable object holding a sequence of characters. Create one with a literal or the String constructor; String is in java.lang, so no import is needed.
• + and += concatenate into a new String. A primitive on the other side is converted to text; any other object is converted by calling its toString method. Java works left to right, so the order of the pieces matters.
• Characters are numbered by index from 0 to length() - 1.
• substring(from, to) returns indices from to to - 1; substring(from) goes to the end; substring(i, i + 1) is the single character at i. indexOf(str) finds where str first starts, or returns -1.
• An index outside the allowed range throws a StringIndexOutOfBoundsException while the program runs.
• equals tells whether two strings have exactly the same characters; compareTo returns a negative, zero, or positive number to show alphabetical order.

System.out.println("A" + 2 * 3 + 1);

String date = "2026-10-07";
int dash = date.indexOf("-");
String year = date.substring(0, dash);
String rest = date.substring(dash + 1);
String month = rest.substring(0, rest.indexOf("-"));
System.out.println(year);
System.out.println(rest);
System.out.println(month);

index:      0 1 2 3 4 5 6 7 8 9
character:  2 0 2 6 - 1 0 - 0 7

2026
10-07
10

String word = "rocket";
String last = word.substring(word.length(), word.length() + 1);
System.out.println("Last letter: " + last);

String last = word.substring(word.length() - 1, word.length());

String a = "sun";
String b = a;
a = a + "flower";
b.substring(1);
System.out.println(a + " " + b);

public class Login
{
    public static void main(String[] args)
    {
        String entry = "maya.lee@school";
        System.out.println("Checking " + entry);
        int at = entry.indexOf("@");
        System.out.println("Name: " + entry.substring(0, at));
        int dot = entry.indexOf(".org");
        System.out.println("Site: " + entry.substring(at + 1, dot));
        System.out.println("Welcome!");
    }
}

Checking maya.lee@school
Name: maya.lee

String first = "Mario";
String second = "Maria";
System.out.println(first.compareTo(second));
System.out.println(first.substring(0, 4).equals(second.substring(0, 4)));
System.out.println(second.equals("maria"));
System.out.println(second.compareTo(first));

14
true
false
-14

String code = "";
code += 4;
code += 2;
code = 1 + code;
System.out.println(code + 1);
System.out.println(code.length() + 1);

1421
4

import java.util.Scanner;

public class ReaderReport
{
    public static void main(String[] args)
    {
        Scanner reader = new Scanner(System.in);
        String report = "Reader: " + reader;
        System.out.println(report.indexOf("Scanner"));
        System.out.println(report.substring(0, 12));
    }
}

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can create a String with a literal or the constructor, and explain why String needs no import. Reread
• I can predict the result of joining strings with + and +=. Reread
• I can predict when + adds and when it concatenates, working left to right. Reread
• I can find the index of any character and the length of a string. Reread
• I can predict the result of substring with one or two arguments, including single characters. Reread
• I can tell which substring calls throw a StringIndexOutOfBoundsException. Reread
• I can explain why calling a method on a String never changes it. Reread
• I can predict what indexOf returns, including -1. Reread
• I can predict the result of equals and the sign of compareTo. Reread
• I can explain what happens when a String is concatenated with any object. Reread