{"title":"String Methods","description":"","content":"The previous lesson introduced what a `String` is and showed the handful of methods that answer \"how big is this?\" or \"what character sits at this position?\". This lesson goes wider. The `String` class ships with dozens of methods for searching inside text, slicing it, swapping characters out, splitting it on a delimiter, changing its case, and trimming whitespace. We'll work through the most useful ones with runnable examples drawn from a normal online store, and call out the spots where the method's behavior surprises beginners.\n\nOne thing to keep in mind. Every method on this page returns a new `String`. None of them changes the original. Treat the return value as the thing that holds your result.\n\n---\n\n# Searching Inside a String\n\nThe most basic question you can ask a string is \"where does this substring start?\". `String` has two methods for that. `indexOf` scans from left to right and returns the index of the first match. `lastIndexOf` scans from right to left and returns the index of the last match. Both return `-1` when the target isn't present.\n\n\n```java\npublic class FindSubstring {\n public static void main(String[] args) {\n String productName = \"Wireless Bluetooth Headphones\";\n\n int firstE = productName.indexOf('e');\n int lastE = productName.lastIndexOf('e');\n int bluetoothStart = productName.indexOf(\"Bluetooth\");\n int missing = productName.indexOf(\"Wired\");\n\n System.out.println(\"First 'e' at index: \" + firstE);\n System.out.println(\"Last 'e' at index: \" + lastE);\n System.out.println(\"'Bluetooth' starts at: \" + bluetoothStart);\n System.out.println(\"'Wired' search returns: \" + missing);\n }\n}\n```\n\n\nThe `-1` is the contract for \"not found\". Code that uses `indexOf` should always check for that before doing arithmetic on the result, because feeding `-1` into `substring` or array indexing leads to confusing failures further down.\n\nBoth methods come in four overloads. The two we've used so far accept either a `char` or a `String`. The other two add a `fromIndex` parameter, which tells the search where to start.\n\n\n```java\npublic class SearchFromIndex {\n public static void main(String[] args) {\n String orderDescription = \"order-101-item-42-qty-3\";\n\n int firstDash = orderDescription.indexOf('-');\n int secondDash = orderDescription.indexOf('-', firstDash + 1);\n int thirdDash = orderDescription.indexOf('-', secondDash + 1);\n\n System.out.println(\"First dash: \" + firstDash);\n System.out.println(\"Second dash: \" + secondDash);\n System.out.println(\"Third dash: \" + thirdDash);\n }\n}\n```\n\n\nThe `fromIndex` form is useful when you want to walk through every occurrence of a character or substring. Start at `0`, find the first one, then call the method again starting one position past where the previous match landed.\n\n`lastIndexOf` takes a `fromIndex` too, but the meaning flips. It treats `fromIndex` as the rightmost position the search is allowed to look at and scans backward from there.\n\n\n```java\npublic class LastIndexFrom {\n public static void main(String[] args) {\n String filename = \"invoice.backup.pdf\";\n\n int lastDot = filename.lastIndexOf('.');\n int dotBefore = filename.lastIndexOf('.', lastDot - 1);\n\n System.out.println(\"Rightmost dot: \" + lastDot);\n System.out.println(\"Dot before that one: \" + dotBefore);\n }\n}\n```\n\n\nA common use of `lastIndexOf` is pulling out a file extension or the trailing segment of any string.\n\n---\n\n# Slicing with `substring`\n\n`substring` carves a piece out of a string and hands you back a new `String` containing just that piece. It comes in two forms.\n\n- `substring(beginIndex)` returns everything from `beginIndex` to the end.\n- `substring(beginIndex, endIndex)` returns everything from `beginIndex` (inclusive) up to `endIndex` (exclusive).\n\nThe half-open range is a common source of off-by-one bugs. The character at `endIndex` isn't in the result. The result's length is `endIndex - beginIndex`.\n\n\n```java\npublic class SubstringBasics {\n public static void main(String[] args) {\n String productCode = \"ELEC-2024-MOUSE-001\";\n\n String category = productCode.substring(0, 4);\n String year = productCode.substring(5, 9);\n String tail = productCode.substring(10);\n\n System.out.println(\"Category: \" + category);\n System.out.println(\"Year: \" + year);\n System.out.println(\"Tail: \" + tail);\n }\n}\n```\n\n\nFor the year, `5` is the position of the digit `2` and `9` is the position of the dash that follows the year. The character at `9` isn't included, which is what we want when \"year\" means four characters.\n\n`substring` pairs well with `indexOf` and `lastIndexOf` when you need to pick a piece out of a string whose exact layout you don't know in advance. Pulling the file extension off a name is the classic case.\n\n\n```java\npublic class FileExtension {\n public static void main(String[] args) {\n String upload = \"shipping-label-final.pdf\";\n\n int dot = upload.lastIndexOf('.');\n if (dot != -1) {\n String name = upload.substring(0, dot);\n String extension = upload.substring(dot + 1);\n System.out.println(\"Name: \" + name);\n System.out.println(\"Extension: \" + extension);\n } else {\n System.out.println(\"No extension found.\");\n }\n }\n}\n```\n\n\nThe `dot + 1` skips the dot itself, which is what most callers want. Off-by-one mistakes around `substring` come in two flavors: forgetting that `endIndex` is exclusive (and slicing one character short), and forgetting to add `1` after a delimiter (and including the delimiter in the result). Reading the boundaries carefully each time is the only fix.\n\nIf you ask for indices that don't make sense, `substring` throws `StringIndexOutOfBoundsException` immediately.\n\n\n```java\npublic class SubstringBounds {\n public static void main(String[] args) {\n String customer = \"Alice\";\n System.out.println(customer.substring(2, 10)); // throws\n }\n}\n```\n\n\nThe valid range is `0 <= beginIndex <= endIndex <= length()`. Calling `s.substring(0, s.length())` is legal and returns a string equal to `s`. Calling `s.substring(s.length())` is also legal and returns an empty string. Going past `length()` isn't.\n\n`substring` allocates a new `String` and copies the selected characters into it. Slicing the same region many times in a loop creates many short-lived objects. If you're carving up the same source string repeatedly, slice once and reuse the result.\n\n---\n\n# Replacing Parts of a String\n\n`String` has a small family of replacement methods, and the differences between them matter. The two safe ones do straight literal replacement. The two regex-aware ones can fail unexpectedly if you don't know they treat their first argument as a regular expression.\n\nThe literal versions are `replace(char, char)` and `replace(CharSequence, CharSequence)`. Both swap every occurrence of the first argument with the second, with no regex interpretation. `CharSequence` is a supertype that `String` implements, so passing two strings works as expected.\n\n\n```java\npublic class LiteralReplace {\n public static void main(String[] args) {\n String address = \"1 Main St, Apt 4\";\n String hyphenated = address.replace(' ', '-');\n String expanded = address.replace(\"St\", \"Street\");\n\n System.out.println(hyphenated);\n System.out.println(expanded);\n }\n}\n```\n\n\nBoth calls produce new strings. `address` itself is unchanged. If you want to replace several patterns, chain the calls or assign the intermediate results to a variable.\n\n\n```java\npublic class ChainedReplace {\n public static void main(String[] args) {\n String description = \"Brand New :: Wireless :: Mouse\";\n String clean = description.replace(\" :: \", \" \").replace(\"Brand New\", \"New\");\n System.out.println(clean);\n }\n}\n```\n\n\nThe regex-aware versions are `replaceAll(String, String)` and `replaceFirst(String, String)`. Both treat the first argument as a regular expression pattern. `replaceAll` replaces every match. `replaceFirst` replaces only the leftmost one.\n\n\n```java\npublic class RegexReplace {\n public static void main(String[] args) {\n String prices = \"Item1: 29 dollars, Item2: 45 dollars, Item3: 12 dollars\";\n\n String withSymbol = prices.replaceAll(\"dollars\", \"USD\");\n String firstOnly = prices.replaceFirst(\"dollars\", \"USD\");\n\n System.out.println(\"All: \" + withSymbol);\n System.out.println(\"First: \" + firstOnly);\n }\n}\n```\n\n\nBecause the first argument is a regex, characters with special regex meaning (`.`, `*`, `+`, `?`, `(`, `)`, `[`, `]`, `{`, `}`, `|`, `^`, `$`, `\\`) don't match themselves literally. The `.` is the most common source of confusion.\n\n**What's wrong with this code?**\n\n\n```java\npublic class DotReplaceBug {\n public static void main(String[] args) {\n String price = \"29.99\";\n String cleaned = price.replaceAll(\".\", \",\");\n System.out.println(cleaned);\n }\n}\n```\n\n\nThe caller wanted `29,99`. They got `,,,,,` instead. In a regex, `.` matches any character, so every position in the string is a match and gets replaced. The fix is to either escape the dot or use the literal `replace` method.\n\n**Fix:**\n\n\n```java\npublic class DotReplaceFixed {\n public static void main(String[] args) {\n String price = \"29.99\";\n String cleaned = price.replace(\".\", \",\");\n System.out.println(cleaned);\n }\n}\n```\n\n\nFor now, the rule of thumb is: if you're replacing a fixed string, use `replace` first. Only use `replaceAll` or `replaceFirst` when a pattern is required.\n\n---\n\n# Splitting into Parts\n\n`split(String regex)` takes a delimiter and breaks the string into an array of pieces. Wherever the delimiter matches, the string is cut, and the parts between cuts become elements of the result.\n\n\n```java\npublic class SplitOrder {\n public static void main(String[] args) {\n String order = \"shoes,29.99,blue,size-10\";\n String[] fields = order.split(\",\");\n\n System.out.println(\"Item: \" + fields[0]);\n System.out.println(\"Price: \" + fields[1]);\n System.out.println(\"Color: \" + fields[2]);\n System.out.println(\"Size: \" + fields[3]);\n System.out.println(\"Total fields: \" + fields.length);\n }\n}\n```\n\n\nThe argument to `split` is a regex, the same as with `replaceAll`. A single literal character like `,` happens to have no special regex meaning, so it works as written. If you want to split on a character that does have regex meaning, like `.` or `|`, you've to escape it in the pattern.\n\n\n```java\npublic class SplitOnDot {\n public static void main(String[] args) {\n String version = \"v1.4.2\";\n String[] parts = version.split(\"\\\\.\");\n System.out.println(\"Major: \" + parts[0]);\n System.out.println(\"Minor: \" + parts[1]);\n System.out.println(\"Patch: \" + parts[2]);\n }\n}\n```\n\n\nThe pattern `\"\\\\.\"` is a two-character Java string that contains the two characters backslash and dot. In regex, `\\.` means \"a literal dot\". The double backslash is how Java spells one backslash inside a string literal.\n\n`split` can also drop trailing empty strings from the result, which is a common gotcha.\n\n\n```java\npublic class SplitTrailing {\n public static void main(String[] args) {\n String row = \"alice,,bob,,,\";\n String[] parts = row.split(\",\");\n System.out.println(\"Parts: \" + parts.length);\n for (int i = 0; i < parts.length; i++) {\n System.out.println(i + \": [\" + parts[i] + \"]\");\n }\n }\n}\n```\n\n\nThe trailing empty fields after `bob` are removed without warning. If you need them, the two-argument form `split(regex, limit)` with a negative limit keeps every empty field.\n\nEvery call to `split` compiles the regex pattern from scratch. If you split the same delimiter many times in a hot loop, pre-compile a `Pattern` once and reuse it.\n\n---\n\n# Changing Case\n\n`toUpperCase()` and `toLowerCase()` return new strings with every letter converted to the matching case. Non-letter characters pass through unchanged.\n\n\n```java\npublic class ChangeCase {\n public static void main(String[] args) {\n String productName = \"Wireless Mouse\";\n System.out.println(productName.toUpperCase());\n System.out.println(productName.toLowerCase());\n System.out.println(productName);\n }\n}\n```\n\n\nThe third line prints the original because, again, neither method changes the source. Both have a variant that takes a `Locale`, which controls how the case rules are applied for languages where uppercase is more than a simple character swap. The no-argument versions use the JVM's default locale. For e-commerce search and comparison, normalizing to lowercase before comparing is a common pattern, and a locale-aware call (`toLowerCase(Locale.ROOT)`) avoids problems on systems with unexpected defaults.\n\n\n```java\npublic class NormalizeForSearch {\n public static void main(String[] args) {\n String query = \"Wireless Mouse\";\n String catalog = \"WIRELESS MOUSE - BLACK\";\n\n boolean match = catalog.toLowerCase().contains(query.toLowerCase());\n System.out.println(\"Match: \" + match);\n }\n}\n```\n\n\n---\n\n# Trimming Whitespace\n\nWhen text comes from a form, a CSV file, or a copy-paste, it usually arrives with stray whitespace at the ends. `trim` and `strip` both clean that up. They differ in what they consider whitespace.\n\n`trim()` is the old method. It removes any leading or trailing character whose code point is at or below `U+0020`, which covers the ASCII space and the usual control characters but not Unicode whitespace.\n\n`strip()`, added in Java 11, removes any character that `Character.isWhitespace` considers whitespace. That includes a wide range of Unicode whitespace characters that `trim` would leave alone.\n\n\n```java\npublic class TrimVsStrip {\n public static void main(String[] args) {\n String name = \" Alice \";\n // is EM SPACE, a Unicode whitespace character\n\n System.out.println(\"[\" + name + \"]\");\n System.out.println(\"[\" + name.trim() + \"]\");\n System.out.println(\"[\" + name.strip() + \"]\");\n }\n}\n```\n\n\n`trim` left the EM SPACE characters in place because their code point (`0x2003`) is above `0x20`. `strip` removed them because they count as Unicode whitespace.\n\nFor plain ASCII input, the two methods behave the same. For anything that might include Unicode whitespace, prefer `strip`. New code should use `strip` by default.\n\nJava 11 also added `stripLeading()` and `stripTrailing()` for one-sided trims.\n\n\n```java\npublic class OneSidedStrip {\n public static void main(String[] args) {\n String review = \" Great product \";\n System.out.println(\"[\" + review.stripLeading() + \"]\");\n System.out.println(\"[\" + review.stripTrailing() + \"]\");\n }\n}\n```\n\n\nThese are useful when you care about whitespace on one side but not the other, like keeping indentation on the left but cleaning trailing spaces on the right.\n\n---\n\n# Checking What a String Contains\n\nOften you don't need the exact position of a substring. You want to know whether the string includes it, or starts or ends with it. Four boolean methods cover those cases.\n\n- `contains(CharSequence target)` returns `true` if `target` appears anywhere in the string.\n- `startsWith(String prefix)` returns `true` if the string begins with `prefix`.\n- `startsWith(String prefix, int offset)` returns `true` if the string has `prefix` at position `offset`.\n- `endsWith(String suffix)` returns `true` if the string finishes with `suffix`.\n\n\n```java\npublic class ContainsChecks {\n public static void main(String[] args) {\n String productName = \"Wireless Bluetooth Headphones\";\n\n System.out.println(\"Has 'Bluetooth': \" + productName.contains(\"Bluetooth\"));\n System.out.println(\"Has 'Wired': \" + productName.contains(\"Wired\"));\n System.out.println(\"Starts wireless: \" + productName.startsWith(\"Wireless\"));\n System.out.println(\"Ends phones: \" + productName.endsWith(\"phones\"));\n }\n}\n```\n\n\n`contains` is the easiest way to test for membership. It's roughly the same as `indexOf(target) != -1`, but reads more clearly when position is irrelevant.\n\nThe two-argument `startsWith` is helpful when checking for a prefix at a position other than the beginning.\n\n\n```java\npublic class StartsWithOffset {\n public static void main(String[] args) {\n String orderId = \"ORD-2024-00321\";\n\n boolean is2024 = orderId.startsWith(\"2024\", 4);\n boolean isLegacy = orderId.startsWith(\"2019\", 4);\n\n System.out.println(\"From 2024: \" + is2024);\n System.out.println(\"From 2019: \" + isLegacy);\n }\n}\n```\n\n\nYou could write the same check with `substring(4, 8).equals(\"2024\")`, but that allocates a temporary string just to throw it away. The `startsWith(prefix, offset)` form does the comparison in place without the extra allocation.\n\n`startsWith(prefix, offset)` avoids the temporary `String` that `substring(...).equals(...)` would create. Tiny gain on a single call, but it shows up when filtering thousands of strings.\n\nAll three of these methods are case-sensitive. If you want a case-insensitive check, normalize both sides first.\n\n\n```java\npublic class CaseInsensitiveContains {\n public static void main(String[] args) {\n String review = \"GREAT PRODUCT, fast shipping\";\n String search = \"shipping\";\n\n boolean found = review.toLowerCase().contains(search.toLowerCase());\n System.out.println(\"Found: \" + found);\n }\n}\n```\n\n\nThere's no `containsIgnoreCase` in the `String` API. Lowercasing both sides is the standard workaround.\n\n---\n\n# Repeating a String\n\nJava 11 added `repeat(int count)`, which returns a string consisting of the original repeated `count` times. It's the simplest method on this page.\n\n\n```java\npublic class RepeatExample {\n public static void main(String[] args) {\n String separator = \"-\".repeat(20);\n String dots = \".\".repeat(5);\n String empty = \"hello\".repeat(0);\n\n System.out.println(separator);\n System.out.println(\"Loading\" + dots);\n System.out.println(\"[\" + empty + \"]\");\n }\n}\n```\n\n\n`repeat(0)` returns the empty string. A negative count throws `IllegalArgumentException`. Before Java 11, the same result took a loop with `StringBuilder`, which we cover in lesson 05.\n\n\n```java\npublic class RepeatForReceipt {\n public static void main(String[] args) {\n String border = \"=\".repeat(30);\n String title = \" RECEIPT \";\n\n System.out.println(border);\n System.out.println(title);\n System.out.println(border);\n System.out.println(\"Wireless Mouse $29.99\");\n System.out.println(\"USB Cable $ 9.99\");\n System.out.println(border);\n }\n}\n```\n\n\nThis is useful any time you need a divider or a column of padding without typing out the characters by hand.\n\n---\n\n# Joining Strings Together\n\nThe reverse of `split` is `String.join`. It takes a delimiter and a sequence of pieces, then concatenates the pieces with the delimiter between each pair. There are two forms. One takes a varargs of `CharSequence` (so any number of strings as arguments), and the other takes an `Iterable` (so a `List`, a `Set`, or anything else you can loop over).\n\n\n```java\npublic class JoinVarargs {\n public static void main(String[] args) {\n String address = String.join(\", \", \"1 Main St\", \"Apt 4\", \"Springfield\", \"12345\");\n System.out.println(address);\n }\n}\n```\n\n\nThe iterable form is the more common choice, because in practice the pieces are usually already in a collection.\n\n\n```java\nimport java.util.List;\n\npublic class JoinList {\n public static void main(String[] args) {\n List categories = List.of(\"Books\", \"Electronics\", \"Clothing\", \"Toys\");\n String tagline = String.join(\" | \", categories);\n System.out.println(tagline);\n }\n}\n```\n\n\nThe delimiter goes between elements only, never at the start or the end. An empty iterable produces an empty string. A one-element iterable produces just that element with no delimiter.\n\n`String.join` is cleaner than building the same result with a loop and `+=`, and it's faster too, because it allocates one final string instead of one per concatenation.\n\n---\n\n# Looking at Individual Characters with `chars()`\n\n`chars()` returns an `IntStream` of the `char` values (each cast to `int`) in the string. We haven't covered streams yet, so we won't go deep, but one quick use is counting characters that match a condition.\n\n\n```java\npublic class CountDigits {\n public static void main(String[] args) {\n String orderRef = \"ORD-2024-00321-A1\";\n long digitCount = orderRef.chars().filter(Character::isDigit).count();\n System.out.println(\"Digits: \" + digitCount);\n }\n}\n```\n\n\nFor each character in `orderRef`, `chars()` produces its `int` value. `filter(Character::isDigit)` keeps only the ones that are digits. `count()` returns how many made it through. The result is the number of digits in the string.\n\nFor now, treat `chars()` as a way to look at every character in the string with a one-line stream pipeline. You can also walk a string with a `for` loop over `length()` and `charAt(i)`.\n\n---\n\n# A Map of the Methods\n\nThe methods we covered split into a small number of categories based on what kind of work they do.\n\n\n```mermaid\nflowchart LR\n Root[String Methods]:::cyan --> Search[Searching
indexOf, lastIndexOf
contains, startsWith, endsWith]:::orange\n Root --> Slice[Slicing
substring]:::orange\n Root --> Modify[Replacing
replace, replaceAll, replaceFirst]:::green\n Root --> SplitJoin[Split and Join
split, String.join]:::green\n Root --> Format[Case and Trim
toUpperCase, toLowerCase
trim, strip, stripLeading, stripTrailing]:::teal\n Root --> Misc[Other
repeat, chars]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe split between \"searching\" methods that return positions or booleans and \"modifying\" methods that return new strings is the main distinction. When the return type of a method is unclear, the next table answers that question for the ones we covered.\n\n\n| Method | Return type | What it does |\n| ------ | ----------- | ------------ |\n| `indexOf(int / String)` | `int` | Position of first match, or `-1` |\n| `indexOf(int / String, int)` | `int` | First match at or after the given index |\n| `lastIndexOf(int / String)` | `int` | Position of last match, or `-1` |\n| `lastIndexOf(int / String, int)` | `int` | Last match at or before the given index |\n| `substring(int)` | `String` | From `begin` to the end |\n| `substring(int, int)` | `String` | From `begin` (inclusive) to `end` (exclusive) |\n| `replace(char, char)` | `String` | Replace every matching char, literal |\n| `replace(CharSequence, CharSequence)` | `String` | Replace every matching substring, literal |\n| `replaceAll(String, String)` | `String` | Replace every regex match |\n| `replaceFirst(String, String)` | `String` | Replace the first regex match |\n| `split(String)` | `String[]` | Split on a regex delimiter |\n| `toUpperCase()` | `String` | All letters to upper case |\n| `toLowerCase()` | `String` | All letters to lower case |\n| `trim()` | `String` | Strip ASCII whitespace from both ends |\n| `strip()` | `String` | Strip Unicode whitespace from both ends |\n| `stripLeading()` | `String` | Strip Unicode whitespace from the left |\n| `stripTrailing()` | `String` | Strip Unicode whitespace from the right |\n| `contains(CharSequence)` | `boolean` | Whether the substring appears |\n| `startsWith(String)` | `boolean` | Whether the string starts with the prefix |\n| `startsWith(String, int)` | `boolean` | Whether the prefix appears at the offset |\n| `endsWith(String)` | `boolean` | Whether the string ends with the suffix |\n| `repeat(int)` | `String` | Repeat the string the given number of times |\n| `chars()` | `IntStream` | Stream of character code points |\n| `String.join(CharSequence, ...)` | `String` | Concatenate pieces with a delimiter |\n\n\nThe static method `String.join` is at the bottom because it's not called on an instance like the others.","pageType":"java"}

String Methods

Get Premium