Java String compareTo() Method

What You’ll Learn

The compareTo() method compares two strings in lexicographic order (like dictionary order) and returns an int telling you which string comes first. It is the standard tool for sorting strings and the basis of Java’s Comparable interface.

Definition and Usage

In Java, compareTo(String anotherString) compares the calling string with the argument string character by character, using Unicode values. If the first differing character in the caller is smaller, the result is negative; if larger, positive; if no difference is found and both strings have the same length, the result is zero.

For example, "apple".compareTo("banana") returns a negative number because 'a' comes before 'b'. This is how Java naturally sorts names in a contact list or words in a vocabulary app.

📝 Syntax

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

public int compareTo(String anotherString)

Parameters

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

Return Value

• Negative — the calling string is lexicographically less than the argument.
• Zero — both strings are lexicographically equal.
• Positive — the calling string is lexicographically greater than the argument.

Examples Gallery

These programs run in Java 8+. They cover basic comparison, equal strings, sorting, case sensitivity, and prefix length rules.

public class CompareExample {
    public static void main(String[] args) {
        String str1 = "apple";
        String str2 = "banana";

        int result = str1.compareTo(str2);

        if (result < 0) {
            System.out.println("str1 is before str2");
        } else if (result > 0) {
            System.out.println("str1 is after str2");
        } else {
            System.out.println("str1 and str2 are equal");
        }
        System.out.println("compareTo returned: " + result);
    }
}

str1 is before str2
compareTo returned: -1

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

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

compareTo: 0
equals:    true

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

public class SortNames {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Mari", "Arun", "Zara", "Bala");

        names.sort(String::compareTo);

        System.out.println(names);
    }
}

[Arun, Bala, Mari, Zara]

public class CaseCompare {
    public static void main(String[] args) {
        String upper = "Apple";
        String lower = "apple";

        System.out.println("\"Apple\".compareTo(\"apple\"): " +
            upper.compareTo(lower));
        System.out.println("\"apple\".compareTo(\"Apple\"): " +
            lower.compareTo(upper));
    }
}

"Apple".compareTo("apple"): -32
"apple".compareTo("Apple"): 32

public class PrefixCompare {
    public static void main(String[] args) {
        String shortWord = "app";
        String longWord  = "apple";

        System.out.println("\"app\".compareTo(\"apple\"):  " +
            shortWord.compareTo(longWord));
        System.out.println("\"apple\".compareTo(\"app\"): " +
            longWord.compareTo(shortWord));
    }
}

"app".compareTo("apple"):  -2
"apple".compareTo("app"): 2

🚀 Common Use Cases

• Sorting data — order usernames, product names, or file paths alphabetically.
• Ordered collections — TreeSet and TreeMap rely on comparison logic like compareTo().
• Binary search — find a string in a sorted array efficiently.
• Range checks — test whether a value falls between two string bounds.
• Implementing Comparable — custom classes often delegate string fields to compareTo().

📝 Notes

• Comparison is case-sensitive. Use compareToIgnoreCase() when case should not affect order.
• Ordering follows Unicode code unit values, so digits and symbols participate normally.
• Passing null as the argument throws NullPointerException.
• compareTo() == 0 implies the strings are equal in content; use equals() when you only need a true/false equality check.
• Do not rely on the exact numeric result—only the sign is guaranteed to be meaningful.

⚡ Optimization

compareTo() is the standard, optimized way to compare strings in Java. It stops at the first differing character rather than scanning the entire string when possible. For sorting large lists, prefer built-in sort utilities (Collections.sort, Arrays.sort) that call compareTo() efficiently rather than writing nested loops by hand.

💡 Best Practices