Числовые операторы в Java

От / 
🔥 🚀 Важно для всех, кто работает с Java! 🔥
На JavaRocks ты найдешь уникальные туториалы, практические задачи и редкие книги, которых не найти в свободном доступе. Присоединяйся к нашему Telegram-каналу JavaRocks — стань частью профессионального сообщества!

В этой статье рассмотрим очень важную тему, а именно числовые операторы в Java.

В программировании числа играют ключевую роль. Если вспомнить школьные уроки, можно понять, что компьютер представляет всю информацию в числовом формате, используя комбинации нулей и единиц — так называемый двоичный код.

“В мире существует только 10 типов людей:
те, кто понимает бинарный код, и те, кто не понимает.”

В программировании существует множество числовых операторов, и мы рассмотрим самые важные из них на примерах.

Начнем с самых простых: арифметических операторов. Это хорошо знакомые операторы сложения (+), вычитания (-), умножения (*) и деления (/).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}
Run Code

Вывод:

1032
966
32967
30

Все эти операторы вам уже знакомы. К ним можно добавить оператор остатка от деления (или оператор деления по модулю) — %.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}
Run Code

Вывод:

1

В этом примере мы делим 33 на 2. Получаем 16 с остаточным «хвостом» (единицей), который не делится на 2. Этот «хвост» — результат операции «остаток от деления».

Java также поддерживает операторы сравнения/отношений (как в математике). Эти операторы, вероятно, знакомы вам еще со школы:

  • равно (==)
  • больше (>)
  • меньше (<)
  • больше или равно (>=)
  • меньше или равно (<=)
  • не равно (!=)

Здесь важно подчеркнуть один момент, который часто приводит к ошибкам у новичков. Оператор «равно» записывается как ==, а не =.

В Java одинарное = — это оператор присваивания, который используется, когда переменной присваивается число, строка или значение другой переменной.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}
Run Code

Вывод:

999

Упс! Это явно не тот результат, который мы ожидали. Это совершенно другой тип данных: мы ожидали увидеть логическое значение, а получили число. Все из-за того, что в скобках мы использовали оператор присваивания вместо оператора сравнения.

x=y

Значение y (999) было присвоено переменной x, а затем мы вывели значение x.

Вот как это нужно делать правильно:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}
Run Code

Вывод:

false

Теперь мы правильно сравнили два числа!

Вот еще одна особенность оператора присваивания (=): его можно “соединять” в цепочку:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}
Run Code

Вывод:

256

Помните, что присваивание выполняется справа налево.

Это выражение (x = y = z) будет выполнено поэтапно:

  • y = z, то есть y = 256
  • x = y, то есть x = 256

Унарные операторы

Эти операторы получили название «унарные» от латинского слова «uno», что означает «один». Это название объясняется тем, что, в отличие от предыдущих операторов, они действуют только на одно число, а не на несколько. К ним относятся:

  • Унарный минус. Он изменяет знак числа на противоположный.
public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}
Run Code

Вывод:

-999
999

Мы применили оператор унарного минуса дважды. В результате число сначала стало отрицательным, а потом снова стало положительным!

  • Инкремент (++) и декремент (–)

Оператор ++ увеличивает число на единицу, а оператор — уменьшает его на ту же величину.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}
Run Code

Вывод:

1000
999

Вот важный момент. Существует два типа операторов инкремента и декремента: постфиксный и префиксный.

x++ – постфиксный
++x – префиксный

В чем заключается основное отличие между тем, когда плюсы/минусы ставятся до или после числа?

Мы увидим это на следующем примере:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}
Run Code

Вывод:

999

Что-то не сходится! Мы хотели увеличить x на 1 и присвоить новое значение переменной y. То есть, y должно быть равно 1000. Но вместо этого мы получаем 999. Похоже, что x не был увеличен и оператор инкремента не сработал?

Но он сработал. Чтобы в этом убедиться, попробуйте вывести x в конце 🙂

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}
Run Code

Вывод:

999
1000

Фактически, именно поэтому эту операцию называют постфиксной: она выполняется после основного выражения. В нашем случае это означает:

int y = x++;

Сначала выполняется y = x (переменной y присваивается значение x), и только потом выполняется x++.

Что если это не то поведение, которое нам нужно? Тогда следует использовать префиксную запись:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}
Run Code

В этом случае сначала обрабатывается ++x, и только потом выполняется y = x.

Это различие стоит запомнить сразу, чтобы не ошибиться в реальной программе, где использование постфикса вместо префикса может все перевернуть 🙂

Составные операторы

Также в Java есть так называемые составные операторы. Они объединяют два оператора:

  • Оператор присваивания
  • Арифметические операторы

К ним относятся:

  • +=
  • -=
  • *=
  • /=
  • %=

Рассмотрим пример:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}
Run Code

Вывод:

1032

x += y означает x = x + y. Эти два символа используются вместе для сокращения записи. Аналогично работают комбинации -=, *=, /= и %=.

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

Помимо числовых операторов, в Java существуют операции, которые оперируют булевыми значениями (true и false).

Эти операции выполняются с помощью логических операторов:

  • ! — логическое отрицание. Он меняет значение булевой переменной на противоположное.
public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}
Run Code

Вывод:

false
  • && — логическое И. Он возвращает true только в том случае, если оба операнда равны true.
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}
Run Code

Вывод:

false
true

Результат первой операции — false, так как один из операндов ложен, а именно 100 > 200. Для того чтобы оператор && вернул true, оба операнда должны быть истинными (как во второй строке).

  • || — логическое ИЛИ. Результат будет true, если хотя бы один из операндов истинный.

С этим оператором предыдущий пример сработает иначе:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}
Run Code

Вывод:

true

Выражение 100 > 200 по-прежнему ложно, но для оператора ИЛИ достаточно, чтобы первая часть (100 > 10) была истинной.

Перевод статьи «Numeric operators in Java».

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Прокрутить вверх