Java String equals() Method

What You’ll Learn

The equals() method compares whether two strings contain the same text. It returns true or false. This is the method you should use instead of == when comparing string content in Java.

Definition and Usage

In Java, equals(Object obj) is inherited from java.lang.Object and overridden by String to compare character content. When both operands are strings with identical characters, "Hello".equals("Hello") returns true.

The == operator checks object identity—whether two variables refer to the exact same object in memory. Two different String objects can hold the same text; equals() detects that match while == may not.

📝 Syntax

The equals() method is declared in the Object class and overridden in String:

public boolean equals(Object anotherObject)

Parameters

• anotherObject — the object to compare with. May be null or any type; returns true only when it is a String with matching content.

Return Value

Returns true if both strings contain the same characters in the same order; otherwise false.

Exceptions

Does not throw an exception when the argument is null—it returns false. Calling equals on a null string reference (e.g. null.equals("x")) throws NullPointerException.

Examples Gallery

These programs run in Java 8+. They show matching strings, unequal text, the critical == vs equals() difference, case sensitivity, and null-safe comparison.

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

        boolean same = str1.equals(str2);

        System.out.println("Equal content? " + same);
    }
}

Equal content? true

public class NotEqualDemo {
    public static void main(String[] args) {
        String greeting = "Hello, World!";
        String other    = "Hello, Java!";

        System.out.println("Equals Java?  " + greeting.equals(other));
    }
}

Equals Java?  false

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

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

a == b:      false
a.equals(b): true

public class CaseSensitiveEquals {
    public static void main(String[] args) {
        String lang = "Java";

        System.out.println("Equals 'Java'? " + lang.equals("Java"));
        System.out.println("Equals 'java'? " + lang.equals("java"));
    }
}

Equals 'Java'? true
Equals 'java'? false

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

        // Safe: literal on the left
        System.out.println("Yoda? " + "Yoda".equals(userInput));

        // equals(null) on a non-null receiver returns false
        System.out.println("Null arg? " + "Java".equals(null));
    }
}

Yoda? false
Null arg? false

🚀 Common Use Cases

• Input validation — check whether the user typed an expected command or answer.
• Authentication — compare a entered password string with a stored value (never plain text in production; this illustrates the API).
• Configuration — branch logic when a setting equals "true" or "production".
• Menu systems — match user selection strings to menu options.
• Collections logic — filter or search lists when item text must match exactly.

📝 Notes

• equals() compares content, not object identity—use it instead of == for strings.
• It is case-sensitive. Use equalsIgnoreCase() when case should not matter.
• string.equals(null) returns false; null.equals(...) throws NullPointerException.
• String literals with the same text may share a pool reference, so == can appear to work—do not rely on that.
• For comparing a String with a StringBuilder, use contentEquals(), not equals().

⚡ Optimization

equals() is highly optimized in the JDK and is the correct choice for content comparison. Compare against a literal first when possible ("OK".equals(status)) to avoid null checks. In hot loops, avoid repeated case conversions—normalize once or use equalsIgnoreCase() directly when appropriate.

💡 Best Practices