Java String Methods

What is a String method?

A method is an action you ask the String to perform. You write the String, a dot, the method name, and any extra info inside the brackets.

String result = someString.methodName(arguments);

One rule ties this whole lesson together: a String in Java is immutable. Once created, its text can never change.

• Methods like toUpperCase() or replace() do not edit the String in place.
• They return a new String. You must catch that returned value.
• Ignore the return value and your text looks unchanged, and you wonder why.

Think of a photocopier: you feed in a page, ask for an uppercase copy, and out comes a fresh page. The original is untouched.

Length and reading single characters

Two basic questions: how long is it, and what character sits at a spot?

• length() gives the character count.
• charAt(index) reads one character.
• Positions start at 0, not 1, just like arrays.

This example asks “Java” for its size and for two of its characters.

String name = "Java";

System.out.println(name.length());     // how many characters
System.out.println(name.charAt(0));    // first character
System.out.println(name.charAt(3));    // fourth character

Walking through it:

• length() returns 4, because “Java” is four characters long.
• charAt(0) reads index 0, the first character, 'J'.
• charAt(3) reads index 3, the fourth character, 'a'.
• The last valid index is length() - 1, so charAt(4) throws an error.

4
J
a

Changing the case

Turn text into all capitals or all small letters.

• toUpperCase() returns an all-caps copy.
• toLowerCase() returns an all-small copy.
• Both return a new String; the original cannot change.

This example shows the case methods, and proves the original stays the same.

String word = "Hello";

System.out.println(word.toUpperCase());   // HELLO
System.out.println(word.toLowerCase());   // hello
System.out.println(word);                 // still Hello

The last line still prints “Hello”. The case methods handed back new Strings; word never changed. This is handy for comparing input: lowercase both “YES” and “yes” first and they match.

HELLO
hello
Hello

Searching inside text

A few tools find things inside a String, each answering a different question.

• indexOf(s) tells you where a piece of text first appears, as an index.
• lastIndexOf(s) tells you where it appears last, scanning from the end.
• contains(s) just tells you yes or no, is it in there at all.
• startsWith(s) and endsWith(s) check the beginning and the ending.

This example searches a sentence in a few different ways.

String sentence = "I am learning Java, and Java is fun";

System.out.println(sentence.indexOf("Java"));       // first position of "Java"
System.out.println(sentence.lastIndexOf("Java"));   // last position of "Java"
System.out.println(sentence.indexOf("Python"));     // not found
System.out.println(sentence.contains("learning"));  // is it there?
System.out.println(sentence.startsWith("I am"));    // does it start with this?
System.out.println(sentence.endsWith("fun"));       // does it end with this?

Here is what each line gives back:

• indexOf("Java") returns 14, where the first “Java” begins.
• lastIndexOf("Java") returns 24, where the second “Java” begins.
• indexOf("Python") returns -1, because it is missing (not 0).
• contains, startsWith, and endsWith each return true or false.

Use contains for a yes/no answer, and indexOf when you need the position.

14
24
-1
true
true
true

Cutting a piece out with substring

Take a slice out of a String with substring(). The second form is the most common String mistake, so go slow.

• substring(start) gives everything from start to the end.
• substring(start, end) gives start up to but not including end.
• The end index is exclusive, so substring(0, 5) is indexes 0–4, five characters.

This example cuts the same String two ways.

String text = "Hello World";

System.out.println(text.substring(6));      // from index 6 to the end
System.out.println(text.substring(0, 5));   // index 0 up to (not including) 5

Reading the results:

• substring(6) starts at index 6 and runs to the end, giving “World”.
• substring(0, 5) takes indexes 0–4, giving “Hello”, leaving out index 5 (the space).
• The length you get back is exactly end - start, which avoids off-by-one slips.

World
Hello

Cleaning up spaces with trim and strip

Text from people is messy, with stray spaces at the start and end. Remove them with trim() or the newer strip().

• trim() removes spaces from both ends, leaving inner spaces alone.
• strip() does the same but understands more whitespace, like Unicode spaces (Java 11+).
• For everyday text either is fine; for many languages, prefer strip().

This example cleans a value that has spaces on both sides.

String messy = "   Alex   ";

System.out.println("[" + messy.trim() + "]");    // ends trimmed
System.out.println("[" + messy.strip() + "]");   // same idea, newer

Both lines print [Alex]. The square brackets just show where the text begins and ends, so you can see the spaces are gone.

[Alex]
[Alex]

Replacing text with replace

Swap one piece of text for another with replace().

• It changes every match, not just the first.
• It returns a new String, leaving the original alone.

This example turns commas into dashes.

String text = "one,two,three";

System.out.println(text.replace(",", " - "));   // swap every comma
System.out.println(text);                        // original unchanged

replace(",", " - ") changes each comma and returns a new String. The second line proves the original still has its commas; replace copied, it did not edit.

one - two - three
one,two,three

Breaking text into parts with split

When a String holds several values joined by a separator, split() breaks it into an array of pieces. This is how you read comma-separated data or pull words from a sentence.

This example splits on the comma.

String text = "one,two,three";

String[] parts = text.split(",");                // break on each comma

System.out.println("First part: " + parts[0]);
System.out.println("Last part: " + parts[2]);
System.out.println("Number of parts: " + parts.length);

What happens here:

• split(",") cuts the text at each comma and returns an array of pieces.
• parts[0] is “one”, parts[2] is “three”, and parts.length is 3.
• The argument is a pattern, so special characters like . and | need "\\." or "\\|". Commas, spaces, and dashes pass as-is.

First part: one
Last part: three
Number of parts: 3

Comparing Strings the right way

This one trips up almost everyone. To check if two Strings hold the same text, use equals(), not ==. The == operator checks if they are the same object in memory; equals() checks if the characters match.

• equals(other) is true when both Strings hold exactly the same characters, caps included.
• equalsIgnoreCase(other) is true when they match if you ignore capital letters.
• compareTo(other) returns a number that tells you the dictionary order.

This example compares a few names.

String a = "Riya";
String b = "riya";

System.out.println(a.equals(b));              // false, case differs
System.out.println(a.equalsIgnoreCase(b));    // true, case ignored
System.out.println(a.compareTo("Sam"));       // negative, "Riya" comes first
System.out.println(a.compareTo("Riya"));      // zero, they are equal

Reading the results:

• equals returns false because the first letter’s case differs.
• equalsIgnoreCase returns true because ignoring case they are the same.
• compareTo("Sam") returns a negative number; “Riya” comes before “Sam”.
• compareTo("Riya") returns 0; they are equal.

For compareTo: negative means “I come first”, zero means “equal”, positive means “I come later” — exactly what sorting names needs.

false
true
-1
0

Joining text with concat and the plus sign

Stick two Strings together two ways.

• concat() joins, but only Strings.
• + is far more common and can join non-text values too, like a number.
• Both build a new String.

This example joins a first name and a last name.

String first = "Alex";
String last = "Carter";

System.out.println(first.concat(" ").concat(last));   // using concat
System.out.println(first + " " + last);                // using +

Both lines print “Alex Carter”. Use + for small joins. For building text inside a long loop, neither is ideal, and you will meet a faster tool in the next lesson.

Alex Carter
Alex Carter

A quick reference

All the methods in one place. Each returns a new value and never changes the original String.

Two small real tasks

Methods stick once you use a few together on a real job.

First task: clean up typed input with extra spaces and random caps into a tidy lowercase value.

String raw = "   Hello THERE   ";

String clean = raw.trim().toLowerCase();   // trim, then lowercase the result

System.out.println("[" + clean + "]");

The methods chain: raw.trim() returns a cleaned String, then .toLowerCase() runs on that result. Each step works on the output before it, so it reads left to right.

[hello there]

Second task: pull the file extension from a file name. It is whatever comes after the last dot, so lastIndexOf and substring work together.

String fileName = "report.final.pdf";

int dot = fileName.lastIndexOf(".");        // position of the last dot
String ext = fileName.substring(dot + 1);   // everything after that dot

System.out.println("Extension: " + ext);

Use lastIndexOf, not indexOf, because the name has two dots and the extension sits after the last one. substring(dot + 1) starts past the dot, giving a clean “pdf”.

Extension: pdf

Common Mistakes

A few slip-ups catch nearly everyone.

Getting substring’s second number wrong. The end index is excluded, so people read one character too few or too many.

String s = "Hello";

System.out.println(s.substring(0, 5));   // ❌ "you might expect Hell"
System.out.println(s.substring(0, 5));   // ✅ actually "Hello", index 5 is excluded so 0..4

Ignoring the returned value. This is the immutability trap. The method runs, returns a new String, and you forget to keep it.

String s = "  hi  ";

s.trim();          // ❌ result thrown away, s still has the spaces
s = s.trim();      // ✅ keep the returned value, now s is "hi"

Reading an index that is out of range. The last valid index is length() - 1, so going past it throws an error.

String s = "Java";

System.out.println(s.charAt(4));   // ❌ StringIndexOutOfBoundsException, no index 4
System.out.println(s.charAt(3));   // ✅ last valid index is length() - 1, which is 3

Using == to compare text. It compares objects, not characters, so it can be false even when the words look the same.

String a = "hi", b = "h" + "i";

if (a == b) { }          // ❌ unreliable, checks identity not text
if (a.equals(b)) { }     // ✅ checks the actual characters

Best Practices

Habits that keep String code clean and bug-free.

• Always catch the returned value. Strings never change in place, so assign the result, like s = s.trim();.
• Use equals for text, never ==. And use equalsIgnoreCase when capital letters should not matter.
• Pick the right search tool. Use contains for a yes or no, and indexOf when you actually need the position.
• Trim input before you check it. Real input often carries stray spaces, so clean it first, then compare or store.
• Lowercase both sides before comparing case-insensitively. Or just call equalsIgnoreCase, which does it for you.
• Chain methods to read left to right. Something like raw.trim().toLowerCase() is clear, because each step works on the one before it.

What You’ve Learned

Nicely done. That is a full toolbox now. The key String methods:

• ✅ length() counts characters and charAt(i) reads one, both starting at index 0.
• ✅ indexOf() and lastIndexOf() give a position or -1; contains(), startsWith(), and endsWith() give true or false.
• ✅ substring() cuts a piece, and the second index is excluded.
• ✅ toUpperCase(), toLowerCase(), trim(), replace(), and friends all return a new String and leave the original alone.
• ✅ Compare text with equals() or equalsIgnoreCase(), never ==; compareTo() gives dictionary order.
• ✅ split() breaks a String into an array, and concat() or + joins Strings together.

What’s Next?

Now that you can act on text, the next step is comparing it correctly. The difference between == and equals() matters more than people expect. Let’s dig in next.

Java String Comparison