Как сравниваются примитивы

Как сравниваются примитивы

Сравнение примитивов в Java — это одна из важнейших операций, но часто источник ошибок, особенно когда путают примитивы с объектами. Важно понимать разницу между ==, .equals() и другими операторами сравнения.

Примитивные типы в Java

// 8 примитивных типов
public class PrimitiveTypes {
    // Целые числа
    byte b = 127;      // 8 bit
    short s = 32767;   // 16 bit
    int i = 2147483647; // 32 bit
    long l = 9223372036854775807L; // 64 bit
    
    // Дробные
    float f = 3.14f;   // 32 bit
    double d = 3.14159; // 64 bit
    
    // Логический
    boolean bool = true; // 1 bit
    
    // Символ
    char c = 'A';      // 16 bit (Unicode)
}

Оператор == для примитивов

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

public class PrimitiveComparison {
    public static void main(String[] args) {
        // Целые числа
        int a = 5;
        int b = 5;
        System.out.println(a == b);  // true (значения одинаковые)
        
        int c = 5;
        int d = 10;
        System.out.println(c == d);  // false (значения разные)
        
        // Дробные числа
        double x = 3.14;
        double y = 3.14;
        System.out.println(x == y);  // true
        
        // Логические
        boolean flag1 = true;
        boolean flag2 = true;
        System.out.println(flag1 == flag2);  // true
        
        // Символы
        char ch1 = 'A';
        char ch2 = 'A';
        System.out.println(ch1 == ch2);  // true (сравниваются коды)
    }
}

Важные грабли: Floating Point сравнение

Для дробных чисел есть особенности из-за точности представления:

public class FloatingPointComparison {
    public static void main(String[] args) {
        // Проблема 1: Неточность представления
        double a = 0.1;
        double b = 0.2;
        double c = 0.3;
        
        System.out.println(a + b == c);  // false (!)
        // Потому что 0.1 + 0.2 = 0.30000000000000004
        
        // Правильное сравнение дробных чисел
        double epsilon = 1e-9;
        System.out.println(Math.abs((a + b) - c) < epsilon);  // true
        
        // Проблема 2: NaN (Not-a-Number)
        double nan = Double.NaN;
        System.out.println(nan == nan);  // false (сам с собой не равен!)
        System.out.println(Double.isNaN(nan));  // true (правильный способ)
        
        // Проблема 3: Бесконечность
        double infinity = Double.POSITIVE_INFINITY;
        System.out.println(infinity == infinity);  // true
        System.out.println(Double.isInfinite(infinity));  // true
    }
}

Сравнение примитивов vs объектов

Это главная путаница в Java:

public class PrimitiveVsObject {
    public static void main(String[] args) {
        // ПРИМИТИВЫ — сравниваются по значению
        int x = 5;
        int y = 5;
        System.out.println(x == y);  // true (значения одинаковые)
        
        // ОБЪЕКТЫ — сравниваются по ссылке по умолчанию
        Integer a = 5;      // Автобоксинг: new Integer(5)
        Integer b = 5;      // Автобоксинг: new Integer(5)
        System.out.println(a == b);  // Может быть true или false!
                                     // (зависит от кэша Integer)
        
        // Для сравнения объектов используй .equals()
        System.out.println(a.equals(b));  // true
        
        // Большие числа
        Integer c = 200;    // Новый объект
        Integer d = 200;    // Новый объект
        System.out.println(c == d);  // false (разные объекты)
        System.out.println(c.equals(d));  // true (одинаковые значения)
    }
}

Операторы сравнения: <, >, <=, >=

Эти операторы работают только с примитивами (и их обёрнутыми версиями через распаковку):

public class ComparisonOperators {
    public static void main(String[] args) {
        // Целые числа
        int a = 10;
        int b = 20;
        
        System.out.println(a < b);   // true
        System.out.println(a <= b);  // true
        System.out.println(a > b);   // false
        System.out.println(a >= b);  // false
        System.out.println(a != b);  // true
        System.out.println(a == b);  // false
        
        // Дробные числа
        double x = 3.14;
        double y = 2.71;
        
        System.out.println(x > y);   // true
        System.out.println(x >= y);  // true
        System.out.println(x < y);   // false
        System.out.println(x <= y);  // false
        
        // Обёрнутые типы (с распаковкой)
        Integer c = 15;
        Integer d = 25;
        System.out.println(c < d);   // true (распакуются и сравнятся)
    }
}

Сравнение примитивов в условиях

public class ConditionalComparison {
    public static void main(String[] args) {
        int age = 25;
        
        // if условие
        if (age == 25) {
            System.out.println("Exactly 25");
        }
        
        if (age > 18) {
            System.out.println("Adult");
        }
        
        // Ternary оператор
        String status = (age >= 18) ? "Adult" : "Minor";
        System.out.println(status);  // Adult
        
        // switch для int, byte, short, char
        switch (age) {
            case 25:
                System.out.println("Age is 25");
                break;
            case 30:
                System.out.println("Age is 30");
                break;
            default:
                System.out.println("Other age");
        }
    }
}

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

Символы сравниваются по их Unicode кодам:

public class CharComparison {
    public static void main(String[] args) {
        char c1 = 'A';   // Unicode 65
        char c2 = 'A';   // Unicode 65
        char c3 = 'B';   // Unicode 66
        
        System.out.println(c1 == c2);  // true (одинаковые коды)
        System.out.println(c1 == c3);  // false
        System.out.println(c1 < c3);   // true (65 < 66)
        
        // Можно даже кастить в int
        int code = (int) c1;
        System.out.println(code);  // 65
    }
}

Сравнение логических значений

public class BooleanComparison {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false;
        
        System.out.println(b1 == b2);  // true
        System.out.println(b1 == b3);  // false
        System.out.println(b1 != b3);  // true
        
        // Логические операции
        System.out.println(b1 && b2);  // true (И)
        System.out.println(b1 || b3);  // true (ИЛИ)
        System.out.println(!b1);       // false (НЕ)
    }
}

Сравнение с приведением типов

Когда сравниваются разные примитивные типы:

public class TypePromotion {
    public static void main(String[] args) {
        // Меньший тип расширяется к большему
        int a = 5;
        long b = 5L;
        System.out.println(a == b);  // true (int расширяется к long)
        
        double x = 5.0;
        int y = 5;
        System.out.println(x == y);  // true (int расширяется к double)
        
        // Но будь осторожен с дробными!
        double d = 5.5;
        int i = 5;
        System.out.println(d == i);  // false (5.5 != 5)
        
        // Kasting
        System.out.println((int) d == i);  // true (5 == 5 после кастинга)
    }
}

Таблица сравнения методов

Практические советы

public class BestPractices {
    
    // 1. Для примитивов используй ==
    public boolean comparePrimitives(int a, int b) {
        return a == b;  // Правильно
    }
    
    // 2. Для дробных чисел используй epsilon
    public boolean compareDoubles(double a, double b) {
        return Math.abs(a - b) < 1e-9;  // Правильно
    }
    
    // 3. Для объектов используй .equals()
    public boolean compareObjects(Object a, Object b) {
        return Objects.equals(a, b);  // Правильно и null-safe
    }
    
    // 4. Избегай автобоксинга в сравнениях
    Integer x = 100;
    Integer y = 100;
    // Плохо: x == y  (может быть true/false, зависит от кэша)
    // Хорошо: x.equals(y)  (всегда true)
    
    // 5. Для Comparable используй compareTo()
    Integer a = 5;
    Integer b = 10;
    System.out.println(a.compareTo(b));  // -1 (a < b)
}

Сравнение примитивов — базовая операция, которую важно понимать, чтобы избежать неожиданного поведения в программе.