Java String compareToIgnoreCase() Method

What You’ll Learn

The compareToIgnoreCase() method compares two strings in dictionary order while ignoring letter case. It returns the same style of int as compareTo(), but treats A and a as equivalent for sorting and ordering.

Definition and Usage

In Java, compareToIgnoreCase(String str) is a member of java.lang.String. It walks both strings in parallel, comparing characters after normalizing case, and returns whether the caller would appear before, at, or after the argument in a case-insensitive sorted list.

When two strings differ only in capitalization—such as "Hello, World!" and "HELLO, world!"—the method returns 0, even though equals() would return false.

📝 Syntax

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

public int compareToIgnoreCase(String str)

Parameters

• str — the string to compare against. Must not be null (throws NullPointerException).

Return Value

• Negative — caller is lexicographically less than str, ignoring case.
• Zero — strings are equal ignoring case.
• Positive — caller is lexicographically greater than str, ignoring case.

Examples Gallery

Run these in Java 8+. They show equal strings with different case, comparison with compareTo(), sorting, and the difference from equalsIgnoreCase().

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

        int result = str1.compareToIgnoreCase(str2);

        if (result == 0) {
            System.out.println("The strings are equal (ignoring case).");
        } else if (result < 0) {
            System.out.println("str1 is before str2.");
        } else {
            System.out.println("str1 is after str2.");
        }
        System.out.println("compareToIgnoreCase returned: " + result);
    }
}

The strings are equal (ignoring case).
compareToIgnoreCase returned: 0

public class CompareBothMethods {
    public static void main(String[] args) {
        String a = "Apple";
        String b = "apple";

        System.out.println("compareTo():            " + a.compareTo(b));
        System.out.println("compareToIgnoreCase():  " + a.compareToIgnoreCase(b));
    }
}

compareTo():            -32
compareToIgnoreCase():  0

import java.util.Arrays;
import java.util.List;

public class SortIgnoreCase {
    public static void main(String[] args) {
        List<String> tags = Arrays.asList("java", "Python", "C++", "android");

        tags.sort(String::compareToIgnoreCase);

        System.out.println(tags);
    }
}

[android, C++, java, Python]

public class DifferentWords {
    public static void main(String[] args) {
        String lang1 = "JAVA";
        String lang2 = "Python";

        int result = lang1.compareToIgnoreCase(lang2);

        System.out.println("Result: " + result);
        System.out.println(result < 0 ? "JAVA before Python" : "JAVA after Python");
    }
}

Result: -15
JAVA before Python

public class CompareVsEquals {
    public static void main(String[] args) {
        String input = "admin";
        String stored = "ADMIN";

        boolean same = input.equalsIgnoreCase(stored);
        int order  = input.compareToIgnoreCase(stored);

        System.out.println("equalsIgnoreCase: " + same);
        System.out.println("compareToIgnoreCase: " + order);
        System.out.println("equals (case-sensitive): " + input.equals(stored));
    }
}

equalsIgnoreCase: true
compareToIgnoreCase: 0
equals (case-sensitive): false

🚀 Common Use Cases

• Sorting names or tags — display lists where apple and Apple should not split apart because of case.
• Search ranking — order results without penalizing capitalization differences.
• Ordered sets/maps — custom comparators built on case-insensitive string order.
• File or path comparison — on case-insensitive file systems (conceptually similar behavior).
• Avoiding manual toLowerCase() — let Java handle case normalization inside one readable call.

📝 Notes

• Comparison still uses Unicode character values after case normalization—not locale-specific human collation rules.
• Passing null throws NullPointerException.
• compareToIgnoreCase() == 0 does not imply equals() is true—only case-insensitive lexical equality.
• For simple “same text ignoring case?” checks, equalsIgnoreCase() is clearer than testing for zero.
• Locale-sensitive sorting (e.g. Turkish I / ı) may need Collator instead of this method.

⚡ Optimization

compareToIgnoreCase() is the standard optimized approach for case-insensitive lexicographic comparison. It avoids allocating two new lowercased strings via toLowerCase() on every compare during a sort. For large sorts, prefer this method or a Comparator based on it rather than converting strings manually in a loop.

💡 Best Practices