Java Comparison Operators: Equality, Relational Operators and Examples

Java Comparison Operators: Compare Values and Build Conditions

Comparison operators test equality and ordering and are fundamental to conditions, loops, validation, filtering, and business rules.

What You Will Learn

• == and !=
• Greater and less comparisons
• Primitive comparison
• Reference identity
• String content
• Floating-point considerations

1. Equality and Inequality

2. Relational Operators

age > 18
score < 50
age >= 18
score <= 100

3. Boolean Results

boolean passed = marks >= 40;

4. Primitive Comparison

For primitive operands, == compares values under Java numeric rules.

5. Reference Comparison

For reference types, == tests reference identity rather than general object content equality.

6. String Comparison

String a = new String("Java");
String b = new String("Java");
System.out.println(a.equals(b));

Use equals for String content comparison.

7. Floating-Point Comparison

Calculated floating-point values can have representation differences, so direct equality may be inappropriate for some calculations.

8. Business Conditions

if (balance >= minimumBalance) {
    System.out.println("Eligible");
}

9. Common Mistakes

• Using = instead of ==
• Using == for String content
• Assuming reference identity means logical equality
• Ignoring floating-point behavior

6. Comparing Strings Correctly

A frequent beginner mistake is using == to compare String contents. Because String is an object, == checks whether two references identify the same object. Use equals() when the goal is content equality.

String first = "Java";
String second = new String("Java");
System.out.println(first == second);      // false
System.out.println(first.equals(second)); // true

For null-safe comparison, Objects.equals(a, b) is useful because it handles two null references without throwing a NullPointerException.

7. Comparing Objects by Identity vs Value

Object identity answers “Are these the same object?” Logical equality answers “Do these objects represent the same value according to their equality contract?” The distinction matters in collections, caching, domain models, and APIs.

User user1 = new User("Ravi");
User user2 = new User("Ravi");

// Identity may be different even when logical values are equal.
boolean sameObject = user1 == user2;

8. Boolean Comparisons

A comparison expression produces a boolean result. You can store it in a variable or use it directly in a condition.

boolean validAge = age >= 18;
boolean withinLimit = score <= 100;

if (validAge && withinLimit) {
    System.out.println("Valid");
}

9. Comparing Floating-Point Values

Direct equality checks on floating-point calculations can be surprising because binary floating-point values may not represent every decimal fraction exactly. When an application requires approximate comparison, define an acceptable tolerance.

double a = 0.1 + 0.2;
double b = 0.3;
double epsilon = 1e-9;
boolean closeEnough = Math.abs(a - b) < epsilon;

The appropriate tolerance depends on the domain and scale of the values. For exact decimal requirements, consider a decimal representation such as BigDecimal instead.

10. Comparison in Sorting and Filtering

Comparison operators are fundamental to filtering and ordering data.

if (employee.getSalary() > 50000) {
    highEarners.add(employee);
}

When sorting objects, use Comparator logic rather than trying to reduce all ordering behavior to direct == or > comparisons. A comparator can define how complex objects should be ordered.

11. Chained Comparisons Are Not Python-Style

Java does not support mathematical-style chained comparisons such as 0 < x < 10 as one boolean expression. Write the two comparisons explicitly and combine them with &&.

boolean valid = x > 0 && x < 10;

12. Common Comparison Mistakes

• Using == for String content.
• Comparing references when logical equality is required.
• Assuming floating-point equality is always safe.
• Forgetting that comparison expressions produce boolean values.
• Writing conditions that are technically valid but unclear because of unnecessary complexity.

13. Practical Comparison Checklist

• For primitives, compare values with the appropriate relational operator.
• For object identity, use == intentionally.
• For object value equality, use equals() according to the class contract.
• Use null-safe equality patterns when either side may be null.
• Use a domain-appropriate strategy for floating-point comparison.

14. Comparison in Business Logic

Comparison operators often represent business rules: age eligibility, spending limits, account status, score thresholds, date ordering, and quantity limits. The comparison itself is simple, but the rule it represents should be expressed clearly.

boolean eligible = age >= 18 && accountActive;

If the rule becomes more complex, move it into a well-named method such as isEligibleForPurchase(). The method name then communicates the business meaning better than a long boolean expression.

15. Null Checks and Comparison

Object comparisons must account for possible null values. Calling equals() on a null reference throws an exception, so use a null-safe pattern when inputs may be absent.

boolean same = java.util.Objects.equals(first, second);

16. Comparison with Dates and Domain Objects

Many domain types provide methods or comparators for ordering. Do not assume that every object should be compared with == or relational operators. Use the comparison API defined by the type.

17. Practice Tasks for Comparison Operators

• Check whether a number is within a range using two comparisons.
• Compare two primitive integers.
• Compare two Strings by content using equals().
• Write a null-safe equality check.
• Create a condition that validates both minimum and maximum limits.
• Compare two domain values using the appropriate type-specific method or comparator.

18. Comparison Review Checklist

• Know whether you need value equality, identity, or ordering.
• Use the correct operator for the data type.
• Handle null safely for references.
• Avoid direct floating-point equality when approximate comparison is required.
• Keep complex business comparisons readable through named methods.

Practical Mini Project

Create an eligibility checker that compares age, score, account status, and a String role. Use relational operators for numeric values, equals for String content, and a logical expression to combine the rules. Add a null-safe comparison for an optional role. Then test boundary values such as exactly 18 and exactly 40.

Comparison Mini Project

A useful extension is to improve the first version rather than immediately building something large. Give each important value a clear name, keep methods short, validate inputs at the boundary, and test normal, boundary, and invalid cases. This turns a language concept into a small engineering habit.

Comparison questions to practice

• What does == compare for primitives?
• What does == compare for references?
• Why is equals used for String content?
• How should null be handled?
• Why can floating-point equality be problematic?

How This Topic Connects to the Next Java Concepts

After comparison operators, logical operators let you combine several comparison results into complete business conditions.

19. Comparison and Boundary Testing

Comparison logic is especially sensitive to boundary values. If a rule says age >= 18, test 17, 18, and 19. If a score must be below 100, test 99, 100, and 101. Testing only a typical value can hide an incorrect choice between > and >= or < and <=.

20. Comparison and Readability

A condition should read like the rule it represents. If a comparison expression becomes difficult to understand, give its result a descriptive name or move it into a method. This is particularly helpful when several comparisons are combined with logical operators. Clear conditions make future rule changes safer.

Frequently Asked Questions

What does == do?

It compares primitive values or reference identity depending on operand types.

How should Strings be compared?

Use equals for content.

What does != do?

It checks inequality.

Do comparisons return boolean?

Yes.

Conclusion

Comparison operators turn values into decisions. Master value comparison and reference identity before moving into equality contracts and object design.

Related Java Resources

• Java Operators
• Java Logical Operators
• Java Equality and Reference Comparison
• Java Strings