Операторы сравнения Java

Операторы сравнения принимают два операнда и возвращают boolean. В Java их шесть — равно, не равно и четыре реляционных оператора. Главный подводный камень: == ведёт себя по-разному для примитивов и объектов, что является наиболее распространённым источником ошибок у начинающих.

Шесть операторов

Каждый из них возвращает boolean, который можно использовать в условии if, в условии цикла или как значение переменной:

int score = 85;
boolean passed = score >= 60;        // true
boolean perfect = score == 100;      // false
boolean failed = !(score >= 60);     // false

Реляционные операторы (>, <, >=, <=) чаще всего используются в условиях if и в условиях выхода из цикла:

int temperature = 30;

if (temperature > 25) {
  System.out.println("warm");        // printed
} else if (temperature < 10) {
  System.out.println("cold");
}

for (int i = 0; i < 3; i++) {        // i < 3 is the loop guard
  System.out.println(i);             // 0 1 2
}

== для примитивов

Для примитивных типов == сравнивает значения:

int a = 5;
int b = 5;
System.out.println(a == b);    // true

double x = 0.1 + 0.2;
double y = 0.3;
System.out.println(x == y);    // false — IEEE 754 rounding

Пример с числами с плавающей точкой напоминает: не сравнивайте значения double на точное равенство. Проверяйте, что они отличаются не более чем на допустимую погрешность:

System.out.println(Math.abs(x - y) < 1e-9);   // true

== для объектов — идентичность, а не равенство

Для ссылочных типов == сравнивает ссылки — указывают ли две переменные на один и тот же объект в памяти. Два разных объекта с одинаковым содержимым не являются ==:

String s1 = new String("hello");
String s2 = new String("hello");

System.out.println(s1 == s2);          // false — different objects
System.out.println(s1.equals(s2));     // true  — same contents

Главное правило: для объектов всегда используйте .equals() для сравнения содержимого.

if (input.equals("quit")) { ... }      // correct
// if (input == "quit") { ... }        // works by coincidence, don't rely on it

Форма == "quit" иногда возвращает true, потому что Java дедуплицирует строковые литералы — одинаковый литерал компилируется в один объект. Но это деталь реализации, а не гарантия.

Objects.equals — безопасно для null

Если одна из сторон может быть null, вызов obj.equals(other) бросает NullPointerException. Используйте вместо этого Objects.equals — он обрабатывает null с любой стороны:

import java.util.Objects;

String a = null;
String b = "hello";

System.out.println(Objects.equals(a, b));   // false (no NPE)
System.out.println(Objects.equals(a, null)); // true

Сравнение объектов-обёрток

Типы-обёртки (Integer, Long и др.) подчиняются правилу объектов — == сравнивает ссылки, а не значения:

Integer x = 200;
Integer y = 200;
System.out.println(x == y);         // false (usually)
System.out.println(x.equals(y));    // true

(Значения от -128 до 127 кэшируются, поэтому Integer x = 100; Integer y = 100; x == y случайно оказывается true — но это особенность JVM, а не правило языка. Не полагайтесь на это.)

Сравнение для упорядочения — .compareTo

Операторы <, >, <=, >= работают только с примитивами. Для сравнения объектов по порядку используйте метод Comparable.compareTo (возвращает отрицательное, нулевое или положительное число):

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b));   // negative — "apple" < "banana"
System.out.println(a.compareTo(a));   // 0
System.out.println(b.compareTo(a));   // positive

Integer, Long, String, LocalDate и большинство «естественных» типов реализуют Comparable. Пользовательская сортировка использует Comparator — это рассматривается в Comparable и Comparator.

Демонстрация

Что дальше

Логические операторы Java — объединение логических выражений с помощью &&, || и !.

Практика