Java String Methods

The String class in Java comes with over 60 built-in methods. You do not need all of them — but roughly 20 show up in almost every real project. This article covers each of those 20 with a clear explanation of what it does, how it behaves on edge cases, and where it genuinely appears in production code.

Every method here returns a new String or a computed value — none of them modify the original. That is the immutability rule, and it applies to every method on this page without exception.

Quick Reference — All Methods Covered

1 — length()

Returns the total number of characters in the string, including spaces and punctuation. Indexing in Java is zero-based, so the last valid index is always length() - 1.

Output:
'Priya Sharma' length: 12
'' length          : 0
'   ' length       : 3
With emoji length  : 16
Username 'rohan_dev' is valid (9 chars).
Last char: s

Note: length without parentheses is for arrays (arr.length). For strings, you always need parentheses — str.length().

2 — charAt(index)

Returns the char at the specified zero-based index. Throws StringIndexOutOfBoundsException if the index is negative or greater than or equal to length().

Output:
charAt(0)  : D
charAt(3)  : S
charAt(11) : w

Sentence  : Welcome to India
Vowels    : 6

'racecar' is palindrome: true
Error: String index out of range: 50

3 — indexOf() and lastIndexOf()

indexOf(str) returns the starting index of the first occurrence of a substring. Returns -1 if not found. lastIndexOf(str) returns the last occurrence. Both have overloads that accept a starting position for the search.

Output:
First 'Java'  at: 0
First '.'     at: 14
'Python' at      : -1
'Java' from index 5: 15
Last 'Java'   at: 33
Last '.'      at: 44

Filename  : profile_photo.jpeg
Name      : profile_photo
Extension : jpeg

Email    : rohan.mehta@razorpay.com
Username : rohan.mehta
Domain   : razorpay.com

'an' found 2 times in 'banana'

Always check for -1 before using the index in substring(). If indexOf returns -1 and you pass that to substring(), you get a StringIndexOutOfBoundsException.

4 — substring(start) and substring(start, end)

substring(start) returns everything from start index to the end. substring(start, end) returns characters from start (inclusive) to end (exclusive). The length of the result is always end - start.

Output:
From index 10 : ORD-2024-9921 | Status: PLACED
Indices 10-23 : ORD-2024-9921

Employee ID : EMP-042
Name        : Priya Sharma
Department  : Engineering
Salary      : 85000

First : Ananya
Last  : Krishnan

Truncated : This wireless keyboard comes with a long...

substring(start, end) — end is exclusive. "Hello".substring(0, 3) is "Hel" — positions 0, 1, 2, not 3. A common interview question is: what does "Hello".substring(2, 2) return? Answer: an empty string "" — start equals end, so zero characters.

5 — contains(), startsWith(), endsWith()

Three methods that check whether a string contains or begins/ends with a given value. All return boolean.

Output:
Product code checks:
  contains 'PHONE'  : true
  contains 'LAPTOP' : false

URL checks:
  startsWith 'https': true
  startsWith 'http' : true
  startsWith 'ftp'  : false
  'meesho' at pos 12: true

Filename checks:
  endsWith '.pdf'   : true
  endsWith '.xlsx'  : false

File routing:
  report.pdf      → Document
  data.xlsx       → Spreadsheet
  photo.jpg       → Image
  config.json     → Config
  app.java        → Source Code

6 — equals() and equalsIgnoreCase()

equals() compares content exactly — case-sensitive. equalsIgnoreCase() compares content while ignoring upper/lower case differences. Neither modifies either string.

Output:
equals() — case sensitive:
  'Admin'.equals('admin')  : false
  'Admin'.equals('Admin')  : true

equalsIgnoreCase():
  'Admin' eq-ic 'admin'    : true
  'ADMIN' eq-ic 'admin'    : true

Null safety:
  'admin'.equals(null) : false

ADMIN → Full access
Manager → Reports access
viewer → Read-only access
SUPER_ADMIN → Read-only access

7 — toUpperCase() and toLowerCase()

Convert all characters to uppercase or lowercase respectively. Useful for normalising user input before storage or comparison.

Output:
toUpperCase: HELLO, DEVSTACKFLOW!
toLowerCase: why is everyone shouting?

City match (normalised): true

Raw       : wireless headphones premium edition
Title case: Wireless Headphones Premium Edition

Normalised product codes:
  elec-001 → ELEC_001
  CLOTH-042 → CLOTH_042
  Grocery_101 → GROCERY_101

8 — trim() and strip()

Both remove leading and trailing whitespace. strip() (Java 11+) is the modern version — it handles Unicode whitespace correctly, while trim() only handles characters with ASCII value ≤ 32.

Output:
Original  : '   Hello, World!   '
trim()    : 'Hello, World!'
strip()   : 'Hello, World!'

With tabs : '	  Rohan Mehta  	'
trim()    : 'Rohan Mehta'

Inner spaces : 'Hello   World'
trim()       : 'Hello   World'

stripLeading ('     Sneha'): 'Sneha'
stripTrailing('Priya     '): 'Priya'

Cleaned emails:
  '  rohan@meesho.com  ' → 'rohan@meesho.com'
  '	priya@gmail.com' → 'priya@gmail.com'
  'sneha@flipkart.com   ' → 'sneha@flipkart.com'

Neither trim() nor strip() removes spaces from the middle of a string. To remove all spaces, use replace(" ", "") or replaceAll("\\s+", "").

9 — replace() and replaceAll()

replace(old, new) replaces every occurrence of a character or literal substring. replaceAll(regex, replacement) replaces every match of a regular expression. Both return a new string with all replacements applied.

Output:
Original : I love Java. Java is great. I use Java every day.
Replaced : I love Python. Python is great. I use Python every day.

Phone    : 98765-43210
Cleaned  : 9876543210

Messy : '   Too   many   spaces   '
Neat  : 'Too many spaces'

Raw    : Phone: (98765) 43-210
Digits : 9876543210

Card   : 4111111111114521
Masked : 4111 **** **** 4521

replaceFirst: REPLACED,age,city,name,email

replace() with a String argument replaces literal text. replaceAll() interprets the first argument as a regex — special characters like ., *, +, ?, (, ) must be escaped with \\ if you want them treated literally.

10 — split()

Splits a string at every match of a regular expression and returns a String[]. The delimiter itself is not included in the result.

Output:
CSV     : Priya,28,Bengaluru,Software Engineer
Parts   : [Priya, 28, Bengaluru, Software Engineer]
Name    : Priya
City    : Bengaluru

Words   : [The, quick, brown, fox]

Full    : [home, user, documents, report.pdf]
Limited : [home, user/documents/report.pdf]

Domain  : mail.google.com
Parts   : [mail, google, com]

Record  : ORD-001|Priya|1299.50|PLACED
Columns : [ORD-001, Priya, 1299.50, PLACED]

Normal split : [A, B, , C]
With -1 limit: [A, B, , C, ]

Common traps with split(): . means "any character" in regex — use "\\." for literal dot. | means OR — use "\\|" for literal pipe. By default, trailing empty strings are discarded — use split(delimiter, -1) to preserve them.

11 — String.join()

String.join(separator, parts...) joins multiple strings or an array/list with a separator between each element. This is cleaner than building the joined string manually in a loop.

Output:
Path    : home/user/documents
Skills  : Java, Spring Boot, SQL, Git
Cities  : Mumbai | Delhi | Bengaluru | Pune

CSV row : EMP-042,Priya Sharma,Engineering,85000

SQL     : WHERE id IN (101, 205, 330, 412)

Nav     : Home > Electronics > Mobile Phones > Samsung

12 — String.valueOf() and String.format()

String.valueOf(x) converts any type — int, double, boolean, char, object — to its String representation. It handles null safely, returning "null".

String.format(template, args) builds a formatted string using placeholders like %s (string), %d (integer), %f (decimal), %n (newline).

Output:
valueOf(int)    : 42
valueOf(double) : 1299.99
valueOf(boolean): true
valueOf(char)   : A
valueOf(null)   : null

Name: Rohan Mehta | Role: Developer | Salary: Rs.75000.50 | Experience: 3 yr(s)

Formatted table:
Product            Price      Stock
-------------------------------------
Laptop          45999.00         12
Mouse             599.00        150
Keyboard         1299.00         80
Monitor         18500.00         25

Total Sales: Rs.1,234,567.89
Order ID: ORD-00042

13 — isEmpty() and isBlank()

isEmpty() — true only when length() is 0. A string of spaces has length > 0 so it is not empty. isBlank() (Java 11+) — true when the string is empty OR contains only whitespace. Better for user input validation.

Output:
isEmpty() results:
  ''      isEmpty: true
  '     ' isEmpty: false
  'hello' isEmpty: false

isBlank() results:
  ''      isBlank: true
  '     ' isBlank: true
  '\t'   isBlank: true
  'hello' isBlank: false

Input validation:
  'Priya Sharma' → VALID
  '' → INVALID: empty or blank
  '  ' → INVALID: empty or blank
  'null' → INVALID: empty or blank
  'R' → VALID

14 — toCharArray()

Converts the String into a char[]. Useful for character-level operations: sorting characters, frequency counting, manual parsing, or when you need to modify characters (remember, String is immutable — you cannot modify a String's characters in place, but you can modify a char[]).

Output:
String   : DevStackFlow
charArray: [D, e, v, S, t, a, c, k, F, l, o, w]
Length   : 12

Sorted chars: acdefklovstw

Character frequencies in 'programming':
  'a' : 1
  'g' : 2
  'i' : 1
  'm' : 2
  'n' : 1
  'o' : 1
  'p' : 1
  'r' : 2

Reversed: etsamaN

Real-World Example — Complete Profile Processing Pipeline

The Business Problem

A user profile management system at a company like Meesho or Flipkart receives raw profile data from multiple sources — mobile apps, web forms, import files. The data is inconsistent: mixed case, extra spaces, partially formatted phone numbers, varied email formats. The pipeline below uses string methods at every step to clean, validate, and format the data into a consistent structure before saving it.

Output:
╔══════════════════════════════════════════╗
║     PROFILE PROCESSING PIPELINE         ║
╚══════════════════════════════════════════╝

── Profile 1 ──────────────────────────────
RAW INPUT:
  name  : '  priya  SHARMA  '
  email : 'PRIYA@MEESHO.COM  '
  phone : '98765 43210'
  city  : '  bengaluru  '

PROCESSED:
Name       : Priya Sharma
Email      : priya@meesho.com
Phone      : 98765-43210
City       : Bengaluru

── Profile 2 ──────────────────────────────
RAW INPUT:
  name  : 'rohan mehta'
  email : 'rohan@flipkart.in'
  phone : '+91-9876543210'
  city  : 'Mumbai'

PROCESSED:
Name       : Rohan Mehta
Email      : rohan@flipkart.in
Phone      : 98765-43210
City       : Mumbai

── Profile 3 ──────────────────────────────
RAW INPUT:
  name  : 'SNEHA RAO'
  email : 'sneha.rao'
  phone : '9123456789'
  city  : 'CHENNAI'

PROCESSED:
Name       : Sneha Rao
Email      : MISSING
Phone      : 91234-56789
City       : Chennai

── Profile 4 ──────────────────────────────
RAW INPUT:
  name  : ''
  email : 'karan@gmail.com'
  phone : '12345'
  city  : 'Delhi'

PROCESSED:
Name       : MISSING
Email      : karan@gmail.com
Phone      : MISSING
City       : Delhi

All 14 methods appear across the pipeline: isBlank, trim, strip, toLowerCase, toUpperCase, split, charAt, substring, contains, indexOf, startsWith, replaceAll, format, toCharArray.

Best Practices

Always check for null before calling any String method. A null String reference throws NullPointerException on any method call. The safe pattern: if (input != null && !input.isBlank()). For comparison, put the known non-null constant on the left: "expected".equals(input).

Prefer isBlank() over isEmpty() for user input validation. A user typing only spaces has not provided a value. isEmpty() misses this. isBlank() correctly rejects whitespace-only strings. This distinction prevents silent bugs in form validation logic.

Use String.format() for multi-value messages. Building a message with several variables using + produces code that is hard to read as the number of parts grows. String.format("Rs.%.2f for order %s", amount, id) is readable, maintainable, and auto-formats numbers.

Escape regex special characters in split() and replaceAll(). Common characters that must be escaped: . (dot), | (pipe), *, +, ?, (, ), [, ]. Use "\\." for a literal dot, "\\|" for a literal pipe. Forgetting this is the most common mistake with both methods.

Common Mistakes

Mistake 1 — Ignoring the Return Value

Mistake 2 — Using split(".") to Split by Dot

Mistake 3 — Comparing Strings With ==

Mistake 4 — Calling substring(0, 0) Expecting Something Useful

substring(start, end) where start == end returns an empty string, not a single character. To get the first character as a String: name.substring(0, 1) or String.valueOf(name.charAt(0)).

Interview Questions

Q1. What is the difference between str.replace() and str.replaceAll() in Java?

replace(old, new) replaces all occurrences of a literal character or literal string. It does not interpret the first argument as a regular expression. replaceAll(regex, replacement) interprets the first argument as a regular expression and replaces every match. Use replace() for straightforward text substitution. Use replaceAll() when you need pattern matching — removing all digits, collapsing multiple spaces, or extracting specific formats. Because replaceAll() compiles the regex each call, replace() is slightly faster for literal substitution.

Q2. What does split(".") return when called on a String?

An empty array — not the parts separated by dots. The . in regex means "match any single character". So every character in the string is treated as a delimiter, leaving no content between delimiters. To split on a literal dot, escape it: split("\\."). This is one of the most common beginner traps and appears frequently in interview screening tests.

Q3. What is the difference between trim() and strip() in Java?

Both remove leading and trailing whitespace, but they differ in which characters they consider whitespace. trim() removes characters with ASCII value ≤ 32 — the standard ASCII whitespace. strip() (Java 11+) removes Unicode whitespace — it recognises non-breaking spaces, ideographic spaces, and other Unicode whitespace characters that trim() would leave behind. For modern Java, strip() is the preferred choice. stripLeading() and stripTrailing() are also available for one-sided trimming.

Q4. What is the difference between isEmpty() and isBlank()?

isEmpty() returns true only when length() is 0 — a string with just spaces like " " is not empty. isBlank() (Java 11+) returns true when the string is either empty or contains only whitespace characters. For validating user input, isBlank() is almost always the correct choice — a user who types only spaces has not provided a value, and isEmpty() would incorrectly accept it.

Q5. How does String.format() work and what are the main format specifiers?

String.format(template, args...) builds a formatted string by replacing placeholders in the template with the provided arguments. The main specifiers: %s for any object (calls toString()), %d for integers, %f for floating-point (use %.2f for 2 decimal places), %c for a single character, %b for boolean, %n for a newline, and %, for thousand separators. Width and alignment are controlled by numbers — %-20s left-aligns in a 20-character field, %10d right-aligns an integer in 10 characters.

Q6. What does indexOf() return when the substring is not found, and why does this matter?

indexOf() returns -1 when the target substring is not present. The return value of -1 matters because it is a common source of bugs: if you pass -1 directly to substring() — for example, str.substring(0, str.indexOf("@")) when there is no @ — you get StringIndexOutOfBoundsException. Always check if indexOf returned -1 before using the result: int idx = str.indexOf("@"); if (idx != -1) { ... }.

FAQs

Are String methods case-sensitive by default?

Yes. contains(), startsWith(), endsWith(), equals(), indexOf(), and replace() are all case-sensitive. "Hello".contains("hello") returns false. Use toLowerCase() on both sides before comparing, or use the IgnoreCase variants where they exist: equalsIgnoreCase(), compareToIgnoreCase(), regionMatches() with ignoreCase=true.

Can String methods be chained?

Yes. Since every String method returns a new String, you can chain calls directly: input.trim().toLowerCase().replace(",", "").split(" "). Each method is called on the result of the previous one. Chaining is readable for two or three operations. For longer chains, assigning intermediate results to named variables improves readability and makes debugging easier.

What is the difference between compareTo() and equals()?

equals() returns a boolean — just true or false, same content or not. compareTo() returns an integer — zero means equal, negative means the first string comes before the second lexicographically (dictionary order), positive means the first comes after. compareTo() is used for sorting strings. equals() is used for equality checks. compareToIgnoreCase() is the case-insensitive version.

Why does substring() use exclusive end index?

The exclusive end index is a convention used throughout Java's standard library — Arrays.copyOfRange, List.subList, String.substring all use (from, to) where from is inclusive and to is exclusive. This makes it easy to compute the length: the result always has to - from elements. It also makes adjacent slices simple — substring(0, 5) and substring(5, 10) together cover positions 0-9 with no overlap and no gap.

Does replace() modify the original string?

No. String is immutable. replace() returns a new String with the replacements applied — the original string is unchanged. If you write str.replace("a", "b") without capturing the result, nothing changes. Always assign the return value: str = str.replace("a", "b") or String newStr = str.replace("a", "b").

Summary

The twenty String methods covered here handle the vast majority of text processing needs in real Java development. The most critical to master: trim() and strip() for cleaning input, equals() and equalsIgnoreCase() for comparison, contains() / startsWith() / endsWith() for presence checks, indexOf() and substring() for extraction, replace() and replaceAll() for substitution, split() for parsing, and String.format() for structured output.

The one rule that ties all of them together: String is immutable. Every method returns a new String. Always capture the result.

What to Read Next