Операторы в Java: арифметические, сравнения, логические и присваивания

Что делают операторы

Операторы - это символы, которые объединяют значения, чтобы вычислять новые. Вы уже используете их неформально - + складывает, > сравнивает - и Java группирует их в несколько семейств: арифметические, сравнения, логические, присваивания и пару особых, таких как инкремент и тернарный оператор.

Большинство операторов берут два значения (одно до символа, одно после) и выдают результат. Хитрость в том, чтобы знать, какого типа этот результат и в каком порядке они применяются - именно здесь спотыкаются новички.

Арифметические операторы

Пять арифметических операторов работают с числами: +, -, *, / и % (остаток).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (целочисленное деление!)
        System.out.println(a % b);   // 2  (остаток)
    }
}

Оператор % - это остаток от деления: 17 % 5 равно 2, потому что 5 укладывается в 17 три раза и остаётся 2. Это повседневный инструмент для проверки делимости - n % 2 == 0 это стандартная проверка «является ли n чётным?».

Обратите также внимание, что + выполняет двойную работу: с числами он складывает, но со String с любой стороны он соединяет текст.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

Первая строка читается слева направо: "Total: " + 3 уже строка, поэтому 4 добавляется как текст. Заключите вычисление в скобки, когда хотите, чтобы оно выполнилось первым.

Подводный камень целочисленного деления

Это самый частый сюрприз из всех. Когда оба операнда / - целые числа, Java выполняет целочисленное деление и отбрасывает дробь - оно не округляет, а усекает в сторону нуля.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, не 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (достаточно одного double)
        System.out.println((double) 5 / 2); // 2.5 (приведение одного операнда)
    }
}

Чтобы получить дробный результат, сделайте хотя бы один операнд double - либо напишите его с .0, либо приведите одну сторону с помощью (double). Запись (double)(5 / 2) не помогает, потому что целочисленное деление 5 / 2 уже произошло до приведения; приводить нужно операнд, а не результат.

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

Операторы сравнения задают вопрос «да/нет» и возвращают boolean. Их шесть: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Следите за разницей между = (присваивание - «положи это значение сюда») и == (сравнение - «равны ли они?»). Их путаница - классическая ошибка.

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

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - разные объекты
        System.out.println(a.equals(b));   // true  - одинаковый текст
    }
}

Используйте == для примитивов вроде int и boolean, а .equals() - всякий раз, когда сравниваете содержимое объектов, таких как String.

Логические операторы

Логические операторы объединяют булевы значения: && (и), || (или) и ! (не). Именно так вы выражаете условия вроде «достаточно взрослый и есть билет».

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& и || работают с сокращённым вычислением: Java прекращает вычисление, как только ответ становится очевидным. С &&, если левая часть false, правая никогда не проверяется; с ||, если левая часть true, правая пропускается. Это не просто оптимизация - на это можно полагаться ради безопасности:

if (text != null && text.length() > 0) { ... }

Если text равно null, левая часть false и text.length() никогда не вызывается, что предотвращает NullPointerException. Поменяйте порядок - и программа упадёт.

Присваивание и инкремент

= присваивает, но в Java есть и составные присваивания, которые объединяют операцию с присваиванием: +=, -=, *=, /=, %=. А ++ / -- прибавляют или вычитают единицу.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ бывает в двух видах: постфиксный (count++) возвращает старое значение, а затем увеличивает; префиксный (++count) сначала увеличивает, а затем возвращает новое значение. Разница важна только тогда, когда вы используете результат в том же выражении:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // выводит 5, затем x становится 6
        System.out.println(++x);   // x становится 7, выводит 7
    }
}

Когда ++ стоит на отдельной строке, постфиксный и префиксный варианты не различаются - так что выбирайте тот, что читается яснее, и не вставляйте инкременты в более крупные выражения.

Тернарный оператор

Тернарный оператор condition ? a : b - это компактный if/else, который выдаёт значение: если условие true, он вычисляется в a, иначе в b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Он хорош для коротких присваиваний «одно-или-другое». Не поддавайтесь искушению вкладывать тернарные операторы в тернарные - это быстро становится нечитаемым, и обычный if/else понятнее.

Приоритет и скобки

Операторы применяются в фиксированном порядке, во многом как в математике: *, /, % связываются крепче, чем + и -, которые связываются крепче, чем сравнения, которые связываются крепче, чем &&, а затем ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, не 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

Запоминать всю таблицу не нужно. Когда выражение смешивает семейства или вам приходится останавливаться, чтобы понять порядок, добавьте скобки - они ничего не стоят и делают намерение очевидным для следующего читателя.

Далее: приведение типов

Несколько подводных камней отсюда - целочисленное деление, смешивание int и double - сводятся к типам. Намеренное преобразование между числовыми типами называется приведением (casting), и это тема следующей страницы.