1. Обзор
Операторы являются фундаментальным строительным блоком любого языка программирования. Мы используем операторы для выполнения операций над значениями и переменными.
Java предоставляет множество групп операторов. Они классифицируются по функциональному назначению.
В этом руководстве мы рассмотрим все операторы Java, чтобы понять их функциональные возможности и способы их использования.
2. Арифметические операторы
Мы используем арифметические операторы для выполнения простых математических операций. Следует отметить, что арифметические операторы работают только с примитивными числовыми типами и их упакованными типами , такими как int и Integer .
Далее посмотрим, какие операторы у нас есть в группе арифметических операторов.
2.1. Оператор сложения
Оператор сложения (+) позволяет нам добавить два значения или объединить две строки:
int ten = 5 + 5;
String youAndMe = "You " + "and" + " Me";
2.2. Оператор вычитания
Обычно мы используем оператор вычитания (-), чтобы вычесть одно значение из другого:
int five = 10 - 5;
int negative80 = 20 - 100;
2.3. Оператор умножения
Оператор умножения (*) используется для умножения двух значений или переменных:
int hundred = 20 * 5;
int fifteen = -5 * -3;
2.4. Оператор отдела
Оператор деления (/) позволяет разделить левое значение на правое:
int four = 20 / 5;
int seven = 15 / 2;
Когда мы используем оператор деления для двух целых значений ( byte , short , int и long ), мы должны отметить, что результатом является значение частного. Остаток не включен .
Как показывает приведенный выше пример, если мы вычисляем 15/2 , частное равно 7, а остаток равен 1 . Следовательно, мы имеем 15/2 = 7 .
2.5. Оператор по модулю
Мы можем получить частное с помощью оператора деления. Однако, если мы просто хотим получить остаток от деления, мы можем использовать оператор по модулю (%):
int one = 15 % 2;
int zero = 10 % 5;
3. Унарные операторы
Как следует из названия, унарным операторам требуется только один единственный операнд . Например, мы обычно используем унарные операторы для увеличения, уменьшения или отрицания переменной или значения.
Теперь давайте подробно рассмотрим унарные операторы в Java.
3.1. Унарный оператор плюс
Унарный оператор плюс (+) указывает положительное значение. Если число положительное, мы можем опустить оператор «+»:
int five = +5; // same as: int five = 5
3.2. Унарный минус-оператор
В отличие от унарного оператора плюс, унарный минус (-) инвертирует значение или выражение:
int negativeFive = -5;
int eighty = -(20 - 100);
3.3. Логический оператор дополнения
Оператор логического дополнения (!) также известен как оператор НЕ . Мы можем использовать его для инвертирования значения логической переменной или значения:
boolean aTrue = true;
boolean bFalse = !aTrue;
3.4. Оператор приращения
Оператор приращения (++) позволяет нам увеличить значение переменной на 1:
int number = 5;
number++; // number = 6
3.5. Оператор декремента
Оператор декремента (–) действует противоположно оператору инкремента. Он уменьшает значение переменной на 1:
int number = 5;
number--; // number = 4
Мы должны помнить, что операторы инкремента и декремента могут использоваться только с переменной . Например, « int a = 5; а++; " Это хорошо. Однако выражение « 5++ » не будет скомпилировано.
4. Реляционные операторы
Реляционные операторы также можно назвать «операторами сравнения». По сути, мы используем эти операторы для сравнения двух значений или переменных.
4.1. Оператор «равно»
Мы используем оператор «равно» (==) для сравнения значений с обеих сторон. Если они равны, операция возвращает true :
int number1 = 5;
int number2 = 5;
boolean theyAreEqual = number1 == number2;
Оператор «равно» довольно прост. С другой стороны, класс Object предоставляет метод equals() . Поскольку класс Object является суперклассом всех классов Java, все объекты Java могут использовать метод equals() для сравнения друг с другом.
Когда мы хотим сравнить два объекта — например, когда мы сравниваем объекты Long или сравниваем String — мы должны разумно выбирать между методом сравнения из метода equals() и методом оператора «равно» .
4.2. Оператор «Не равно»
Оператор «не равно» (!=) действует противоположно оператору «==». Если значения с обеих сторон не равны, операция возвращает true :
int number1 = 5;
int number2 = 7;
boolean notEqual = number1 != number2;
4.3. Оператор «больше, чем»
Когда мы сравниваем два значения с помощью оператора «больше чем» (>), он возвращает true , если значение в левой части больше, чем значение в правой части:
int number1 = 7;
int number2 = 5;
boolean greater = number1 > number2;
4.4. Оператор «больше или равно»
Оператор «больше или равно» (>=) сравнивает значения с обеих сторон и возвращает true , если левый операнд больше или равен правому операнду:
int number1 = 7;
int number2 = 5;
boolean greaterThanOrEqualTo = number1 >= number2;
number1 = 5;
greaterThanOrEqualTo = number1 >= number2;
4.5. Оператор «меньше чем»
Оператор «меньше чем» (<) сравнивает два значения с обеих сторон и возвращает true , если значение в левой части меньше, чем значение в правой части:
int number1 = 4;
int number2 = 5;
boolean lessThan = number1 < number2;
4.6. Оператор «меньше или равно»
Точно так же оператор «меньше или равно» (<=) сравнивает значения с обеих сторон и возвращает true , если левый операнд меньше или равен правому:
int number1 = 4;
int number2 = 5;
boolean lessThanOrEqualTo = number1 <= number2;
number1 = 5;
lessThanOrEqualTo = number1 <= number2;
5. Логические операторы
У нас есть два логических оператора в Java: логические операторы И и ИЛИ. По сути, их функция очень похожа на вентиль И и вентиль ИЛИ в цифровой электронике.
Обычно мы используем логический оператор с двумя операндами, которые являются переменными или выражениями, которые могут быть оценены как логические .
Далее давайте познакомимся с ними поближе.
5.1. Логический оператор И
Логический оператор И ( && ) возвращает значение true только в том случае, если оба операнда истинны :
int number1 = 7;
int number2 = 5;
boolean resultTrue = (number1 > 0) && (number1 > number2);
5.2. Логический оператор ИЛИ
В отличие от оператора ' && ', логический оператор ИЛИ ( || ) возвращает значение true , если хотя бы один операнд имеет значение true :
int number1 = 7;
int number2 = 5;
boolean resultTrue = (number1 > 100) || (number1 > number2);
Следует отметить, что логический оператор ИЛИ имеет эффект короткого замыкания : он возвращает истину , как только один из операндов оценивается как истина, без оценки остальных операндов.
6. Тернарный оператор
Тернарный оператор — это сокращенная форма оператора if-then-else . Он называется тернарным, так как имеет три операнда. Во-первых, давайте посмотрим на стандартный синтаксис оператора if-then-else :
if ( condition ) {
expression1
} else {
expression2
}
Мы можем преобразовать приведенный выше оператор if-then-else в компактную версию, используя тернарный оператор:
Давайте посмотрим на его синтаксис:
condition ? expression1 : expression2
Далее давайте разберемся, как работает тернарный оператор на простом примере:
int number = 100;
String greaterThan50 = number > 50 ? "The number is greater than 50" : "The number is NOT greater than 50";
7. Побитовые операторы и операторы побитового сдвига
Поскольку статья « Побитовые операторы Java » подробно описывает побитовые операторы и операторы сдвига битов, мы кратко рассмотрим эти операторы в этом руководстве.
7.1. Побитовый оператор И
Побитовый оператор И (&) возвращает побитовое И входных значений:
int number1 = 12;
int number2 = 14;
int twelve = number1 & number2; // 00001100 & 00001110 = 00001100 = 12
7.2. Побитовый оператор ИЛИ
Оператор побитового ИЛИ (|) возвращает побитовое ИЛИ входных значений:
int number1 = 12;
int number2 = 14;
int fourteen = number1 | number2; // 00001100 | 00001110 = 00001110 = 14
7.3. Побитовый оператор XOR
Оператор побитового XOR (исключающее ИЛИ) (^) возвращает побитовое XOR входных значений:
int number1 = 12;
int number2 = 14;
int two = number1 ^ number2; // 00001100 ^ 00001110 = 00000010 = 2
7.4. Оператор побитового дополнения
Оператор побитового дополнения (~) является унарным оператором. Он возвращает дополнительное представление значения, которое инвертирует все биты входного значения:
int number = 12;
int negative13 = ~number; // ~00001100 = 11110011 = -13
7.5. Оператор левого сдвига
Операторы сдвига сдвигают биты влево или вправо на заданное количество раз.
Оператор сдвига влево (<<) сдвигает биты влево на количество раз, определенное правым операндом. После сдвига влево пустое место справа заполняется 0.
Далее дважды сдвинем число 12 влево:
int fourtyeight = 12 << 2; // 00001100 << 2 = 00110000 = 48
n << x имеет тот же эффект, что и умножение числа n на x степени двойки.
7.6. Подписанный оператор правой смены
Оператор сдвига вправо со знаком (>>) сдвигает биты вправо на количество раз, определенное правым операндом, и в результате заполняет 0 оставшихся пробелов.
Заметим, что крайнее левое положение после сдвига зависит от расширения знака .
Далее, давайте дважды сделаем «знаковый сдвиг вправо» для чисел 12 и -12, чтобы увидеть разницу:
int three = 12 >> 2; // 00001100 >> 2 = 00000011 = 3
int negativeThree = -12 >> 2; // 11110100 >> 2 = 11111101 = -3
Как показывает второй пример выше, если число отрицательное, крайняя левая позиция после каждого сдвига будет устанавливаться расширением знака.
n >> x имеет тот же эффект деления числа n на x степень двойки.
7.7. Беззнаковый оператор сдвига вправо
Оператор беззнакового сдвига вправо (>>>) работает аналогично оператору '>>'. Единственное отличие состоит в том, что после сдвига самый левый бит устанавливается в 0 .
Далее, давайте дважды сдвинем вправо числа 12 и -12 без знака, чтобы увидеть разницу:
int three = 12 >>> 2; // 00001100 >> 2 = 00000011 = 3
int result = -12 >>> 2; // result = 1073741821 (11111111111111111111111111110100 >>> 2 = 00111111111111111111111111111101)
Как мы видим во втором примере выше, оператор >>> заполняет пробелы слева 0 независимо от того, является ли число положительным или отрицательным .
8. Оператор instanceof
Иногда, когда у нас есть объект, мы хотели бы проверить, является ли он экземпляром данного типа . В этом нам может помочь оператор instanceof :
boolean resultTrue = Long.valueOf(20) instanceof Number;
9. Операторы присваивания
Мы используем операторы присваивания для присвоения значений переменным. Далее давайте посмотрим, какие операторы присваивания мы можем использовать в Java.
9.1. Простой оператор присваивания
Простой оператор присваивания (=) — простой, но важный оператор в Java. На самом деле, мы использовали его много раз в предыдущих примерах. Он присваивает значение справа операнду слева:
int seven = 7;
9.2. Составные задания
Мы изучили арифметические операторы. Мы можем комбинировать арифметические операторы с простым оператором присваивания для создания составных присваиваний.
Например, мы можем написать « а = а + 5 » составным образом: « а += 5 ».
Наконец, давайте рассмотрим все поддерживаемые составные присваивания в Java на примерах:
// Assuming all variables (a,b,c,d,e) have the initial value 10
a += 4; // a = 14, same as a = a + 4
b -= 4; // b = 6, same as b = b - 4
c *= 4; // c = 40, same as c = c * 4
d /= 4; // d = 2, same as d = d / 4
e %= 4; // e = 2, same as e = e % 4
10. Заключение
Java предоставляет множество групп операторов для различных функций. В этой статье мы рассмотрели операторы в Java.