Java Strings — Why == Broke Authentication in Production

package io.thecodeforge.strings;

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

        // METHOD 1: String literal — stored in the String Pool
        // Java reuses this object if another variable holds the same text
        String firstName = "Alice";
        String greeting = "Hello, World!";

        // METHOD 2: Using 'new' — always creates a fresh object in heap memory
        // Avoid this unless you explicitly need a separate object
        String cityName = new String("London");

        // Printing strings is straightforward — just pass the variable to println
        System.out.println(firstName);   // prints: Alice
        System.out.println(greeting);    // prints: Hello, World!
        System.out.println(cityName);    // prints: London

        // .length() tells you how many characters are in the String
        // Spaces count as characters too
        System.out.println(greeting.length()); // prints: 13

        // Strings can hold digits, symbols, spaces — anything in double quotes
        String productCode = "ITEM-00942";
        String emptyString  = "";  // valid — zero characters

        System.out.println(productCode);        // prints: ITEM-00942
        System.out.println(emptyString.length()); // prints: 0
    }
}

package io.thecodeforge.strings;

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

        String originalMessage = "Good morning";

        // This looks like we're changing originalMessage — we're NOT.
        // Java creates a brand-new String object "Good morning, Alice"
        // and makes the variable 'originalMessage' point to that new object.
        // The old "Good morning" string still exists in memory (briefly).
        originalMessage = originalMessage + ", Alice";

        System.out.println(originalMessage); // prints: Good morning, Alice

        // PROOF OF IMMUTABILITY:
        // Assign the reference to a second variable BEFORE concatenating
        String part1 = "Java ";
        String part2 = part1; // part2 points to the SAME object as part1

        // Now "modify" part1 by concatenating
        part1 = part1 + "is fun";

        // part2 still holds the original value — it was NOT changed
        // This proves the original object was never touched
        System.out.println(part1); // prints: Java is fun
        System.out.println(part2); // prints: Java  <-- original, untouched

        // UPPERCASE and LOWERCASE — these also return NEW strings
        String username = "alice_smith";
        String upperUsername = username.toUpperCase(); // new object created

        System.out.println(username);      // prints: alice_smith  (unchanged)
        System.out.println(upperUsername); // prints: ALICE_SMITH
    }
}

package io.thecodeforge.strings;

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

        String userEmail = "  Alice@Example.COM  "; // simulating messy user input

        // --- CLEANING INPUT ---

        // .trim() removes leading and trailing whitespace
        // Essential when handling form input — users often hit spacebar by accident
        String cleanEmail = userEmail.trim();
        System.out.println(cleanEmail); // prints: Alice@Example.COM

        // .toLowerCase() converts every character to lowercase
        // Standardising before storing in a database is best practice
        String normalisedEmail = cleanEmail.toLowerCase();
        System.out.println(normalisedEmail); // prints: alice@example.com

        // --- INSPECTING CONTENT ---

        String productDescription = "Java is a powerful, versatile language.";

        // .length() — number of characters (spaces included)
        System.out.println(productDescription.length()); // prints: 39

        // .contains() — checks if a piece of text exists inside the string
        // Returns true or false (a boolean)
        boolean mentionsJava = productDescription.contains("Java");
        System.out.println(mentionsJava); // prints: true

        // .startsWith() and .endsWith() — check the beginning or end
        System.out.println(productDescription.startsWith("Java"));  // prints: true
        System.out.println(productDescription.endsWith("language.")); // prints: true

        // .indexOf() — finds the position (index) of the first match
        // Returns -1 if the text is not found at all
        int positionOfPowerful = productDescription.indexOf("powerful");
        System.out.println(positionOfPowerful); // prints: 10

        // --- EXTRACTING PARTS ---

        String orderCode = "ORD-20240915-UK";

        // .substring(startIndex) — cuts from that index to the end
        // Indexes start at 0, just like a numbered shelf starting at slot zero
        String datePart = orderCode.substring(4, 12); // characters at index 4 up to (not including) 12
        System.out.println(datePart); // prints: 20240915

        // --- REPLACING AND SPLITTING ---

        String rawCsvRow = "Alice,30,Engineer,London";

        // .split() breaks a String into an array of parts using a separator
        // The separator itself is not included in the results
        String[] fields = rawCsvRow.split(",");
        System.out.println(fields[0]); // prints: Alice
        System.out.println(fields[1]); // prints: 30
        System.out.println(fields[2]); // prints: Engineer
        System.out.println(fields[3]); // prints: London

        // .replace() swaps every occurrence of one piece of text for another
        String updatedDescription = productDescription.replace("powerful", "fast");
        System.out.println(updatedDescription);
        // prints: Java is a fast, versatile language.

        // .isEmpty() — true if the string has zero characters
        // .isBlank() — true if the string is empty OR only whitespace (Java 11+)
        String emptyInput = "";
        String blankInput = "   ";
        System.out.println(emptyInput.isEmpty()); // prints: true
        System.out.println(blankInput.isBlank()); // prints: true
    }
}

package io.thecodeforge.strings;

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

        // Two string literals — Java stores both in the String Pool
        // Because they're identical, Java reuses the SAME object
        String cityA = "Paris";
        String cityB = "Paris";

        // == checks if they're the same OBJECT in memory
        // Here it returns true — but only because of the String Pool
        System.out.println(cityA == cityB);       // prints: true (don't rely on this!)
        System.out.println(cityA.equals(cityB));  // prints: true (correct and reliable)

        // Now create one using 'new' — this forces a new object in heap memory
        // cityC holds "Paris" as text, but it's a DIFFERENT object to cityA
        String cityC = new String("Paris");

        // == fails here — different objects, even though the text is identical
        System.out.println(cityA == cityC);       // prints: false  <-- WRONG result for intent
        System.out.println(cityA.equals(cityC));  // prints: true   <-- CORRECT

        // Real-world scenario: input coming from a scanner or database
        // would behave like the 'new String(...)' case above
        // ALWAYS use .equals() for string comparison in real code

        // BONUS: Case-insensitive comparison
        // .equalsIgnoreCase() is great for usernames, commands, country codes
        String inputCountry  = "united kingdom";
        String storedCountry = "United Kingdom";

        System.out.println(inputCountry.equals(storedCountry));             // prints: false
        System.out.println(inputCountry.equalsIgnoreCase(storedCountry));   // prints: true

        // COMPARING AGAINST A KNOWN CONSTANT:
        // Put the known string FIRST to avoid a NullPointerException
        // if the variable is null
        String userStatus = null;
        // userStatus.equals("active")  <-- DANGER: NullPointerException!
        boolean isActive = "active".equals(userStatus); // safe — no crash
        System.out.println(isActive); // prints: false
    }
}

package io.thecodeforge.strings;

import java.util.Objects;

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

        String userInput = null; // simulate missing input

        // BAD: crashes with NullPointerException
        // boolean match = userInput.equals("admin");

        // GOOD: put the constant first
        boolean match1 = "admin".equals(userInput);
        System.out.println("match1 = " + match1); // prints: false (no crash)

        // GOOD: use Objects.equals() — null-safe on both sides
        boolean match2 = Objects.equals(userInput, "admin");
        System.out.println("match2 = " + match2); // prints: false

        // Safe default for transformed strings
        String trimmed = (userInput != null) ? userInput.trim() : "";
        System.out.println("trimmed = '" + trimmed + "'"); // prints: ''

        // Alternative with Optional and map
        String result = Optional.ofNullable(userInput)
                                .map(String::toUpperCase)
                                .orElse("DEFAULT");
        System.out.println("result = " + result); // prints: DEFAULT
    }
}

// io.thecodeforge — java tutorial

public class StringPoolMemoryDebug {
    public static void main(String[] args) {
        char[] tokenChars = {"A", "B", "C", "-", "T", "O", "K", "E", "N"};
        
        // Dangerous: creates a new String every time
        String rawToken = new String(tokenChars);
        String anotherRaw = new String(tokenChars);
        System.out.println("Two new objects: " + (rawToken != anotherRaw)); // true
        
        // Safe: uses the pool — only one object exists on heap
        String pooledToken = new String(tokenChars).intern();
        String anotherPooled = new String(tokenChars).intern();
        System.out.println("Same pooled object: " + (pooledToken == anotherPooled)); // true
    }
}

// io.thecodeforge — java tutorial

public class StringBuilderVsConcat {
    public static void main(String[] args) {
        String[] headers = {"Host", "User-Agent", "Accept", "Connection"};
        
        // Bad: allocates 4+ intermediate strings
        String badJoin = "";
        for (String h : headers) {
            badJoin += h + ",";
        }
        
        // Good: single StringBuilder, zero extra allocations
        StringBuilder goodJoin = new StringBuilder();
        for (String h : headers) {
            goodJoin.append(h).append(",");
        }
        System.out.println(goodJoin.toString());
    }
}

// io.thecodeforge — java tutorial

import java.util.regex.Pattern;

public class RegexCompilationFix {
    private static final Pattern COMMA = Pattern.compile(",");  // compiled once
    
    public static void main(String[] args) {
        String csvLine = "alice,30,engineer";
        
        // Slow: compiles pattern every call
        String[] naive = csvLine.split(",");
        
        // Fast: precompiled pattern
        String[] fast = COMMA.split(csvLine);
        
        // Even faster for first field only
        int firstComma = csvLine.indexOf(',');
        String name = (firstComma == -1) ? csvLine : csvLine.substring(0, firstComma);
        System.out.println(name);  // alice
    }
}

// io.thecodeforge — java tutorial
public class StringBuilderVsBuffer {
    public static void main(String[] args) {
        // Fast: single-threaded
        StringBuilder sb = new StringBuilder();
        sb.append("Hello").append(" ").append("World");
        System.out.println(sb);

        // Thread-safe but slower
        StringBuffer buffer = new StringBuffer();
        buffer.append("Hello").append(" ").append("World");
        System.out.println(buffer);
    }
}

// io.thecodeforge — java tutorial
import java.util.StringTokenizer;

public class StringTokenizerVsSplit {
    public static void main(String[] args) {
        String data = "a,,b,c";

        // Legacy: skips empty tokens
        StringTokenizer st = new StringTokenizer(data, ",");
        while (st.hasMoreTokens()) {
            System.out.print(st.nextToken() + " ");
        }
        System.out.println();

        // Modern: includes empty token
        for (String s : data.split(",")) {
            System.out.print("'" + s + "' ");
        }
    }
}