1. Introduction

Output

0
10
-1

Both methods also have overloads that accept a fromIndex. For indexOf(), the search begins at or after that position. For lastIndexOf(), fromIndex is the rightmost position at which the backward search may begin.

Output

1
3
5
Last a at or before index 3: 3

Always check for -1 before using a search result in index arithmetic or passing it to another method.

4. Extracting Text with substring()

substring() returns a portion of a string. It has two common forms:

• substring(beginIndex) returns the text from beginIndex through the end.
• substring(beginIndex, endIndex) returns text from beginIndex (inclusive) to endIndex (exclusive).

The length of a substring produced by the two-index form is endIndex - beginIndex.

Output

2024-58
2024
58

4.1 Extracting a File Extension

Combine lastIndexOf() and substring() when the location of a delimiter is not fixed.

Output

 Extension: pdf

The + 1 skips the dot. The check also avoids treating a missing dot or a final dot as a normal extension.

Valid boundaries satisfy:

0 <= beginIndex <= endIndex <= string.length()

Invalid boundaries cause StringIndexOutOfBoundsException. Calling substring(0, s.length()) is valid, and calling substring(s.length()) returns an empty string.

5. Replacing Text

Java offers literal replacement methods and regular-expression replacement methods. Choose the correct family for the task.

5.1 Literal replacement with replace()

• replace(char oldChar, char newChar) replaces every occurrence of a character.
• replace(CharSequence target, CharSequence replacement) replaces every matching literal sequence.

Output

12 Park Street, Park City
987 654 3210
12 Main Street, Main City

5.2 Regex replacement with replaceAll() and replaceFirst()

• replaceAll(regex, replacement) replaces every match of a regular expression.
• replaceFirst(regex, replacement) replaces only the first match.

Output

Item # costs #.## and item # costs #.##
Item ORDER costs 29.99 and item 13 costs 39.99

Output

29,99
29,99

6. Splitting a String with split()

split(String regex) divides a string wherever the regular expression matches and returns a String[] array.

Output

[Books, Games, Electronics]
Books
Games
Electronics

The argument is a regular expression. A comma has no special regex meaning, so split(",") works directly. A dot does have special meaning, so split on a literal dot with split("\\.").

Output

 [invoice, pdf]

6.1 Trailing Empty Values

By default, split(regex) discards trailing empty strings. Use the two-argument form with a negative limit to preserve them.

Output

[alice, bob]
[alice, bob, , ]

If the same regex is used repeatedly in a performance-critical loop, consider compiling a Pattern once and reusing it.

7. Changing Letter Case

toUpperCase() and toLowerCase() return new strings with letters converted to upper or lower case. Non-letter characters generally remain unchanged.

Output

WIRELESS MOUSE - BLACK
wireless mouse - black
Wireless Mouse - Black
title

The no-argument methods use the JVM's default locale. For locale-independent normalization—such as technical identifiers or case-normalized comparisons—use toLowerCase(Locale.ROOT) where appropriate. Case conversion is not always a simple one-character-to-one-character transformation in every language.

8. Removing Whitespace: trim() and strip()

Text from forms, CSV files, or copy-and-paste operations can contain unwanted whitespace at the beginning or end.

• trim() removes leading and trailing characters whose values are at or below U+0020.
• strip() removes leading and trailing characters recognized as whitespace by Character.isWhitespace().
• stripLeading() removes whitespace only at the beginning.
• stripTrailing() removes whitespace only at the end.

strip(), stripLeading(), and stripTrailing() were introduced in Java 11.

Output

[Java String Methods]
[Java String Methods]
[Java String Methods   ]
[   Java String Methods]

For ordinary ASCII spaces, trim() and strip() often appear identical. With Unicode whitespace, their behavior can differ. Prefer strip() in new Java 11+ code when Unicode whitespace handling is desired.

9. Checking String Content

These methods answer whether a string contains a sequence or matches a prefix or suffix:

• contains(CharSequence target) checks whether the target occurs anywhere.
• startsWith(String prefix) checks the beginning of the string.
• startsWith(String prefix, int offset) checks for a prefix at a specified position.
• endsWith(String suffix) checks the end of the string.

Output

true
true
true
true

Output

 true

Java 11 introduced repeat(int count), which returns the original string repeated the requested number of times. A count of zero returns an empty string. A negative count throws IllegalArgumentException.

Output

----------hahaha0

This is convenient for dividers or repeated padding. On Java versions before 11, similar output can be built using a loop and StringBuilder.

11. Joining Text with String.join()

String.join() combines several character sequences with a delimiter between adjacent elements. It supports varargs and an Iterable, such as a list.

Output

store/orders/2024sale, popular, new

The delimiter appears only between elements, not at the beginning or end. An empty iterable produces an empty string; a one-element iterable produces that element without a delimiter. String.join() is generally clearer than repeatedly concatenating strings with += in a loop.

12. Inspecting Characters with chars()

chars() returns an IntStream of the string's UTF-16 char values converted to integers. It can be useful with stream operations such as filter() and count().

Output

 Digits: 6

For beginner-friendly character-by-character processing, a for loop using length() and charAt(i) is also a useful option. Note that chars() processes UTF-16 code units; supplementary Unicode characters may require codePoints() when working with full Unicode code points.

13. String Method Reference Table

14. Common Mistakes to Avoid

1. Assuming a method changes the original string. Assign the returned value if you want to keep it: text = text.strip();.
2. Treating -1 as a valid search index. Check whether indexOf() or lastIndexOf() found a match before using the result.
3. Forgetting that substring() excludes endIndex. The second index marks the position just after the final character to include.
4. Forgetting to skip a delimiter. Use delimiterIndex + 1 when extracting text after a one-character delimiter.
5. Using replaceAll() for fixed literal text. Regex metacharacters may match more than intended; prefer replace() for literal replacements.
6. Forgetting that split() accepts a regex. Escape special regex characters such as a literal dot.
7. Ignoring trailing empty fields. Use split(regex, -1) when trailing empty strings must be retained.
8. Assuming case checks ignore case. contains(), startsWith(), and endsWith() are case-sensitive.
9. Using Java 11 methods on older runtimes. strip(), repeat(), and related methods require Java 11 or later.

15. Best Practices

• Prefer contains() when you only need a yes/no answer, rather than the exact index.
• Use replace() for literal replacement and regex methods only when a pattern is required.
• Validate search results before passing their indexes into substring().
• Choose strip() for Unicode-aware whitespace removal in Java 11+ applications.
• Use Locale.ROOT for locale-independent case normalization when appropriate.
• Use String.join() when joining an existing collection of strings.
• Preserve trailing empty fields with split(regex, -1) if they are meaningful data.
• Avoid repeated string slicing or concatenation in performance-sensitive loops; measure the real workload and consider alternatives where necessary.

16. Quick Revision

• indexOf() finds the first match; lastIndexOf() finds the last. Both return -1 if absent.
• substring(begin, end) includes begin and excludes end.
• replace() performs literal replacement; replaceAll() and replaceFirst() use regex patterns.
• split() uses a regex and normally discards trailing empty fields; a negative limit preserves them.
• toUpperCase() and toLowerCase() return converted strings without modifying the source.
• trim() handles a limited range of characters; strip() handles whitespace recognized by Character.isWhitespace().
• contains(), startsWith(), and endsWith() return booleans and are case-sensitive.
• repeat() and strip() were added in Java 11.
• String.join() places a delimiter between elements.
• chars() exposes UTF-16 char values as an IntStream.

17. Conclusion

Java String methods make common text operations easier to express and read. Learn the difference between searching and slicing, literal and regex replacement, and trim() and strip(). Most importantly, remember that strings are immutable: transformation methods return results rather than changing the original object. With careful index checks and the right method for each job, you can process text reliably in Java applications.