String Methods

The String class provides more than sixty methods for examining and transforming text. This lesson is a guided tour of the ones used most often, grouped by purpose, with the rules that apply to all of them. Several groups (comparison, searching, replacing, splitting, formatting) have their own detailed lessons; here the goal is to know what exists and when to reach for it.

Two Rules That Apply to Every Method

1. Strings are immutable. No method changes the string it is called on. Methods that transform text return a new string, which you must store or use:

String name = "  ada  ";
name.strip();                      // result thrown away; name is unchanged
name = name.strip();               // correct: keep the result

2. Indexes are zero-based, and end indexes are exclusive. In substring(2, 5), the character at index 2 is included and the one at index 5 is not, so the result has 5 - 2 = 3 characters. Indexes outside 0–length() throw StringIndexOutOfBoundsException.

Because transforming methods return strings, they can be chained:

String cleaned = "  Hello, World!  ".strip().toLowerCase().replace("!", "");   // "hello, world"

Examining Characters and Size

Changing Case

"Java".toUpperCase();      // "JAVA"
"Java".toLowerCase();      // "java"

Case conversion depends on the locale for a few languages. In Turkish, for example, "TITLE".toLowerCase() produces a dotless ı. For identifiers, keys, file extensions, and protocol values that are not shown to users, pass Locale.ROOT so the result is the same on every machine:

String ext = fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase(Locale.ROOT);

There is no built-in "capitalize" method; combine substring with case conversion:

String word = "chennai";
String capitalized = word.substring(0, 1).toUpperCase() + word.substring(1);   // "Chennai"

Removing Whitespace

String s = "  Hello, Java World  ";
System.out.println("[" + s.strip() + "]");      // [Hello, Java World]

Prefer strip() in new code. trim() does not remove Unicode whitespace such as the non-breaking space (U+00A0) or ideographic space (U+3000), which often arrive in text copied from web pages.

To remove all whitespace, including inside the string, use a regular expression: s.replaceAll("0s+", "").

Extracting Parts

String path = "reports/2026/november/sales.csv";

path.substring(8);                         // "2026/november/sales.csv"
path.substring(0, 7);                      // "reports"
path.substring(path.lastIndexOf('/') + 1); // "sales.csv"

substring combined with indexOf or lastIndexOf is the standard way to pull out a segment around a delimiter. split (its own lesson) breaks a string into all its parts at once.

Searching

String s = "  Hello, Java World  ";
s.contains("Java");           // true
s.indexOf('o');               // 6
s.lastIndexOf('o');           // 15
s.strip().startsWith("Hello");   // true

All of these are case-sensitive. The String Search lesson covers them in depth.

Comparing

"Java".equalsIgnoreCase("JAVA");    // true
"java".compareTo("Java");           // 32: 'j' (106) minus 'J' (74)

Never compare string content with ==. The String Compare lesson explains why.

Replacing

"banana".replace('a', 'o');             // "bonono"
"2026-11-11".replace("-", "/");         // "2026/11/11"
"a1b22c333".replaceAll("\\d+", "#");    // "a#b#c#"

replace with text is literal; replaceAll treats its first argument as a regular expression, so characters such as ., $, and + have special meanings there.

Splitting and Joining

"red,green,blue".split(",");                  // ["red", "green", "blue"]
"a,b,,c".split(",").length;                   // 4: the empty field between commas is kept
String.join("|", List.of("x", "y"));          // "x|y"
"line1\nline2".lines().count();               // 2

split takes a regular expression. lines() (Java 11) splits on any line terminator (\n, \r\n, or \r) and returns a stream.

Building and Formatting

Other Useful Methods

Practical Example: URL Slugs and Initials

Blogs and course platforms turn titles into URL-friendly "slugs," and user interfaces often show a person's initials in an avatar.

import java.text.Normalizer;
import java.util.List;

public class Slug {
    static String slugify(String title) {
        String s = Normalizer.normalize(title.strip(), Normalizer.Form.NFD)
                .replaceAll("\\p{M}", "")           // drop accents: é -> e
                .toLowerCase()
                .replaceAll("[^a-z0-9]+", "-")       // anything else becomes a hyphen
                .replaceAll("^-|-$", "");            // no leading or trailing hyphen
        return s.length() > 40 ? s.substring(0, 40).replaceAll("-$", "") : s;
    }

    static String initials(String fullName) {
        StringBuilder sb = new StringBuilder();
        for (String part : fullName.strip().split("\\s+")) {
            sb.append(Character.toUpperCase(part.charAt(0)));
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        List<String> titles = List.of(
            "  Java Strings: The Complete Guide ",
            "Café & Crème — Résumé Tips!",
            "C++ vs. C# in 2026?",
            "Understanding Java's String.format(), String.join() and Text Blocks in Depth"
        );
        for (String t : titles) {
            System.out.println(slugify(t));
        }
        System.out.println(initials("  ada   king lovelace "));
    }
}

Output:

java-strings-the-complete-guide
cafe-creme-resume-tips
c-vs-c-in-2026
understanding-java-s-string-format-strin
AKL

slugify is a chain of string methods, each returning a new string for the next step:

1. strip() removes outer whitespace.
2. Normalizer.normalize(..., NFD) splits accented letters into a base letter plus a combining mark, and replaceAll("0p{M}", "") deletes the marks, turning é into e.
3. toLowerCase() lowercases the text.
4. replaceAll("[^a-z0-9]+", "-") turns every run of other characters (spaces, punctuation, symbols) into a single hyphen.
5. A final replaceAll trims hyphens at either end.
6. Long slugs are cut with substring, and any trailing hyphen left by the cut is removed.

The output also shows the limits of a simple approach. C++ and C# both become c, and the long title is cut mid-word. Real systems often keep a small table of special cases and cut at the last hyphen before the limit. initials uses split("0s+") to break the name on runs of whitespace (so extra spaces do no harm), then charAt(0) and Character.toUpperCase to build the result.