String Utility Methods: join(), repeat(), chars(), strip()

Java's String class ships with a rich set of utility methods for everyday text manipulation. Java 11 expanded the API significantly: strip() provides Unicode-aware whitespace removal, isBlank() tests for empty-or-whitespace strings, and repeat() makes string repetition a one-liner. The chars() and codePoints() methods expose a string as an IntStream, enabling stream pipelines over individual characters. This article covers the most useful String utility methods with practical examples.

String.join() with delimiter and Iterable
String.repeat(): Java 11+
strip() vs trim(): Unicode-aware whitespace
chars() and codePoints() streams
contains(), startsWith(), endsWith()
toUpperCase() / toLowerCase() with Locale
isBlank(): Java 11+

String.join() with delimiter and Iterable

String.join(delimiter, elements) concatenates all elements with the given separator, accepting either varargs or any Iterable<? extends CharSequence>. Null elements are included as the literal string "null" rather than throwing. For a list join, String.join(",", list) is the simplest option. Inside a stream pipeline where you need prefix and suffix as well, use Collectors.joining(delimiter, prefix, suffix). For incremental joining in a loop with prefix/suffix control, StringJoiner provides setEmptyValue() to control what is returned when no elements are added.

Java

// String.join(delimiter, elements...) — joins strings with a separator
String csv = String.join(", ", "Alice", "Bob", "Charlie");
System.out.println(csv); // Alice, Bob, Charlie

// Join from a List (or any Iterable<CharSequence>)
List<String> names = List.of("red", "green", "blue");
String joined = String.join(" | ", names);
System.out.println(joined); // red | green | blue

// Empty delimiter — concatenates without separator
String concat = String.join("", "foo", "bar", "baz");
System.out.println(concat); // foobarbaz

// Join with multi-character delimiter
String path = String.join("/", "home", "user", "docs", "report.txt");
System.out.println(path); // home/user/docs/report.txt

// Join a Set (iteration order is Set-defined)
Set<String> tags = new LinkedHashSet<>(List.of("java", "strings", "api"));
System.out.println(String.join(", ", tags)); // java, strings, api

// StringJoiner — more control: prefix, suffix, empty value
import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.add("one");
sj.add("two");
sj.add("three");
System.out.println(sj.toString()); // [one, two, three]

// setEmptyValue — returned when no elements are added
StringJoiner empty = new StringJoiner(", ", "[", "]");
empty.setEmptyValue("(none)");
System.out.println(empty.toString()); // (none)

// Collectors.joining() — joining in a stream pipeline
String result = Stream.of("a", "b", "c")
    .map(String::toUpperCase)
    .collect(Collectors.joining(", ", "{", "}"));
System.out.println(result); // {A, B, C}

Use String.join() when you already have the elements. Use Collectors.joining() inside a stream pipeline. Use StringJoiner directly when you need to add elements incrementally (e.g., in a loop) and want prefix/suffix support.

String.repeat(): Java 11+

repeat(n), added in Java 11, returns a new string consisting of the receiver repeated n times. Calling it with 0 returns an empty string; a negative count throws IllegalArgumentException. It is clean and readable for building separator lines, padding strings, or generating test data, eliminating the old idiom of new String(new char[n]).replace('\0', c). It also works on multi-character strings, making it useful for pattern repetition.

Java

// String.repeat(int count) — returns the string repeated count times
String dashes = "-".repeat(20);
System.out.println(dashes); // --------------------

// Useful for padding or building separators
String title = "Results";
String line   = "=".repeat(title.length());
System.out.println(title);
System.out.println(line); // =======

// Repeat multi-character strings
String block = "ab".repeat(4);
System.out.println(block); // abababab

// Zero count returns empty string
System.out.println("x".repeat(0)); // ""

// Negative count throws IllegalArgumentException
// "x".repeat(-1); // throws IllegalArgumentException

// Practical use: indent levels
String indent = "  "; // 2 spaces
for (int level = 0; level <= 3; level++) {
    System.out.println(indent.repeat(level) + "level " + level);
}
// level 0
//   level 1
//     level 2
//       level 3

// Building a simple ASCII table border
int cols = 5;
String border = ("+" + "-".repeat(10)).repeat(cols) + "+";
System.out.println(border);
// +----------+----------+----------+----------+----------+

// Pre-Java 11 equivalent
// String old = new String(new char[n]).replace('\0', 'x');
// Or: IntStream.range(0, n).mapToObj(i -> "x").collect(Collectors.joining())

Note: Before Java 11, there was no built-in repeat(). Common workarounds were new String(new char[n]).replace('\0', c) or a stream pipeline. Since Java 11 is the current LTS baseline for most projects, prefer repeat() directly.

strip() vs trim(): Unicode-aware whitespace

trim() removes characters with code point <= '\u0020' (ASCII space and control characters). strip(), added in Java 11, uses Character.isWhitespace() which recognizes a broader set of Unicode whitespace including non-breaking spaces (\u00A0), em-spaces, and ideographic spaces. stripLeading() and stripTrailing() strip only one side. For any code dealing with internationalized or copy-pasted text, prefer strip(): trim() may silently leave Unicode whitespace that causes subsequent comparisons to fail.

Java

// trim() — removes ASCII control characters and spaces (\u0000–\u0020)
// strip() — removes all Unicode whitespace (Java 11+, uses Character.isWhitespace())

String plain = "  hello world  ";
System.out.println(plain.trim());  // "hello world"
System.out.println(plain.strip()); // "hello world"

// The difference: Unicode whitespace characters
// \u2003 is an em-space — Unicode whitespace but NOT ASCII \u0020
String unicode = "\u2003hello\u2003";
System.out.println("[" + unicode.trim()  + "]"); // [\u2003hello\u2003] — NOT removed
System.out.println("[" + unicode.strip() + "]"); // [hello]              — removed

// stripLeading() — only leading whitespace
String leading = "   hello   ";
System.out.println("[" + leading.stripLeading() + "]"); // [hello   ]

// stripTrailing() — only trailing whitespace
System.out.println("[" + leading.stripTrailing() + "]"); // [   hello]

// Practical use: normalising user input
String userInput = "  \t Alice \n  ";
String cleaned = userInput.strip();
System.out.println("[" + cleaned + "]"); // [Alice]

// When to use trim() vs strip()
// - New code: always prefer strip() — Unicode-aware and clearly named
// - Existing codebases: trim() is fine for pure ASCII input
// - CSV/TSV parsing with tab-separated values — use strip() to handle tabs

// Checking if stripped result is empty: combine with isBlank()
String ws = "   \t  \n  ";
System.out.println(ws.strip().isEmpty()); // true
System.out.println(ws.isBlank());         // true (Java 11+ shorthand)

Do not use trim() on strings that may contain non-ASCII whitespace such as data from international user inputs, HTML entities decoded to Unicode spaces, or text copied from word processors. Use strip() instead.

chars() and codePoints() streams

chars() returns an IntStream of UTF-16 code unit values: cast each int to char for character operations. codePoints() returns an IntStream of Unicode code points, which correctly handles supplementary characters (emoji, rare CJK characters) that are stored as two char values (a surrogate pair) in UTF-16. For most ASCII and Latin text, both methods give the same results. Use codePoints() whenever the input may contain characters outside the Basic Multilingual Plane (U+FFFF and above). Both streams enable stream-pipeline operations like character frequency counts, filtering, and transformation.

Java

// chars() — returns an IntStream of char values (UTF-16 code units)
String s = "Hello";
s.chars().forEach(c -> System.out.print((char) c + " ")); // H e l l o

// Count vowels using a stream
long vowels = "Programming".chars()
    .filter(c -> "aeiouAEIOU".indexOf(c) >= 0)
    .count();
System.out.println("Vowels: " + vowels); // Vowels: 3

// Convert chars stream back to String
String upper = "hello".chars()
    .map(Character::toUpperCase)
    .collect(StringBuilder::new, (sb, c) -> sb.append((char) c), StringBuilder::append)
    .toString();
System.out.println(upper); // HELLO

// Check if all characters are digits
boolean allDigits = "12345".chars().allMatch(Character::isDigit); // true
boolean hasLetter = "abc12".chars().anyMatch(Character::isLetter); // true

// codePoints() — returns an IntStream of Unicode code points
// Handles supplementary characters (outside BMP, code points > 0xFFFF)
// A single supplementary char is 2 chars (a surrogate pair) in UTF-16
String emoji = "Hello \uD83D\uDE00"; // \uD83D\uDE00 = 😀 (U+1F600)

System.out.println("chars length:       " + emoji.chars().count());      // 8 (6 + 2 surrogates)
System.out.println("codePoints length:  " + emoji.codePoints().count()); // 7 (6 + 1 emoji)

// Count actual characters (code points), not UTF-16 code units
long cpCount = emoji.codePoints().count();

// Collect code points back to string safely
String rebuilt = emoji.codePoints()
    .collect(StringBuilder::new,
             StringBuilder::appendCodePoint,
             StringBuilder::append)
    .toString();
System.out.println(rebuilt.equals(emoji)); // true

// Get distinct characters sorted
"banana".chars()
    .distinct()
    .sorted()
    .mapToObj(c -> String.valueOf((char) c))
    .forEach(System.out::print); // aban (sorted unique chars)
System.out.println();

chars() works correctly for the vast majority of text. Use codePoints() when processing text that may contain emoji or other supplementary Unicode characters (code points above U+FFFF), because those are stored as two char values (a surrogate pair) and chars() would split them.

contains(), startsWith(), endsWith()

These three methods return a plain boolean and are all case-sensitive. contains() scans the entire string for the given CharSequence. startsWith() checks the beginning; its two-argument form startsWith(prefix, offset) checks starting from a specific character position. endsWith() checks the end of the string. None of them support case-insensitive matching directly: convert both sides to the same case first, or use regionMatches(ignoreCase, ...) for substring comparison at a given offset.

Java

String s = "The quick brown fox jumps over the lazy dog";

// contains(CharSequence) — case-sensitive substring check
System.out.println(s.contains("fox"));    // true
System.out.println(s.contains("Fox"));    // false
System.out.println(s.contains(""));       // true — empty string is always contained

// Case-insensitive contains
String lower = s.toLowerCase();
System.out.println(lower.contains("FOX".toLowerCase())); // true

// startsWith(prefix) / endsWith(suffix)
String filename = "report_2025.csv";
System.out.println(filename.startsWith("report")); // true
System.out.println(filename.endsWith(".csv"));      // true
System.out.println(filename.endsWith(".txt"));      // false

// startsWith(prefix, toffset) — check from an offset
String url = "https://example.com/path";
System.out.println(url.startsWith("example.com", 8)); // true (skip "https://")

// Practical: file type checks
List<String> files = List.of("data.csv", "readme.md", "config.json", "App.java");
List<String> javaFiles = files.stream()
    .filter(f -> f.endsWith(".java"))
    .collect(Collectors.toList());
System.out.println(javaFiles); // [App.java]

// Check multiple prefixes — no built-in, use stream
String[] prefixes = {"http://", "https://"};
boolean isUrl = Arrays.stream(prefixes).anyMatch(url::startsWith);
System.out.println(isUrl); // true

// indexOf / lastIndexOf — when you need position too
int idx = s.indexOf("fox");        // 16
int last = s.lastIndexOf("the");   // 31 (second "the")
int notFound = s.indexOf("cat");   // -1

// regionMatches — substring comparison at given offsets
// regionMatches(ignoreCase, toffset, other, ooffset, len)
boolean match = "HelloWorld".regionMatches(true, 0, "HELLO", 0, 5);
System.out.println(match); // true

toUpperCase() / toLowerCase() with Locale

The no-argument toUpperCase() and toLowerCase() use the JVM's default locale, which causes portability bugs. The most famous example is the Turkish locale: "i".toUpperCase() produces "İ" (dotted capital I) rather than "I", breaking any code that compares the result against an ASCII string. Always pass Locale.ENGLISH or Locale.ROOT when the result will be stored, compared, used as a map key, or transmitted. Use the user's locale only when the result is strictly for display.

Java

// Basic case conversion
String s = "Hello World";
System.out.println(s.toUpperCase()); // HELLO WORLD
System.out.println(s.toLowerCase()); // hello world

// Always pass a Locale for locale-sensitive characters
// Classic example: Turkish 'i' — toUpperCase() in Turkish locale yields 'İ' (dotted I)
// but in English locale it yields 'I' (undotted I)
String dotless = "title";
System.out.println(dotless.toUpperCase(Locale.ENGLISH));  // TITLE
System.out.println(dotless.toUpperCase(new Locale("tr"))); // TİTLE  ← note İ

// Always use Locale.ROOT for programmatic/technical strings (URLs, keys, SQL)
String header = "Content-Type";
System.out.println(header.toLowerCase(Locale.ROOT)); // content-type

// Locale.ROOT is culture-neutral — safest for non-display strings
String key = "UserName";
String normalised = key.toLowerCase(Locale.ROOT); // username

// Avoid the no-arg overloads for anything that will be stored, indexed, or compared
// Bad:  str.toUpperCase()          — uses JVM default locale, non-portable
// Good: str.toUpperCase(Locale.US) — explicit, predictable

// Capitalizing the first letter (no built-in)
String word = "hello";
String capitalised = word.isEmpty()
    ? word
    : Character.toUpperCase(word.charAt(0)) + word.substring(1);
System.out.println(capitalised); // Hello

// Title-case each word
String sentence = "the quick brown fox";
String titleCase = Arrays.stream(sentence.split(" "))
    .map(w -> Character.toUpperCase(w.charAt(0)) + w.substring(1))
    .collect(Collectors.joining(" "));
System.out.println(titleCase); // The Quick Brown Fox

Never call toUpperCase() or toLowerCase() without a Locale argument on strings that are used programmatically (map keys, SQL identifiers, HTTP headers, file extensions). Always use Locale.ROOT for such values and the user's Locale only for display text.

isBlank(): Java 11+

isBlank(), added in Java 11, returns true for empty strings and for strings containing only Unicode whitespace (using the same definition as strip()). isEmpty() only returns true for zero-length strings: it returns false for a string of spaces. isBlank() is the right check when validating that a user entered something meaningful. It does not allocate a new string (unlike strip().isEmpty()), making it both more correct and more efficient.

Java

// isBlank() — returns true if the string is empty or contains only whitespace
// Uses the same Unicode definition as strip() (Character.isWhitespace())
System.out.println("".isBlank());          // true
System.out.println("   ".isBlank());       // true
System.out.println("  \t\n  ".isBlank()); // true
System.out.println("  hi  ".isBlank());   // false
System.out.println("0".isBlank());         // false

// isBlank() vs isEmpty()
String empty  = "";
String spaces = "   ";
System.out.println(empty.isEmpty());   // true
System.out.println(spaces.isEmpty());  // false
System.out.println(empty.isBlank());   // true
System.out.println(spaces.isBlank());  // true — isEmpty() would miss this

// Filtering blank lines from a text block
String text = """
    line one

    line two

    line three
    """;

List<String> nonBlank = text.lines()
    .filter(line -> !line.isBlank())
    .collect(Collectors.toList());
System.out.println(nonBlank); // [line one, line two, line three]

// Validate user input — null-safe pattern
static boolean hasValue(String s) {
    return s != null && !s.isBlank();
}
System.out.println(hasValue(null));    // false
System.out.println(hasValue(""));      // false
System.out.println(hasValue("  "));   // false
System.out.println(hasValue("text")); // true

// lines() — Java 11+ — splits on line terminators, returns Stream<String>
// Handles \n, \r\n, \r without regex
long lineCount = "one\ntwo\r\nthree\rfour".lines().count();
System.out.println(lineCount); // 4

// Pre-Java 11 equivalent of isBlank()
// str.trim().isEmpty()  — but trim() misses Unicode whitespace
// str.strip().isEmpty() — correct, but requires Java 11 anyway

isBlank() is the idiomatic Java 11+ test for "has no meaningful content". Prefer it over trim().isEmpty() (which misses Unicode spaces) and over calling strip().isEmpty() (two allocations). isBlank() performs the check without allocating a new String.

Contents

String.join() with delimiter and Iterable

String.repeat(): Java 11+

strip() vs trim(): Unicode-aware whitespace

chars() and codePoints() streams

contains(), startsWith(), endsWith()

toUpperCase() / toLowerCase() with Locale

isBlank(): Java 11+

Related articles