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

Программа становится интересной, когда она принимает решения. А для решений нужны условия. А условия — это сравнения. В этом уроке мы детально разберём все операторы сравнения и их особенности.

🔍 == и != с примитивными типами

Сравнение примитивных типов — самое простое. == проверяет, равны ли два значения, != — не равны ли они:

public class PrimitiveComparison {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;
        int c = 10;

        System.out.println(a == b);  // true
        System.out.println(a == c);  // false
        System.out.println(a != c);  // true

        // Сравнение boolean
        boolean x = true;
        boolean y = false;
        System.out.println(x == true);   // true
        System.out.println(x != y);      // true

        // Сравнение char (по Unicode-коду)
        char ch1 = 'A';
        char ch2 = 'B';
        System.out.println(ch1 < ch2);   // true (65 < 66)

        // Сравнение double — ОСТОРОЖНО!
        double d1 = 0.1 + 0.2;
        double d2 = 0.3;
        System.out.println(d1 == d2);    // false! (погрешность)
    }
}

С примитивами == сравнивает значения. Это просто и предсказуемо. Except для double/float — из-за погрешностей представления прямое сравнение может давать неожиданные результаты.

📝 Сравнение строк: == vs equals()

String — это объект (не примитив). Для объектов == сравнивает ссылки (указывают ли переменные на один объект в памяти), а equals() сравнивает содержимое:

public class StringComparison {
    public static void main(String[] args) {
        String a = "Hello";
        String b = "Hello";
        String c = new String("Hello");

        // == сравнивает ссылки
        System.out.println(a == b);      // true (литералы кэшируются!)
        System.out.println(a == c);      // false (разные объекты)

        // equals() сравнивает содержимое
        System.out.println(a.equals(c)); // true (одинаковый текст)

        // Безопасный порядок (защита от null)
        System.out.println("Hello".equals(a));  // true
        // System.out.println(a.equals("Hello")); // тоже OK если a не null

        // Регистрозависимое сравнение
        System.out.println("Hello".equals("hello"));          // false
        System.out.println("Hello".equalsIgnoreCase("hello")); // true
    }
}

⚖️ Больше, меньше, больше/меньше или равно

Операторы >, <, >=, <= работают только с числовыми типами (и char):

public class NumericComparison {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println(a > b);   // false
        System.out.println(a < b);   // true
        System.out.println(a >= 10); // true
        System.out.println(a <= 5);  // false

        // С char — сравниваются Unicode-коды
        System.out.println('a' > 'A');  // true (97 > 65)
        System.out.println('Z' < 'a');  // true (90 < 97)

        // С double — осторожно с погрешностями
        double x = 1.0;
        System.out.println(x > 0.999999999999); // true (но не всегда предсказуемо)
    }
}

Типичные паттерны использования:

// Проверка диапазона
int age = 25;
boolean isWorkingAge = (age >= 18) && (age <= 65);

// Проверка на ноль
int count = 0;
if (count > 0) {
    System.out.println("Есть элементы");
}

// Проверка на отрицательность
double balance = -50.0;
if (balance < 0) {
    System.out.println("Долг!");
}

🔤 Сравнение символов (char)

Тип char — это число (Unicode-код символа). Поэтому его можно сравнивать через >, < и т.д.:

public class CharComparison {
    public static void main(String[] args) {
        char a = 'A';
        char b = 'Z';

        System.out.println(a < b);   // true (65 < 90)
        System.out.println('a' > 'z'); // false

        // Проверка: является ли символ заглавной буквой
        char ch = 'M';
        boolean isUpperCase = (ch >= 'A' && ch <= 'Z');
        boolean isLowerCase = (ch >= 'a' && ch <= 'z');
        boolean isDigit = (ch >= '0' && ch <= '9');

        System.out.println(ch + " — заглавная: " + isUpperCase);
        System.out.println(ch + " — строчная: " + isLowerCase);
        System.out.println(ch + " — цифра: " + isDigit);
    }
}

📦 Сравнение объектов: compareTo()

Для строк и других объектов можно использовать метод compareTo(), который возвращает:

• Отрицательное число — первая строка «меньше» (идёт раньше в алфавите)
• 0 — строки равны
• Положительное число — первая строка «больше»

public class CompareTo {
    public static void main(String[] args) {
        String a = "apple";
        String b = "banana";

        int result = a.compareTo(b);
        System.out.println(result);  // Отрицательное (apple < banana)

        System.out.println("apple".compareTo("apple"));  // 0
        System.out.println("banana".compareTo("apple")); // Положительное

        // Сортировка строк
        String[] fruits = {"banana", "apple", "cherry"};
        // compareTo используется внутри сортировки
    }
}

🎯 Плавающая точка: осторожность с ==

Мы уже упоминали это в уроке 2.2, но это настолько важно, что стоит повторить:

public class FloatComparison {
    public static void main(String[] args) {
        double a = 0.1 + 0.2;
        double b = 0.3;

        // НЕПРАВИЛЬНО:
        System.out.println(a == b);  // false!

        // ПРАВИЛЬНО:
        double epsilon = 1e-10;
        System.out.println(Math.abs(a - b) < epsilon);  // true!

        // Или через Double.compare
        System.out.println(Double.compare(a, b) == 0);  // false (то же что ==)
        // Double.compare всё равно использует == для значений
    }
}

Правило: никогда не используйте == для сравнения float/double. Всегда проверяйте, что разница меньше epsilon.

✅ Итоги урока

Далее: if / else — условные конструкции для принятия решений →