Java String Methods - == Bug Rejected Login Passwords

public class StringBasics {
    public static void main(String[] args) {

        // Creating a String — Java stores this in the String Pool
        String greeting = "Hello, World!";

        // length() — returns the total number of characters including spaces and punctuation
        int totalCharacters = greeting.length();
        System.out.println("Total characters: " + totalCharacters); // 13

        // charAt(index) — returns the single character at that position
        // Remember: indexing starts at 0, not 1
        char firstChar = greeting.charAt(0);  // 'H' is at position 0
        char seventhChar = greeting.charAt(7); // 'W' is at position 7
        System.out.println("First character: " + firstChar);   // H
        System.out.println("Seventh character: " + seventhChar); // W

        // Strings are immutable — this does NOT change the original
        String shoutyGreeting = greeting.toUpperCase();
        System.out.println("Original is unchanged: " + greeting);       // Hello, World!
        System.out.println("New uppercase string: " + shoutyGreeting);  // HELLO, WORLD!
    }
}

public class UsefulStringMethods {
    public static void main(String[] args) {

        String userEmail = "  support@thecodeforge.io  "; // Notice the leading/trailing spaces

        // trim() removes whitespace from both ends — critical for cleaning user input
        String cleanEmail = userEmail.trim();
        System.out.println("Cleaned email: '" + cleanEmail + "'");
        // Output: 'support@thecodeforge.io'

        // contains() — asks 'does this String contain this text?'
        boolean hasAtSymbol = cleanEmail.contains("@");
        System.out.println("Contains '@': " + hasAtSymbol); // true

        // endsWith() — great for validating file types or domains
        boolean isIoEmail = cleanEmail.endsWith(".io");
        System.out.println("Ends with .io: " + isIoEmail); // true

        // indexOf() — find where something first appears. Returns -1 if not found
        int atPosition = cleanEmail.indexOf("@");
        System.out.println("'@' found at index: " + atPosition); // 7

        // substring(start, end) — extract a slice of the String
        // Extract just the domain part: everything after the '@'
        String domain = cleanEmail.substring(atPosition + 1); // from index 8 to end
        System.out.println("Domain: " + domain); // thecodeforge.io

        // Extract just the username: everything before the '@'
        String username = cleanEmail.substring(0, atPosition); // from 0 up to (not including) '@'
        System.out.println("Username: " + username); // support

        // replace() — swap out characters or substrings. Returns a NEW String.
        String updatedDomain = domain.replace(".io", ".com");
        System.out.println("Updated domain: " + updatedDomain); // thecodeforge.com
        System.out.println("Original domain unchanged: " + domain); // thecodeforge.io

        // toLowerCase() / toUpperCase() — useful for case-insensitive comparisons
        String productCode = "PRD-4821-X";
        System.out.println("Lowercase code: " + productCode.toLowerCase()); // prd-4821-x

        // isEmpty() — true if the String has zero characters (length is 0)
        String emptyField = "";
        System.out.println("Is empty: " + emptyField.isEmpty()); // true

        // isBlank() — true if empty OR contains only whitespace (added in Java 11)
        String blankField = "   ";
        System.out.println("Is blank: " + blankField.isBlank()); // true
    }
}

public class StringComparison {
    public static void main(String[] args) {

        String language1 = "Java";          // stored in String Pool
        String language2 = "Java";          // Java reuses the same pool entry
        String language3 = new String("Java"); // forces a NEW object in heap memory

        // == compares memory addresses (references), NOT content
        System.out.println(language1 == language2);  // true  (same pool object)
        System.out.println(language1 == language3);  // false (different object in heap!)

        // .equals() compares the actual text content — use this for String comparison
        System.out.println(language1.equals(language2)); // true
        System.out.println(language1.equals(language3)); // true — same text, right answer!

        // Real-world scenario: validating a password reset answer
        String correctAnswer = "Fluffy";          // stored answer
        String userAnswer = "  fluffy  ";         // user typed with extra spaces and lowercase

        // Wrong approach — this would fail even though the answer is essentially correct
        boolean wrongCheck = correctAnswer.equals(userAnswer);
        System.out.println("Wrong check result: " + wrongCheck); // false

        // Right approach: clean the input first, then compare without case sensitivity
        boolean correctCheck = correctAnswer.equalsIgnoreCase(userAnswer.trim());
        System.out.println("Correct check result: " + correctCheck); // true

        // compareTo() — useful for sorting. Returns 0 if equal, negative if 'less', positive if 'greater'
        String alpha = "Apple";
        String beta = "Banana";
        int comparison = alpha.compareTo(beta);
        System.out.println("compareTo result: " + comparison); // negative number (Apple comes before Banana alphabetically)
    }
}

public class StringPoolDemo {
    public static void main(String[] args) {
        String literal = "Hello";
        String anotherLiteral = "Hello";  // same pool object
        String newObject = new String("Hello"); // different heap object

        System.out.println(literal == anotherLiteral);  // true (same pool reference)
        System.out.println(literal == newObject);      // false (different objects)

        // Using intern() to pull from pool
        String interned = newObject.intern();
        System.out.println(literal == interned);       // true (now same pool reference)

        // Practical use: normalising strings
        String[] names = {"Alice", "Bob", "ALICE", "alice"};
        for (String name : names) {
            if (name.equalsIgnoreCase("Alice")) {
                // Use intern() to get a canonical form
                String canonical = name.toLowerCase().intern();
                System.out.println("Canonical: " + canonical);
            }
        }
    }
}

import java.util.Arrays;

public class SplitJoinFormat {
    public static void main(String[] args) {

        // --- SPLIT ---
        // Imagine reading a CSV line from a file
        String csvLine = "Alice,30,Engineer,London";

        // split() breaks the String at every comma, returns a String array
        String[] fields = csvLine.split(",");

        System.out.println("Number of fields: " + fields.length); // 4
        System.out.println("Name: " + fields[0]);       // Alice
        System.out.println("Age: " + fields[1]);        // 30
        System.out.println("Role: " + fields[2]);       // Engineer
        System.out.println("City: " + fields[3]);       // London

        // --- JOIN ---
        // Now rebuild the CSV line with a different delimiter
        String tsvLine = String.join("\t", fields); // join with a tab character
        System.out.println("Tab-separated: " + tsvLine);
        // Alice    30    Engineer    London

        // Join a fresh set of values directly
        String fullName = String.join(" ", "James", "Arthur", "Morrison");
        System.out.println("Full name: " + fullName); // James Arthur Morrison

        // --- FORMAT ---
        // String.format() — cleaner than messy concatenation with +
        String name = "Maria";
        int orderCount = 5;
        double totalSpend = 149.99;

        // %s = String placeholder, %d = integer placeholder, %.2f = float with 2 decimal places
        String orderSummary = String.format(
            "Customer: %s | Orders: %d | Total Spend: $%.2f",
            name, orderCount, totalSpend
        );
        System.out.println(orderSummary);
        // Customer: Maria | Orders: 5 | Total Spend: $149.99

        // --- REPEAT (Java 11+) ---
        // Repeat a String N times — handy for formatting or testing
        String divider = "-".repeat(30);
        System.out.println(divider); // ------------------------------

        // --- TEXT BLOCK (Java 15+) ---
        // Write multi-line text without escape characters
        String jsonSnippet = """
                {
                  "name": "Maria",
                  "orders": 5
                }
                """;
        System.out.println(jsonSnippet);
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class JoiningDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // String.join() – simple and direct
        String joined1 = String.join(", ", names);
        System.out.println("String.join: " + joined1);
        // Alice, Bob, Charlie

        // Collectors.joining() – basic
        String joined2 = names.stream().collect(Collectors.joining(", "));
        System.out.println("Collectors.joining: " + joined2);
        // Alice, Bob, Charlie

        // With prefix and suffix
        String joined3 = names.stream().collect(Collectors.joining(", ", "[\", \"]\"));\n        System.out.println(\"With brackets: \" + joined3);\n        // [Alice, Bob, Charlie]\n\n        // Using with mapping – e.g., add a title\n        String joined4 = names.stream()\n            .map(name -> \"Mr. \" + name)\n            .collect(Collectors.joining(\" | \"));\n        System.out.println(\"Mapped: \" + joined4);\n        // Mr. Alice | Mr. Bob | Mr. Charlie\n\n        // Performance: for simple joins, String.join() is slightly faster\n        // For complex transformations, Collectors.joining() is cleaner\n    }\n}",
        "output": "String.join: Alice, Bob, Charlie\nCollectors.joining: Alice, Bob, Charlie\nWith brackets: [Alice, Bob, Charlie]\nMapped: Mr. Alice | Mr. Bob | Mr. Charlie"
      },
      "callout": {
        "type": "tip",
        "title": "When to Use Which",
        "text": "Use String.join() for simple delimiter joins on arrays/collections of strings. Use Collectors.joining() when you have a Stream pipeline and need prefix/suffix or want to combine multiple stream operations (filter, map) before joining."
      },
      "production_insight": "In a REST API endpoint that returned a list of error messages as a single comma-separated string, using Collectors.joining(\", \", \"[\", \"]\") made the code cleaner and easier to modify when the format changed to include a prefix. String.join() would have required manual concatenation.",
      "key_takeaway": "String.join() for simple collection-to-string joins. Collectors.joining() for stream-based joins with prefix/suffix and transformation."
    },
    {
      "heading": "String Concatenation Performance and StringBuilder",
      "content": "One of the most common tasks in Java is combining multiple strings into one. Beginners often use the + operator, and for simple cases that's fine. But inside loops, the + operator hides a performance trap.\n\nWhen you use + between Strings, the Java compiler internally transforms the expression into something like: new StringBuilder().append(a).append(b).toString(). For two or three strings, that's fine — you get a single StringBuilder and one final String. But in a loop, each iteration creates a new StringBuilder, appends, and creates a new String, then discards the old one. That's a lot of object creation and garbage collection.\n\nThe solution is to explicitly use StringBuilder outside the loop. StringBuilder is a mutable sequence of characters. You call append() repeatedly, and only call toString() once at the end. This avoids creating intermediate String objects.\n\nUse StringBuilder when building strings dynamically, especially in loops. For thread-safe scenarios, use StringBuffer — but StringBuilder is faster and preferred in single-threaded code.",
      "code": {
        "language": "java",
        "filename": "StringBuilderExample.java",
        "code": "public class StringBuilderExample {\n    public static void main(String[] args) {\n\n        // BAD: Using + in a loop — creates many intermediate Strings\n        String badResult = \"\";\n        for (int i = 0; i < 5; i++) {\n            badResult = badResult + \"item\" + i + \", \";\n        }\n        System.out.println(\"Bad: \" + badResult);\n\n        // GOOD: Use StringBuilder outside the loop\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < 5; i++) {\n            sb.append(\"item\").append(i).append(\", \");\n        }\n        String goodResult = sb.toString();\n        System.out.println(\"Good: \" + goodResult);\n\n        // For a small fixed number of strings, + is fine\n        String combined = \"Hello, \" + \"World!\" + \" This is fine.\";\n        System.out.println(combined);\n    }\n}",
        "output": "Bad: item0, item1, item2, item3, item4, \nGood: item0, item1, item2, item3, item4, \nHello, World! This is fine."
      },
      "callout": {
        "type": "info",
        "title": "When to Reach for StringBuilder",
        "text": "Use StringBuilder when you're building a string inside a loop, or when combining many parts conditionally. For a fixed number of string literals, the + operator is perfectly fine and actually optimized by the compiler."
      },
      "production_insight": "A log aggregation service was allocating 50 MB of Strings per minute simply by using + inside a loop to build log lines.\nEach iteration created throwaway StringBuilder instances, causing frequent GC pauses.\nSwitching to a single StringBuilder eliminated the allocation and reduced GC time by 80%.",
      "key_takeaway": "Use + for simple, fixed concatenations.\nUse StringBuilder for loops and dynamic builds.\nStringBuffer for thread safety — but StringBuilder is faster in single-threaded code."
    },
    {
      "heading": "Java 11+ String Methods: strip(), isBlank(), repeat(), lines(), and More",
      "content": "Java 11 introduced several new String methods that fill gaps in the standard toolkit. These are now widely used and should be part of every developer's mental library.\n\nstrip(), stripLeading(), stripTrailing() – Like trim() but Unicode-aware. trim() only removes ASCII whitespace (<= U+0020). strip() removes all Unicode whitespace, covering non-breaking spaces, Mongolian vowel separators, and others. In practice, strip() is safer for international text. stripLeading() and stripTrailing() remove whitespace from only one end.\n\nisBlank() – Returns true if the string is empty or contains only whitespace. This is a superset of isEmpty(). For example, \"\\n\\t  \".isBlank() returns true, while isEmpty() returns false. Use isBlank() when you want to reject strings that are effectively empty.\n\nrepeat(n) – Returns a string whose value is this string repeated n times. Useful for building dividers, padding, or test data.\n\nlines() – Returns a stream of lines extracted from the string, split by line terminators (\\n, \\r, \\r\\n). Great for processing multi-line text without manual splitting.\n\nOther notable additions: indent(n) adjusts indentation by n spaces; transform(f) applies a function to the string and returns the result; describeConstable() and resolveConstantDesc() for constant description.\n\nWhen running on Java 11 or later, prefer strip() over trim(), isBlank() over manual checks, and lines() over split(\"\\n\").",
      "code": {
        "language": "java",
        "filename": "Java11StringMethods.java",
        "code": "public class Java11StringMethods {\n    public static void main(String[] args) {\n\n        // --- strip(), stripLeading(), stripTrailing() ---\n        String unicodeWhitespace = \"\\u2003\\u2003Hello\\u2003\";  // em space (Unicode)\n        System.out.println(\"trim():       '\" + unicodeWhitespace.trim() + \"'\");       // keeps em spaces\n        System.out.println(\"strip():      '\" + unicodeWhitespace.strip() + \"'\");      // removes all Unicode whitespace\n        System.out.println(\"stripLeading(): '\" + unicodeWhitespace.stripLeading() + \"'\");\n        System.out.println(\"stripTrailing(): '\" + unicodeWhitespace.stripTrailing() + \"'\");\n\n        // --- isBlank() vs isEmpty() ---\n        String whitespaceString = \"\\n\\t  \";\n        System.out.println(\"isEmpty(): \" + whitespaceString.isEmpty()); // false\n        System.out.println(\"isBlank(): \" + whitespaceString.isBlank()); // true\n\n        // --- repeat(n) ---\n        String separator = \"-\".repeat(20);\n        System.out.println(\"Divider: \" + separator);\n\n        String threeTimes = \"Hi\".repeat(3);\n        System.out.println(\"Repeated: \" + threeTimes); // HiHiHi\n\n        // --- lines() ---\n        String multiline = \"Line1\\nLine2\\nLine3\";\n        multiline.lines()\n            .map(line -> \">> \" + line)\n            .forEach(System.out::println);\n        // >> Line1\n        // >> Line2\n        // >> Line3\n\n        // --- indent(n) (Java 12) ---\n        String indented = \"Hello\\nWorld\".indent(4);\n        System.out.println(indented);\n        //     Hello\n        //     World\n    }\n}",
        "output": "trim():       '\\u2003\\u2003Hello\\u2003'\nstrip():      'Hello'\nstripLeading(): 'Hello\\u2003'\nstripTrailing(): '\\u2003\\u2003Hello'\nisEmpty(): false\nisBlank(): true\nDivider: --------------------\nRepeated: HiHiHi\n>> Line1\n>> Line2\n>> Line3\n    Hello\n    World"
      },
      "callout": {
        "type": "info",
        "title": "Migrating to Java 11+ Methods",
        "text": "If your codebase is already on Java 11, search for all usages of trim() and replace with strip() for Unicode correctness. Replace !str.isEmpty() && !str.trim().isEmpty() with !str.isBlank(). Use repeat() instead of manual loops for padding."
      },
      "production_insight": "A microservice processing user-submitted text notes ran on Java 11. The team replaced trim() with strip() after reports of invisible whitespace characters from foreign keyboards causing empty-looking strings to pass validation. The change eliminated the bug without any performance regression.",
      "key_takeaway": "Java 11+ adds strip(), stripLeading(), stripTrailing(), isBlank(), repeat(), lines(). Prefer these over older equivalents for Unicode correctness and readability."
    },
    {
      "heading": "isBlank() vs isEmpty(): Choosing the Right Emptiness Check",
      "content": "Every Java developer needs to check if a string is empty. But \"empty\" can mean two things: a string with zero characters, or a string with only whitespace (looks empty but technically has content). Java provides isEmpty() for the first case and isBlank() (Java 11+) for the second.\n\nisEmpty(): returns true if length() == 0. It does not consider whitespace.\nisBlank(): returns true if the string is empty or contains only whitespace characters (space, tab, newline, etc.). Internally, it checks if indexOfNonWhitespace() returns -1.\n\nKey difference: isEmpty() is available in all Java versions; isBlank() requires Java 11+. If you're on older Java, you have to manually combine isEmpty() with a trim() check: str.isEmpty() || str.trim().isEmpty(). This is inefficient because trim() creates a new string. isBlank() is both cleaner and faster.\n\nWhen to use which:\n- Use isEmpty() when you care about exact zero length (e.g., a field that must have at least one visible character).\n- Use isBlank() when you want to treat whitespace-only strings as empty (e.g., user input in forms, CSV fields).\n\nIn practice, most business logic uses isBlank() because users rarely type pure whitespace intentionally.",
      "code": {
        "language": "java",
        "filename": "IsBlankVsIsEmpty.java",
        "code": "public class IsBlankVsIsEmpty {\n    public static void main(String[] args) {\n        String empty = \"\";\n        String onlySpaces = \"   \";\n        String withText = \" hello \";\n\n        // isEmpty()\n        System.out.println(\"empty.isEmpty(): \" + empty.isEmpty());           // true\n        System.out.println(\"onlySpaces.isEmpty(): \" + onlySpaces.isEmpty()); // false (length==3)\n        System.out.println(\"withText.isEmpty(): \" + withText.isEmpty());     // false\n\n        // isBlank()\n        System.out.println(\"empty.isBlank(): \" + empty.isBlank());           // true\n        System.out.println(\"onlySpaces.isBlank(): \" + onlySpaces.isBlank()); // true\n        System.out.println(\"withText.isBlank(): \" + withText.isBlank());     // false\n\n        // Old Java 8 workaround (inefficient)\n        boolean oldWay = empty.isEmpty() || empty.trim().isEmpty();\n        boolean oldWay2 = onlySpaces.isEmpty() || onlySpaces.trim().isEmpty();\n        System.out.println(\"Old workaround empty: \" + oldWay);   // true\n        System.out.println(\"Old workaround spaces: \" + oldWay2); // true\n\n        // Performance note: isBlank() does not allocate a new String\n        // while trim() does – use isBlank() on Java 11+\n    }\n}",
        "output": "empty.isEmpty(): true\nonlySpaces.isEmpty(): false\nwithText.isEmpty(): false\nempty.isBlank(): true\nonlySpaces.isBlank(): true\nwithText.isBlank(): false\nOld workaround empty: true\nOld workaround spaces: true"
      },
      "callout": {
        "type": "tip",
        "title": "Prefer isBlank() for User Input",
        "text": "When validating form fields or parsing user-generated content, use isBlank() to reject strings that contain only whitespace. These are almost always unintended input (e.g., copy-paste artifacts)."
      },
      "production_insight": "A customer registration form allowed whitespace-only usernames that passed isEmpty() checks. When other subsystems tried to display the username, they showed blank spaces, causing confusion. Switching to isBlank() in the validation layer prevented the issue entirely.",
      "key_takeaway": "isEmpty() checks for length 0; isBlank() checks for length 0 or all whitespace. On Java 11+, use isBlank() for most user-input scenarios."
    },
    {
      "heading": "Regular Expression Integration: matches, replaceAll, and replaceFirst",
      "content": "Strings and regular expressions go hand in hand in Java. Three methods use regex patterns directly: matches(), replaceAll(), and replaceFirst(). Understanding these will save you from writing complex manual loops.\n\nmatches() – Attempts to match the entire string against a regex pattern. It's equivalent to Pattern.matches(regex, str). Returns boolean. Common mistake: forgetting that matches() tries to match the whole string, not just a substring. If you want to find a substring, use find() on a Pattern object.\n\nreplaceAll() – Replaces every substring that matches the regex with a replacement string. The replacement can include back-references like $1 to capture groups. This is more powerful than replace() which only replaces literal strings.\n\nreplaceFirst() – Same as replaceAll() but only replaces the first occurrence.\n\nThese methods compile the regex each time they're called. If you use the same pattern frequently, pre-compile a Pattern object and reuse it for better performance. For one-off usage, the inline methods are fine.\n\nRemember that the dot (.) in regex matches any character. To match a literal dot, escape it as \\\\\. in the Java string literal.",
      "code": {
        "language": "java",
        "filename": "RegexStringMethods.java",
        "code": "public class RegexStringMethods {\n    public static void main(String[] args) {\n\n        // matches() – entire string must match\n        String phone = \"555-1234\";\n        boolean isPhone = phone.matches(\"\\\\\d{3}-\\\\\d{4}\");\n        System.out.println(\"Is phone number: \" + isPhone); // true\n\n        // Partial match won't work – returns false\n        String text = \"My phone is 555-1234\";\n        System.out.println(\"Partial matches: \" + text.matches(\".*\\\\\d{3}-\\\\\d{4}.*\")); // true (need .*)\n        System.out.println(\"Direct: \" + text.matches(\"\\\\\d{3}-\\\\\d{4}\")); // false\n\n        // replaceAll() – replace all matches\n        String message = \"Error 404: Not Found. Error 500: Server Error.\";\n        String redacted = message.replaceAll(\"Error \\\\\d{3}\", \"Error [REDACTED]\");\n        System.out.println(\"Redacted: \" + redacted);\n        // Error [REDACTED]: Not Found. Error [REDACTED]: Server Error.\n\n        // Using capture groups\n        String date = \"2025-12-31\";\n        String swapped = date.replaceAll(\"(\\\\\d{4})-(\\\\\d{2})-(\\\\\d{2})\", \"$3/$2/$1\");\n        System.out.println(\"Swapped: \" + swapped); // 31/12/2025\n\n        // replaceFirst() – only first occurrence\n        String sentence = \"Java is great. Java is portable.\";\n        String firstOnly = sentence.replaceFirst(\"Java\", \"JavaScript\");\n        System.out.println(\"First only: \" + firstOnly);\n        // JavaScript is great. Java is portable.\n    }\n}",
        "output": "Is phone number: true\nPartial matches: true\nDirect: false\nRedacted: Error [REDACTED]: Not Found. Error [REDACTED]: Server Error.\nSwapped: 31/12/2025\nFirst only: JavaScript is great. Java is portable."
      },
      "callout": {
        "type": "warning",
        "title": "Watch Out: Regex Backslashes in Java Strings",
        "text": "To write a single backslash in a regex, you need two backslashes in a Java String literal: \\\\\d for digit. This is a common source of confusion. If you have a complex regex, consider using Pattern.compile(regex) and store it in a static final field."
      },
      "production_insight": "A log parser used replaceAll() with a regex to mask user email addresses in logs. Initially they used replace() with literal strings, which missed variations. Switching to replaceAll() with a pattern like \"[\\\\\w.]+@[\\\\\w.]+\\\\\.\\\\\w+\" caught all patterns and improved security compliance.",
      "key_takeaway": "matches(), replaceAll(), and replaceFirst() are regex-powered. Use them for pattern-based text manipulation. Pre-compile Pattern objects for repeated use."
    }
  ]