Java With Us

Comparison Operators in Java

Updated on 2026-04-21 Reviewed by the Java With Us editorial team

Comparison operators always produce a boolean. Java has six relational operators plus instanceof — a type-test operator.

The basics

a == b       // equal
a != b       // not equal
a < b        a <= b
a > b        a >= b
a instanceof String   // type check

== on objects is reference equality

String s1 = new String("hi");
String s2 = new String("hi");
s1 == s2;              // false — different objects
s1.equals(s2);         // true — content comparison

For every reference type (except enum constants), use .equals(). Strings from literals happen to be interned, which makes == appear to work — it breaks as soon as a new String or .substring() enters the picture.

Boxing pitfall

Integer a = 127, b = 127;
Integer c = 200, d = 200;
a == b;                // true  — cached (−128..127)
c == d;                // false — different objects

c.equals(d);           // ✅ always works

Floating-point ==

0.1 + 0.2 == 0.3;                // false
Math.abs(0.1 + 0.2 - 0.3) < 1e-9; // ✅ compare with tolerance

BigDecimal gotcha

new BigDecimal("1.00").equals(new BigDecimal("1.0"));   // false — different scale!
new BigDecimal("1.00").compareTo(new BigDecimal("1.0")); // 0 — equal value

Use compareTo() == 0 for BigDecimal equality.

Comparable and compareTo

public class Age implements Comparable<Age> {
    private final int years;
    @Override public int compareTo(Age other) {
        return Integer.compare(years, other.years);   // never use subtraction — overflow risk
    }
}

Common mistakes

  • == on Strings — use .equals() (or .equalsIgnoreCase()).
  • Boxing == bug — works by luck for small numbers, breaks for large.
  • Subtracting ints in compareTo — a - b overflows for large values. Use Integer.compare.
  • Comparing BigDecimal with equals — use compareTo.

Related

Pillar: Java operators. See also equals & hashCode, instanceof.

Related articles