String Methods & Manipulation

String original = "Hello";
String upper = original.toUpperCase(); // new object "HELLO"
System.out.println(original);          // still "Hello" — unchanged!

// Compiler converts to StringBuilder (for simple expressions)
String result = "Hello" + " " + "World"; // compile-time constant → "Hello World"

// In a loop — DANGEROUS (pre-JDK 9)
String s = "";
for (int i = 0; i < 10000; i++) {
    s += i; // Creates a new String EVERY iteration → O(n^2)
}

String s = "Hello".concat(" World"); // Returns new String "Hello World"
// Slightly faster than + for single concat, but no advantage in loops
// Throws NullPointerException if argument is null!

StringBuilder sb = new StringBuilder(1024); // pre-size to avoid resizing
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString(); // Single String created at the end

String csv = String.join(", ", "apple", "banana", "cherry");
// "apple, banana, cherry"

List<String> items = List.of("one", "two", "three");
String joined = String.join(" | ", items);
// "one | two | three"

StringJoiner sj = new StringJoiner(", ", "[", "]"); // delimiter, prefix, suffix
sj.add("red").add("green").add("blue");
System.out.println(sj.toString()); // [red, green, blue]

// Empty value
StringJoiner empty = new StringJoiner(", ", "[", "]");
empty.setEmptyValue("NONE");
System.out.println(empty.toString()); // NONE

"".isEmpty();        // true — zero length
"".isBlank();        // true — zero length

"   ".isEmpty();     // false — has 3 chars
"   ".isBlank();     // true — only whitespace (Unicode-aware!)

"\t\n".isEmpty();    // false
"\t\n".isBlank();    // true — tabs and newlines are whitespace

String s = "  Hello  "; // Unicode thin space

s.trim();   // "  Hello  " — trim() only removes ASCII <= 32
s.strip();  // "Hello" — strip() removes ALL Unicode whitespace!

s.stripLeading();  // "Hello  "
s.stripTrailing(); // "  Hello"

"ha".repeat(3);      // "hahaha"
"-".repeat(40);      // "----------------------------------------"
"abc".repeat(0);     // ""

// Useful for padding
String padded = " ".repeat(Math.max(0, 10 - name.length())) + name;

String multiline = "line1\nline2\r\nline3\rline4";

multiline.lines()           // Stream<String>
    .filter(l -> !l.isBlank())
    .map(String::strip)
    .forEach(System.out::println);
// line1, line2, line3, line4 — handles ALL line terminators

String code = "public class Hello {\n    void main() {}\n}";

code.indent(4);
// "    public class Hello {\n        void main() {}\n    }\n"

// stripIndent() removes common leading whitespace (text block behavior)
String indented = "    Hello\n    World";
indented.stripIndent(); // "Hello\nWorld"

// Chain transformations functionally
String result = " Hello World "
    .transform(String::strip)
    .transform(String::toLowerCase)
    .transform(s -> s.replace(" ", "-"));
// "hello-world"

// Useful for pipeline-style processing
int length = "Hello".transform(String::length); // 5

// Instance method equivalent of String.format()
String msg = "Hello %s, you are %d years old".formatted("Alice", 30);
// "Hello Alice, you are 30 years old"

// Cleaner than static method when chaining
String json = """
    {
        "name": "%s",
        "age": %d
    }
    """.formatted(name, age);

String s = "Hello World Hello";

s.indexOf("Hello");          // 0
s.indexOf("Hello", 1);      // 12 (search from index 1)
s.lastIndexOf("Hello");     // 12
s.contains("World");        // true
s.startsWith("Hello");      // true
s.endsWith("Hello");        // true

// matches() checks ENTIRE string against regex
"12345".matches("\\d+");    // true
"abc123".matches("\\d+");   // false (not entirely digits)
"abc123".matches(".*\\d+"); // true

String s = "Hello World";

s.substring(6);       // "World" — from index 6 to end
s.substring(0, 5);   // "Hello" — from 0 (inclusive) to 5 (exclusive)

// Java 7u6+: substring() creates a NEW backing array (no memory leak)
// Pre-7u6: shared the original char[] — could cause memory leaks!

String s = "Hello";

s.charAt(0);         // 'H'
s.charAt(4);         // 'o'
// s.charAt(5);      // StringIndexOutOfBoundsException!

char[] chars = s.toCharArray(); // ['H','e','l','l','o'] — new array copy
chars[0] = 'J';                 // modifying array does NOT affect original String

"Hello".chars()                  // IntStream of char values
    .mapToObj(c -> (char) c)     // Stream<Character>
    .forEach(System.out::println);

// Count vowels
long vowels = "Hello World".chars()
    .filter(c -> "aeiouAEIOU".indexOf(c) >= 0)
    .count(); // 3

// Collect to String
String upper = "hello".chars()
    .map(Character::toUpperCase)
    .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
    .toString(); // "HELLO"

// For strings with emoji/surrogate pairs, use codePoints() not chars()
String emoji = "Hello 🌍";  // earth emoji is 2 chars (surrogate pair)

emoji.chars().count();       // 8 (counts surrogates separately!)
emoji.codePoints().count();  // 7 (correct — counts emoji as 1)

String s = "aabbcc";

s.replace('a', 'x');          // "xxbbcc" — replaces ALL occurrences of char
s.replace("bb", "B");         // "aaBcc" — replaces ALL occurrences of CharSequence

String s = "Hello   World   Java";

s.replaceAll("\\s+", " ");    // "Hello World Java" — regex: one or more whitespace
s.replaceAll("[aeiou]", "*"); // "H*ll*   W*rld   J*v*"

// Backreferences
"2024-01-15".replaceAll("(\\d{4})-(\\d{2})-(\\d{2})", "$2/$3/$1");
// "01/15/2024"

"aaa bbb aaa".replaceFirst("aaa", "XXX"); // "XXX bbb aaa"

String csv = "apple,banana,,cherry";

csv.split(",");       // ["apple", "banana", "", "cherry"] — keeps empty strings
csv.split(",", 3);   // ["apple", "banana", ",cherry"] — limit to 3 parts
csv.split(",", -1);  // ["apple", "banana", "", "cherry"] — keeps trailing empties

// Regex gotcha — dot and pipe need escaping
"a.b.c".split("\\.");        // ["a", "b", "c"]
"a|b|c".split("\\|");       // ["a", "b", "c"]

// Split on multiple delimiters
"a,b;c:d".split("[,;:]");   // ["a", "b", "c", "d"]

// Static join
String result = String.join("-", "2024", "01", "15"); // "2024-01-15"

// With collection
List<String> parts = List.of("usr", "local", "bin");
String path = String.join("/", parts); // "usr/local/bin"

// StringJoiner with prefix/suffix
StringJoiner sj = new StringJoiner(", ", "SELECT ", " FROM users");
sj.add("name").add("email").add("age");
// "SELECT name, email, age FROM users"

String result = List.of("alpha", "beta", "gamma")
    .stream()
    .collect(Collectors.joining(", ", "[", "]"));
// "[alpha, beta, gamma]"

String s1 = "Hello";
String s2 = "hello";

s1.equals(s2);               // false
s1.equalsIgnoreCase(s2);     // true
s1.compareTo(s2);            // negative (H < h in ASCII)
s1.compareToIgnoreCase(s2);  // 0 (equal ignoring case)

// contentEquals — compare String with StringBuilder
StringBuilder sb = new StringBuilder("Hello");
s1.contentEquals(sb);        // true

// regionMatches — compare substring regions
"Hello World".regionMatches(6, "World Cup", 0, 5); // true ("World" == "World")
"Hello World".regionMatches(true, 6, "WORLD Cup", 0, 5); // true (ignore case)

// Common format specifiers
String.format("%s is %d years old", "Alice", 30);   // "Alice is 30 years old"
String.format("%10s", "hi");                         // "        hi" (right-aligned)
String.format("%-10s", "hi");                        // "hi        " (left-aligned)
String.format("%05d", 42);                           // "00042" (zero-padded)
String.format("%.2f", 3.14159);                      // "3.14"
String.format("%,d", 1000000);                       // "1,000,000"
String.format("%x", 255);                            // "ff" (hex)
String.format("%n");                                 // platform line separator

// Instance method — cleaner for text blocks
String template = "Name: %s, Age: %d";
String result = template.formatted("Bob", 25); // "Name: Bob, Age: 25"

// Source code
String result = "Hello " + name + ", age " + age;

// Pre-Java 9 bytecode: fixed StringBuilder strategy
new StringBuilder().append("Hello ").append(name).append(", age ").append(age).toString();

// Java 9+ bytecode: invokedynamic — JVM chooses optimal strategy
// JVM may use: byte[] concatenation, StringBuilder, or even intrinsics
// depending on runtime profiling!

// Internal representation (simplified)
public final class String {
    private final byte[] value;  // actual character data
    private final byte coder;    // 0=LATIN1, 1=UTF16

    // "Hello" → byte[5] {72,101,108,108,111}, coder=0 (LATIN1, 5 bytes)
    // "Hello 🌍" → byte[16] (UTF16 encoding, 16 bytes for 7 code points)
}

// Method 1: StringBuilder (simplest)
public String reverse(String s) {
    return new StringBuilder(s).reverse().toString();
}

// Method 2: Two-pointer (manual, shows understanding)
public String reverse(String s) {
    char[] chars = s.toCharArray();
    int left = 0, right = chars.length - 1;
    while (left < right) {
        char temp = chars[left];
        chars[left++] = chars[right];
        chars[right--] = temp;
    }
    return new String(chars);
}

public boolean isPalindrome(String s) {
    // Clean: remove non-alphanumeric, lowercase
    String clean = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
    int left = 0, right = clean.length() - 1;
    while (left < right) {
        if (clean.charAt(left++) != clean.charAt(right--)) return false;
    }
    return true;
}

// One-liner (less efficient but concise)
public boolean isPalindrome(String s) {
    String clean = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
    return clean.equals(new StringBuilder(clean).reverse().toString());
}

// Method 1: Sorting — O(n log n)
public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) return false;
    char[] a = s.toCharArray(), b = t.toCharArray();
    Arrays.sort(a);
    Arrays.sort(b);
    return Arrays.equals(a, b);
}

// Method 2: Frequency count — O(n) time, O(1) space (fixed 26 chars)
public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) return false;
    int[] freq = new int[26];
    for (int i = 0; i < s.length(); i++) {
        freq[s.charAt(i) - 'a']++;
        freq[t.charAt(i) - 'a']--;
    }
    for (int count : freq) {
        if (count != 0) return false;
    }
    return true;
}

public List<String> permutations(String s) {
    List<String> result = new ArrayList<>();
    backtrack(s.toCharArray(), 0, result);
    return result;
}

private void backtrack(char[] chars, int start, List<String> result) {
    if (start == chars.length) {
        result.add(new String(chars));
        return;
    }
    for (int i = start; i < chars.length; i++) {
        swap(chars, start, i);
        backtrack(chars, start + 1, result);
        swap(chars, start, i); // backtrack
    }
}

private void swap(char[] chars, int i, int j) {
    char tmp = chars[i];
    chars[i] = chars[j];
    chars[j] = tmp;
}

public char firstNonRepeating(String s) {
    // LinkedHashMap preserves insertion order
    Map<Character, Integer> freq = new LinkedHashMap<>();
    for (char c : s.toCharArray()) {
        freq.merge(c, 1, Integer::sum);
    }
    for (Map.Entry<Character, Integer> e : freq.entrySet()) {
        if (e.getValue() == 1) return e.getKey();
    }
    return '\0'; // not found
}

// Java 8+ stream approach
public char firstNonRepeating(String s) {
    return s.chars()
        .mapToObj(c -> (char) c)
        .collect(Collectors.groupingBy(c -> c, LinkedHashMap::new, Collectors.counting()))
        .entrySet().stream()
        .filter(e -> e.getValue() == 1)
        .map(Map.Entry::getKey)
        .findFirst()
        .orElse('\0');
}

// Sliding window — O(n)
public int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> lastSeen = new HashMap<>();
    int maxLen = 0, start = 0;

    for (int end = 0; end < s.length(); end++) {
        char c = s.charAt(end);
        if (lastSeen.containsKey(c) && lastSeen.get(c) >= start) {
            start = lastSeen.get(c) + 1;
        }
        lastSeen.put(c, end);
        maxLen = Math.max(maxLen, end - start + 1);
    }
    return maxLen;
}