Strings

substring(begin, end) returns the part of the string from begin up to but not including end. The original string is unchanged because strings are immutable; you get a new string back.

Java Strings are immutable, so each + creates a brand-new String object. In a loop that copies the text over and over, which is slow and wasteful. StringBuilder edits one mutable buffer in place, so it is much faster.

The + operator joins two strings into a new string. Because String objects can't be changed, every + makes a brand-new String holding the combined text; the originals stay untouched.

== checks whether two String variables point to the same object in memory. equals() checks whether the two strings contain the same characters. To compare text, always use equals().

An immutable String can never change after it is created. Methods like concat or replace do not edit the original; they build and return a brand-new String. Java made String immutable for safety, sharing, and speed.

A String keeps its characters in a private array inside the String object. Originally that was a char array with two bytes per character. The String is immutable, so the array never changes after the String is created.

A string literal like "hi" is stored in a shared pool, so equal literals point to the same object. new String("hi") always makes a brand-new object on the heap, separate from the pool, even if the text is identical.

A text block is a multi-line string literal that starts and ends with three double-quotes ("""). It lets you write text spanning several lines without escaping every newline or quote.

split breaks a string into an array of pieces around a delimiter. The delimiter is a regex, not plain text, and by default empty pieces at the end of the result are dropped.

They have the same API and do the same job: build strings in a mutable buffer. StringBuffer's methods are synchronized (thread-safe but slower); StringBuilder's are not (faster). Use StringBuilder by default; use StringBuffer only when one instance is shared across threads.

The + you write is not a real method on String. The compiler turns it into bytecode that actually builds the joined string. Older Java used a StringBuilder behind the scenes; modern Java uses a special hook called invokedynamic.

Because strings never change, Java can safely store one shared copy of each literal in a pool and reuse it. Two equal literals are the same object. But new String("x") forces a separate object on the heap, even though its text is equal.

Since Java 9, String stores text in a byte array instead of a char array, with a small flag saying whether the bytes are Latin-1 (one byte per char) or UTF-16 (two bytes). Pure-ASCII text now uses half the memory.

The compiler removes the common leading whitespace shared by every non-blank line and the closing delimiter line. So you can indent the block to match your code, and that indentation is dropped from the result.

Every String operation creates a new String, so building one piece-by-piece with '+' in a loop is slow because it makes many throwaway strings. Use StringBuilder to build in a loop; it edits a buffer in place.

Each + in a loop makes a whole new string and copies all the characters so far. Over many iterations that copying gets very expensive. Use a StringBuilder and append in the loop, then call toString() once at the end.

Mutating methods like append, insert, and reverse change the builder in place and then return the same builder object (this). Because they return the builder, you can chain calls one after another, like sb.append("a").append("b").reverse().

String.format() builds a string from a template with placeholders like %s and %d filled by arguments. String.join() glues several strings together with a separator between them.

If you join strings that are all known at compile time (literals or final constants), the compiler joins them itself and stores the single finished string. No work happens at runtime, and the result is a pooled, interned string literal.

equals() answers a yes/no question: are two strings the same text? compareTo() answers an ordering question: which comes first alphabetically. It returns a negative number, zero, or a positive number, and is what sorting uses to put strings in order.

The string pool is a cache of String objects that Java reuses for identical string literals. Because identical literals share one pooled object, == returns true for them. Strings built at runtime are not pooled, so == returns false for them.

Since a String never changes, many threads can read it at once with no locks — there is nothing to corrupt. And because its characters are fixed, its hash code is computed once and stored, so repeated hashing (e.g. as a HashMap key) is cheap and consistent.

intern() looks in the shared string pool for a string with the same value. If one is there, it returns that pooled object; if not, it adds the current string to the pool and returns it. The result is a canonical reference equal-valued strings can share.

If the closing """ is on its own line, the result ends with a newline; put the closing """ right after the last character to drop it. The \s escape preserves a trailing space, and a trailing backslash joins a line to the next (no newline).

chars() gives a stream of UTF-16 code units, so a character stored as two units (like an emoji) shows up as two values. codePoints() gives a stream of full Unicode characters, so each emoji is one value.

A StringBuilder wraps a char array with a default capacity of 16. When you append past capacity it allocates a bigger array (about double plus two) and copies everything over. If you know roughly the final size, pass it to the constructor so it avoids those reallocations.

Use + for a few fixed pieces in one statement. Use StringBuilder when building up text in a loop. Use String.join or Collectors.joining when gluing a collection together with a separator.

HashMap finds a key by its hashCode() to pick a bucket, then uses equals() to match within that bucket. String overrides both consistently, so lookups work by content. If maps used == they would fail whenever a key was rebuilt at runtime instead of being the same object.

Every transforming method returns a brand-new String and leaves the original alone. Doing this repeatedly (e.g. building text with + in a loop) creates many throwaway objects, so use StringBuilder for heavy building.