ReviseAlgo Logo

Strings

String Methods

Explore core string manipulation APIs (substrings, replacements, splits, strips) and performance implications.

Interview: Focuses on substring memory references, strip() vs trim(), regex overheads in split(), and loop concatenations.

Last Updated: June 13, 2026 • 10 min read

The String class provides a rich set of methods for text manipulation. Because Strings are immutable, none of these methods modify the original object. Instead, they always return a new, distinct String object containing the result. Understanding the performance characteristics of these APIs is critical for writing efficient Java code.

Core Idea

String methods return new String objects. Modifying operations duplicate backing character arrays instead of changing the original string.

Why It Matters

Using methods like trim() or split() incorrectly can cause memory leaks or performance bottlenecks in large data processing pipelines.

Interview Lens

Compares trim() vs strip(), analyzes substring memory behaviors, and evaluates splitting strategies.

Key API Behaviors

  • Substring (substring(begin, end)): In Java 6, substring shared the backing char[] of the parent string, creating a reference memory leak if a small substring kept a massive parent array in memory. In Java 7+, the method copies a new array segment, completely isolating the substring's memory.
  • Trim vs Strip (strip() Java 11+): trim() only removes characters with ASCII values less than or equal to U+0020 (the space character). strip() is Unicode-aware, removing all characters classified as whitespace by Character.isWhitespace() (such as the em-space or thin-space).
  • Split (split(regex)): Splits text using regular expressions. Because compiling regex is expensive, using split() in loops can be a bottleneck. For simple character separations, consider using index checks or custom parsers.

Concatenation Overhead in Loops

Using the + operator for string concatenation inside loops (e.g., s += data;) is a major anti-pattern.

Although the compiler optimizes simple concatenations by translating them to StringBuilder operations, doing so inside a loop creates a new StringBuilder instance on every iteration. This generates garbage on the heap, triggering frequent garbage collection pauses. Use a single, explicit StringBuilder outside the loop instead.

Common Pitfalls

  • Concatenating in Loops: Using the + operator inside loop bodies, causing GC performance degradation.
  • Using trim() for Unicode Text: Relying on trim() to clean user inputs in internationalized apps, leaving Unicode whitespace characters unremoved.
  • Regex Splitting on Plain Text: Using split() with complex regex for simple comma-separated values, causing unnecessary pattern compiling overhead.

Best Practices

  • Use strip() instead of trim() for cleaning whitespace to ensure Unicode compatibility.
  • Use an explicit StringBuilder for string accumulation inside loops.
  • Pre-compile patterns or use simple index splits when performance is critical.

Interview-Relevant Information

Q1: What is the difference between trim() and strip()?
Answer: trim() only removes leading and trailing characters with ASCII values less than or equal to 32 (space). strip() is Unicode-aware, identifying and removing all Unicode whitespace characters (such as \u2001) based on Character.isWhitespace().

Q2: Why was the substring() implementation changed in Java 7?
Answer: In Java 6 and earlier, substring() returned an object sharing the parent string's backing array to save memory. However, if a long-lived object referenced a small substring of a huge string, the entire parent array could not be garbage collected, causing memory leaks. Java 7 changed the method to copy a new array segment, isolating substring memory.

Quick Checklist

Can you distinguish trim() from strip(), explain substring memory isolation changes, analyze concatenation loops, and optimize regex split overheads? If yes, you understand string methods.

Use Cases

Cleaning Unicode user inputs securely in global web portals.

Assembling long CSV strings from large collections inside database exporters.

Common Mistakes

Performing string accumulations in loops using operators, creating memory garbage.

Relying on legacy trim() to process internationalized text inputs.