How to compare strings in Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        String a = "Java";
        String b = "Java";               // the same literal: one shared, interned object
        String c = new String("Java");   // new always creates a separate object
        String part = "Ja";
        String d = part + "va";          // built at run time: a new object
        final String constant = "Ja";
        String e = constant + "va";      // a compile-time constant: interned like a literal

        // == asks "is this the same object?"
        System.out.println("a == b: " + (a == b));
        System.out.println("a == c: " + (a == c));
        System.out.println("a == d: " + (a == d));
        System.out.println("a == e: " + (a == e));
        System.out.println("a == d.intern(): " + (a == d.intern()));

        // equals asks "are these the same characters?"
        System.out.println(a.equals(b) + " " + a.equals(c) + " " + a.equals(d) + " " + a.equals(e));

        // The classic bug: text read at run time is never the literal's object
        Scanner in = new Scanner("yes\n");
        String answer = in.nextLine();
        if (answer == "yes") {
            System.out.println("== matched");
        } else {
            System.out.println("== missed \"" + answer + "\"");
        }
        if (answer.equals("yes")) {
            System.out.println("equals matched");
        }
    }
}

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        String status = null;   // a missing field, an absent map key, an unset parameter

        // Constant first: "active".equals(null) is simply false
        System.out.println("active".equals(status));

        // Variable first: calling a method on null throws
        try {
            System.out.println(status.equals("active"));
        } catch (NullPointerException e) {
            System.out.println("NullPointerException");
        }

        // Both sides may be null: Objects.equals (Java 7+)
        String previous = null;
        System.out.println(Objects.equals(status, previous));
        System.out.println(Objects.equals(status, "active"));
        System.out.println(Objects.equals("active", "active"));

        // Empty or blank? isEmpty checks length 0; isBlank (Java 11+) ignores whitespace
        String[] inputs = {"", "   ", "\t\n", "\u2003", " Ada "};
        String[] labels = {"empty", "3 spaces", "tab+newline", "em space", "\" Ada \""};
        System.out.println("input        isEmpty isBlank trim().isEmpty()");
        for (int i = 0; i < inputs.length; i++) {
            String s = inputs[i];
            System.out.printf("%-12s %-7b %-7b %b%n", labels[i], s.isEmpty(), s.isBlank(), s.trim().isEmpty());
        }

        // Null, empty or blank in one check
        for (String s : new String[] {null, "", "  ", "x"}) {
            System.out.print((s == null || s.isBlank()) + " ");
        }
        System.out.println();
    }
}

import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        String input = "YES";
        System.out.println(input.equals("yes"));
        System.out.println(input.equalsIgnoreCase("yes"));
        System.out.println("yes".equalsIgnoreCase(null));

        // Ignore case for just part of a string: regionMatches(ignoreCase, ...)
        String header = "Content-Type: text/html";
        System.out.println(header.regionMatches(true, 0, "content-type", 0, 12));

        // equalsIgnoreCase works char by char, so it can't match ß with SS
        System.out.println("Straße".equalsIgnoreCase("STRASSE"));
        System.out.println("Straße".toUpperCase(Locale.ROOT));
        System.out.println("Straße".toUpperCase(Locale.ROOT).equals("STRASSE"));

        // toLowerCase() without a Locale uses the default one: pin it for comparisons
        System.out.println("TITLE".toLowerCase(Locale.ROOT));
        System.out.println("TITLE".toLowerCase(Locale.forLanguageTag("tr")));
        System.out.println("TITLE".equalsIgnoreCase("title"));

        // equals() is false for anything that isn't a String, even with the same text
        StringBuilder sb = new StringBuilder("Java");
        System.out.println("Java".equals(sb));
        System.out.println("Java".contentEquals(sb));
        System.out.println("Java".equals(sb.toString()));
    }
}

import java.text.Collator;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        // compareTo returns a negative number, zero or a positive number.
        // Only the sign is meaningful; the magnitude is an implementation detail.
        System.out.println("apple".compareTo("banana"));
        System.out.println("banana".compareTo("apple"));
        System.out.println("apple".compareTo("apple"));
        System.out.println("app".compareTo("apple"));

        if ("apple".compareTo("banana") < 0) {
            System.out.println("apple sorts before banana");
        }

        // It compares char codes, so every uppercase ASCII letter sorts before every lowercase one
        System.out.println("Zebra".compareTo("apple") < 0);
        System.out.println("Zebra".compareToIgnoreCase("apple") < 0);

        List<String> words = List.of("banana", "Cherry", "apple", "Zebra", "éclair", "eclipse");

        List<String> natural = new ArrayList<>(words);
        natural.sort(null);   // null means natural order, i.e. compareTo
        System.out.println(natural);

        List<String> ignoreCase = new ArrayList<>(words);
        ignoreCase.sort(String.CASE_INSENSITIVE_ORDER);
        System.out.println(ignoreCase);

        // Collator sorts the way a dictionary for that language does
        Collator collator = Collator.getInstance(Locale.US);
        List<String> human = new ArrayList<>(words);
        human.sort(collator);
        System.out.println(human);

        // PRIMARY strength: only base letters count, so case and accents are ignored
        collator.setStrength(Collator.PRIMARY);
        System.out.println(collator.compare("resume", "Résumé") == 0);
        System.out.println(collator.equals("resume", "Résumé"));
    }
}

import java.util.Locale;

public class Main {
    // Classic switch statement on a String (Java 7+): each case needs a break
    static int exitCode(String command) {
        int code;
        switch (command) {
            case "start":
                code = 0;
                break;
            case "stop":
            case "halt":
                code = 1;
                break;
            default:
                code = -1;
        }
        return code;
    }

    // Switch expression (Java 14+): arrows, no fall-through, and it returns a value
    static String describe(String command) {
        return switch (command) {
            case "start" -> "starting";
            case "stop", "halt" -> "stopping";
            default -> "unknown: " + command;
        };
    }

    // Java 21+: case null, and a guarded pattern for anything a constant can't express
    static String route(String command) {
        return switch (command) {
            case null -> "no command";
            case "start" -> "starting";
            case String s when s.startsWith("re") -> "restart-like: " + s;
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(exitCode("start") + " " + exitCode("halt") + " " + exitCode("START"));

        System.out.println(describe("stop"));
        System.out.println(describe("Stop"));
        System.out.println(describe("Stop".toLowerCase(Locale.ROOT)));

        // Without case null, a null selector throws
        String missing = null;
        try {
            describe(missing);
        } catch (NullPointerException e) {
            System.out.println("NullPointerException");
        }

        System.out.println(route(null));
        System.out.println(route("reload"));
        System.out.println(route("pause"));
    }
}