Model Answer: "String immutability provides several benefits: 1) Security — strings are used as class names, file paths, network URLs; mutation could corrupt these. 2) Thread safety — immutable strings need no synchronization. 3) String pooling — immutability allows interning and memory sharing without fear of modification. 4) HashMap/HashSet keys — immutability ensures hash code remains stable. 5) Performance — the JVM can cache String objects and optimize operations. Once a String is created, its character sequence cannot change.

Model Answer: "String is immutable — every modification creates a new object. StringBuilder is mutable and designed for single-threaded string building — append, insert, reverse operations modify the internal buffer in place with better performance. StringBuffer is the thread-safe version of StringBuilder — all methods are synchronized, making it safe for multi-threaded use but slower. Use StringBuilder for most new code; use StringBuffer only when sharing the buffer across threads.

Model Answer: "String interning places literal strings in a shared pool (String.intern()). When you intern a string, if an equivalent literal already exists in the pool, the JVM returns that reference; otherwise the string is added and its reference returned. Use intern() when: you have many identical strings and want to save memory; you need to compare strings using == for performance. Avoid intern() when: the strings are numerous and short-lived (adds to pool pressure); you're not comparing many equal strings. In modern JVMs with G1GC, interned strings are moved to heap, reducing PermGen issues.

Model Answer: "String.split() with no limit (or limit > 0) discards trailing empty strings. For example, "a,b,c,".split(",") returns ["a", "b", "c"] — the trailing empty string is dropped. To preserve trailing empties, use a negative limit: "a,b,c,".split(",", -1) returns ["a", "b", "c", ""]. This behavior mirrors the Unix tool awk and prevents empty tokens at the end of lines from being silently lost.

Model Answer: "In modern JDKs (7u6+), substring() creates a new char array containing only the requested characters — no memory leak. However, before this fix, substring() in JDK 6 (and earlier) created a new String object but shared the parent String's underlying char array. The new String's offset/length pointed into the parent's array. This meant holding onto a small substring kept the entire large char array alive in memory — a common cause of OutOfMemoryErrors when processing large strings and keeping small substrings. Always prefer substring over other extraction methods for memory efficiency in modern JVMs.

Model Answer: "indexOf() searches from the beginning of the string toward the end, returning the first index where the substring is found, or -1 if not found. lastIndexOf() searches from the end toward the beginning, returning the last (rightmost) index of the substring. Both support an optional start position parameter. Use indexOf() when you want the first occurrence; use lastIndexOf() when you want the last occurrence, such as finding the final path separator in a file path (path.lastIndexOf('/')). Both perform linear O(n) searching through the string's character array.

Model Answer: "Use matches() with regex "\\d+" for simple cases, but for performance-sensitive code use a manual loop: public static boolean isNumeric(String s) { for (int i = 0; i < s.length(); i++) { if (!Character.isDigit(s.charAt(i))) return false; } return true; }. This avoids regex compilation overhead and is typically 3-5x faster for repeated checks. Alternatively, use Character.isDigit() in a loop with early exit. For empty strings, the manual loop returns true (no digits found to contradict); if you need false for empty, add a length check. Apache Commons Lang StringUtils.isNumeric() handles additional Unicode digit categories.

Model Answer: "String has four replace methods: replace(char, char) replaces all occurrences of a character — returns a new String. replace(CharSequence, CharSequence) replaces all occurrences of a substring. replaceFirst(String regex) replaces only the first match of a regex pattern. replaceAll(String regex, String replacement) replaces all matches of a regex. All return a new String (String is immutable) and perform linear-time scanning for simple character/substring replacements. For regex-based replacements, compilation happens on each call — consider using Pattern.compile() once and reusing the matcher for better performance in loops.

Model Answer: "String internally stores characters in UTF-16 encoding (char array), where each char is a 16-bit value. For characters in the Basic Multilingual Plane (BMP, U+0000 to U+FFFF), one char is sufficient. For supplementary characters (Unicode code points beyond U+FFFF, like many emoji), two chars are needed — a surrogate pair. Methods like length() return the number of chars, not code points. For correct character counting, use codePointCount(0, length()). Similarly, charAt() returns a single char which may be half of a supplementary character. Use codePointAt() for proper supplementary character handling.

Model Answer: "trim() removes leading and trailing ASCII whitespace (code points <= U+0020). It returns a new String with these characters removed. Limitations: it does not remove non-ASCII whitespace (e.g., NBSP U+00A0, BOM U+FEFF), it only looks at char values <= 32, and it cannot distinguish between intentional zero-width space and unwanted whitespace. For Unicode-aware trimming, use strip() (Java 11+) which uses Character.isWhitespace() and handles Unicode properly. stripLeading() and stripTrailing() remove from one side only. For HTML/entity whitespace, use a regex or a library like Apache Commons Text.

Model Answer: "Use toLowerCase(Locale.getDefault()) or toUpperCase(Locale.US) to specify locale. The default locale-sensitive versions can produce unexpected results in Turkish locale — for example, 'i'.toUpperCase() in Turkish locale produces 'İ' (dotted I), not 'I'. For ASCII-only strings, explicitly use Locale.ROOT or Locale.US: str.toUpperCase(Locale.US). The toLowerCase() and toUpperCase() without locale use the JVM's default locale, which can change between environments and cause subtle bugs in internationalized applications.

Model Answer: "String.split() uses regex internally — it compiles a pattern and matches against the string, which has overhead for simple delimiters. StringTokenizer is purpose-built for simple delimiter-based splitting and is generally faster when you only need basic tokenization. StringTokenizer also handles empty tokens more predictably. For simple single-character delimiters, String.indexOf() in a loop can be faster than both. For regex-based splitting (multiple delimiters, patterns), split() is more convenient. Performance difference is negligible for most applications; use whichever is more readable for your use case.

Model Answer: "String's hashCode is computed as: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1], where s[i] is the character value and n is the string length. The constant 31 was chosen empirically as a good compromise between spread and performance (multiplication by 31 can be optimized to (i << 5) - i). This hashing is used by the JVM for String keys in HashMap/HashSet. Because Strings are immutable, the hashCode is cached after first computation — subsequent calls return the cached value. This makes String a good HashMap key because hashCode is stable and caching reduces repeated computation.

Model Answer: "Null strings require defensive handling: 1) Null check before use: if (str != null) { ... }. 2) Use String.valueOf(obj) which returns "null" for null rather than throwing NPE. 3) Use Objects.requireNonNull() to fail fast on null input. 4) Use Objects.toString() with a default: Objects.toString(str, "default"). 5) In equals comparisons, put the literal first: "literal".equals(str) — this is null-safe (won't throw NPE) and also guards against the literal being mistakenly null. 6) Apache Commons Lang StringUtils.defaultString() and related utilities handle null gracefully.

Model Answer: "String.format() uses a format string with printf-style specifiers (%s, %d, %.2f) and returns a formatted string. Use it for: complex formatted output (tables, aligned columns), internationalized messages (with MessageFormat), and when format is defined once and applied to multiple values. Avoid it for: simple concatenations in non-performance-critical paths, or in tight loops (format parsing has overhead). For simple cases like "Hello " + name, concatenation is clearer and the JIT compiler optimizes adjacent string concatenations into StringBuilder internally. Profile before replacing concatenation with format calls in hot paths.

Model Answer: "The String(byte[], charset) constructor decodes the byte array using the specified charset, throwing UnsupportedEncodingException if the charset is not supported. Always specify a charset explicitly: new String(bytes, StandardCharsets.UTF_8). Without a charset, new String(bytes) uses the JVM's default charset, which varies by platform and locale — a common source of encoding bugs. Similarly, getBytes(charset) should be used instead of getBytes() for consistent encoding. For binary data in strings (Base64, etc.), use proper encoding utilities rather than this constructor.

Model Answer: "equals() compares character-by-character (O(n) where n is string length) after a quick length check. == compares references — fast O(1) if both point to the same object, but misleading for value comparison. For interned strings from the pool, == may return true for equal literals because they share references. For Strings created with new String(), == always returns false for separate objects even with identical content. Always use equals() for value comparison. The JIT can optimize repeated equals() calls on the same strings by recognizing patterns, but reference equality is not reliable for value semantics.

Model Answer: "For a known small number of strings, + is readable and the JIT optimizes it to StringBuilder internally. For unknown or large numbers, explicitly use StringBuilder: StringBuilder sb = new StringBuilder(initialCapacity); for (String s : strings) { sb.append(s); } return sb.toString();. Set initial capacity to avoid resizing: new StringBuilder(sum of lengths). For streams, use Collectors.joining() which uses StringBuilder internally. Avoid StringBuffer unless you need thread safety (synchronized). For CSV/character-separated output, StringBuilder with manual append is faster than split+join approaches.

Model Answer: "isEmpty() (Java 6+) returns true only if length() == 0 — it does not check for whitespace. isBlank() (Java 11+) returns true if the string is empty OR contains only whitespace characters (according to Character.isWhitespace()). Example: " ".isEmpty() is false, but " ".isBlank() is true. "".isBlank() is true (empty is blank by definition). For input validation, isBlank() is usually what you want — it treats spaces, tabs, and other whitespace as empty. For checking if a string has actual content (non-whitespace characters), use isBlank() or trim + isEmpty depending on your requirements.

Model Answer: "String implements Comparable<String> with lexicographic (dictionary) comparison based on Unicode code point values. compareTo() compares character-by-character, stopping at the first difference or when one string is exhausted. Shorter strings compare as "less than" longer strings when the longer starts with the shorter: "ab".compareTo("abc") returns negative. This is NOT case-insensitive — 'A' (65) < 'a' (97). For case-insensitive or locale-aware comparison, use String.CASE_INSENSITIVE_ORDER or Collator.getInstance(). String comparisons are used in sorting algorithms and TreeSet/TreeMap ordering.