What String and Optional improvements came in Java 11?

• isBlank() returns true for empty strings AND whitespace-only strings. " ".isBlank() is true. " ".isEmpty() is false.
• strip() removes leading and trailing whitespace using Character.isWhitespace(), which handles Unicode whitespace like \u00A0. trim() only handles ASCII characters with code point <= 32.
• lines() returns a lazy Stream split on line terminators (\n, \r, \r\n).
• repeat(n) returns the string repeated n times: "=-".repeat(20) produces a separator line.
• Files.readString(Path) reads an entire file to a String. Files.writeString(Path, String) writes a String to a file.
• Optional.isEmpty() returns true when the Optional is empty: cleaner than !opt.isPresent().

How is isBlank different from isEmpty?

System.out.println("".isEmpty());       // true
System.out.println("".isBlank());       // true
System.out.println("   ".isEmpty());    // false -- has 3 spaces
System.out.println("   ".isBlank());    // true  -- only whitespace
System.out.println("Rajesh".isBlank()); // false

isBlank() is strictly better than isEmpty() for input validation because it catches whitespace-only strings.

How is strip different from trim?

// Non-breaking space (\u00A0): common in imported data
String imported = "\u00A0Rajesh\u00A0";
System.out.println(imported.trim());   // "\u00A0Rajesh\u00A0" -- not removed!
System.out.println(imported.strip());  // "Rajesh" -- removed!

| Method | Removes | Unicode-aware |
|--------|---------|---------------|
| `trim()` | chars <= 32 (ASCII) | No |
| `strip()` | `Character.isWhitespace()` | Yes |
| `stripLeading()` | Leading whitespace only | Yes |
| `stripTrailing()` | Trailing whitespace only | Yes |

How does lines() work?

String statement = "Date,Amount,Type\n2024-01-15,50000,NEFT\n2024-01-16,30000,UPI";

statement.lines()
    .skip(1)  // skip header
    .map(line -> line.split(",")[1])
    .forEach(amount -> System.out.println("Amount: " + amount));

Amount: 50000
Amount: 30000

lines() is lazy and handles \n, \r, and \r\n line terminators.

How does repeat work?

System.out.println("=-".repeat(30));  // separator line
System.out.println("*".repeat(5));    // *****
System.out.println("abc".repeat(0));  // "" (empty)

How do Files.readString and writeString simplify I/O?

import java.nio.file.*;

// Before Java 11
String old = new String(Files.readAllBytes(Path.of("template.txt")));

// Java 11
String modern = Files.readString(Path.of("template.txt"));
Files.writeString(Path.of("output.txt"), modern);

How is Optional.isEmpty useful?

import java.util.Optional;

Optional<String> account = Optional.empty();

// Before Java 11
if (!account.isPresent()) { /* handle empty */ }

// Java 11
if (account.isEmpty()) { /* handle empty */ }

What are common mistakes?

WRONG: Using trim() on Unicode data and missing non-breaking spaces.

WRONG: Using isEmpty() for validation and missing whitespace-only input.

WRONG: Using Files.readString on huge files that should be streamed.

// WRONG: loads entire 2GB file into memory
String huge = Files.readString(Path.of("transactions.csv"));

// CORRECT: lazy streaming for large files
try (var lines = Files.lines(Path.of("transactions.csv"))) {
    lines.filter(l -> l.contains("NEFT")).forEach(System.out::println);
}

What should a senior engineer know?

• Files.readString loads the entire file into memory. For files larger than available heap, use Files.lines(path) which is lazy and must be closed.
• strip() uses Character.isWhitespace(int) which considers Unicode whitespace categories. trim() uses a simple c <= ' ' check.
• lines() does not include trailing empty strings from the final line terminator.
• repeat(n) throws OutOfMemoryError if n is very large. It uses Arrays.copyOf internally for efficiency.