Java String equalsIgnoreCase() Method

What You’ll Learn

The equalsIgnoreCase() method compares two strings for the same text while ignoring letter case. It returns true or false—perfect when users might type yes, YES, or Yes.

Definition and Usage

In Java, equalsIgnoreCase(String anotherString) is defined on java.lang.String. It compares the full content of two strings character by character, treating uppercase and lowercase forms of the same letter as equal. If "Hello, World!" is compared with "HELLO, world!", the result is true.

Use this method when case differences should not affect the outcome—such as accepting configuration values, menu choices, or file extensions typed in mixed case.

📝 Syntax

The equalsIgnoreCase() method is declared in the String class:

public boolean equalsIgnoreCase(String anotherString)

Parameters

• anotherString — the string to compare with. May be null; a null argument returns false.

Return Value

Returns true if both strings are equal when case is ignored; otherwise false.

Exceptions

Does not throw when the argument is null. Calling the method on a null string reference throws NullPointerException.

Examples Gallery

These programs run in Java 8+. They show a case-insensitive match, comparison with equals(), user command handling, null safety, and contrast with compareToIgnoreCase().

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Hello, World!";
        String str2 = "HELLO, world!";

        boolean result = str1.equalsIgnoreCase(str2);

        if (result) {
            System.out.println("The strings are equal (ignoring case).");
        } else {
            System.out.println("The strings are not equal.");
        }
    }
}

The strings are equal (ignoring case).

public class EqualsVsIgnoreCase {
    public static void main(String[] args) {
        String a = "Java";
        String b = "java";

        System.out.println("equals():            " + a.equals(b));
        System.out.println("equalsIgnoreCase():  " + a.equalsIgnoreCase(b));
    }
}

equals():            false
equalsIgnoreCase():  true

public class CommandParser {
    public static void main(String[] args) {
        String[] attempts = {"yes", "YES", "no", "No"};

        for (String input : attempts) {
            if (input.equalsIgnoreCase("yes")) {
                System.out.println(input + " -> confirmed");
            } else {
                System.out.println(input + " -> declined");
            }
        }
    }
}

yes -> confirmed
YES -> confirmed
no -> declined
No -> declined

public class NullSafeIgnoreCase {
    public static void main(String[] args) {
        String userInput = null;

        System.out.println("Match quit? " + "quit".equalsIgnoreCase(userInput));
        System.out.println("Null arg?   " + "Java".equalsIgnoreCase(null));
    }
}

Match quit? false
Null arg?   false

public class IgnoreCaseCompareMethods {
    public static void main(String[] args) {
        String s1 = "Apple";
        String s2 = "apple";

        System.out.println("equalsIgnoreCase:   " + s1.equalsIgnoreCase(s2));
        System.out.println("compareToIgnoreCase: " + s1.compareToIgnoreCase(s2));
    }
}

equalsIgnoreCase:   true
compareToIgnoreCase: 0

🚀 Common Use Cases

• Menu and command parsing — accept exit, EXIT, or Exit as the same command.
• Configuration flags — treat true, TRUE, and True as enabled.
• File extension checks — when paired with case normalization or for ASCII extensions like .PDF vs .pdf.
• Username or email local-part lookup — when policy says case should not distinguish users (domain rules vary).
• Test assertions — verify output text without brittle exact-case expectations.

📝 Notes

• equalsIgnoreCase() compares the entire string, not a substring—unlike contains().
• It is more forgiving than equals() for letter case but still requires the same text (length and characters).
• For passwords and security-sensitive values, prefer case-sensitive equals() unless policy says otherwise.
• Unicode has locale-specific case rules; for most English tutorials and ASCII input, behavior matches intuition.
• Do not use == for content comparison—use equals() or equalsIgnoreCase().

⚡ Optimization

equalsIgnoreCase() is optimized in the JDK and is preferable to manually calling toLowerCase() on both strings for most cases. If you compare the same pair repeatedly in a loop, cache the boolean result. When sorting many strings case-insensitively, use compareToIgnoreCase() or a Comparator instead of chaining multiple equalsIgnoreCase calls.

💡 Best Practices