Привет! Сегодня мы рассмотрим очень важную тему, а именно операции над числами в Java.
Коротко: в Java есть арифметические операции (+, -, *, /, %), операции сравнения (==, !=, >, < и т.д.), унарные (унарный минус, инкремент ++ и декремент --), комбинированные (+=, -= и т.д.) и логические (!, &&, ||). Ниже разберем каждую группу с примерами.
Числа в программировании повсюду. Если копнуть в школьный курс, можно вспомнить, что вся информация в компьютере представлена в числовом формате, комбинациями нулей и единиц, которое еще называют двоичным кодом.
Кратко
Арифметические:+, -, *, /, а также % (остаток от деления).
Сравнение:==, !=, >, <, >=, <=. Важно: равенство это ==, а один знак = это присваивание.
Унарные: унарный минус, инкремент ++ и декремент --.
Инкремент и декремент бывают префиксные (++x) и постфиксные (x++): порядок выполнения у них разный.
Комбинированные:+=, -=, *=, /=, %= (x += y это x = x + y).
Логические:! (НЕ), && (И), || (ИЛИ) для значений boolean.
Операций над числами в программировании существует великое множество, поэтому мы рассмотрим наиболее важные из них с примерами :)
Арифметические операции
Начнем с самого простого, с арифметических операций. Это известные всем сложение (знак +), вычитание (-), умножение (*) и деление (/).
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);
}
}
Вывод в консоль:
1032
966
32967
30
Всем этим ты уже пользовался. К ним можно прибавить операцию %, остаток от деления.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
Вывод в консоль:
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);//ожидаем, что в консоль будет выведено false
}
}
Вывод в консоль:
999
Упс! Это явно не тот результат, на который мы рассчитывали. Это вообще другой тип данных: мы ожидали увидеть boolean, а получили число. Все потому, что в скобках у нас операция присваивания, а не сравнения.
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);
}
}
Вывод в консоль:
false
Вот теперь мы правильно сравнили 2 числа! :)
Еще одна особенность операции присваивания (=): ее можно осуществлять "по цепочке":
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);
}
}
Вывод в консоль:
256
Запомни: присваивание осуществляется справа налево.
Данное выражение (x = y = z) будет выполнено по шагам:
y = z , то есть у = 256
x = y, то есть x = 256
Унарные операции
Они называются "унарными" от слова "uno", то есть "один". Такое название они получили потому, что в отличие от предыдущих, проводятся над одним числом, а не над несколькими.
К ним относятся:
Унарный минус. Он меняет знак числа на противоположный.
public class Main {
public static void main(String[] args) {
int x = 999;
//меняем знак первый раз
x = -x;
System.out.println(x);
//меняем знак второй раз
x= -x;
System.out.println(x);
}
}
Вывод в консоль:
-999
999
Мы использовали унарный минус два раза. В результате наше число стало сначала отрицательным, а потом снова положительным!
Инкремент (++) и декремент (--)
Операция ++ увеличивает число на единицу, а операция -- уменьшает на эту же самую единицу.
public class Main {
public static void main(String[] args) {
int x = 999;
x++;
System.out.println(x);
x--;
System.out.println(x);
}
}
Вывод в консоль:
1000
999
Такая форма записи может быть тебе знакома, если ты слышал о языке С++. С помощью такого интересного названия его создатели передали свою идею: "C++ является расширением языка C".
А популярная улучшенная версия "Блокнота" называется Notepad++
Важный момент. Операции инкремента и декремента бывают двух видов: постфиксными, и префиксными.
x++ это постфиксная запись
++x это префиксная запись
В чем же заключается принципиальная разница, если ставить плюсы-минусы перед числом или после?
Увидим на примере:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
Вывод в консоль:
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);
}
}
Вывод в консоль:
999
1000
На самом деле, постфиксная операция потому так и называется: она выполняется после основного выражения. То есть выражение int y = x++; происходит по шагам:
сначала y = x (переменной y присваивается изначальное значение x),
а только потом x++ (x увеличивается на 1).
Как быть, если нас не устраивает такое поведение? Нужно использовать префиксный способ записи:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
В этом случае выражение int y = ++x; происходит по шагам:
сначала отработает ++x (x увеличивается на 1),
и только после этого y = x;.
Эту разницу стоит запомнить сразу, чтобы не совершить ошибок в реальной программе, в которой все поведение может из-за этого встать с ног на голову :)
Комбинированные операции
Кроме того, в Java существуют так называемые комбинированные операции. В них используется комбинация из двух операций:
Присваивание
Арифметическая операция
Сюда входят операции:
+=
-=
*=
/=
%=
Рассмотрим пример:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
Вывод в консоль:
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);
}
}
Вывод в консоль:
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);
}
}
Вывод в консоль:
false
true
Результатом первой операции является false, поскольку одно из условий является ложным, а именно 100 > 200. Оператору && для того, чтобы вернуть true требуется, чтобы истинными были все условия (как во второй строке, например).
||, оператор "ИЛИ". Возвращает true, когда хотя бы один из операндов истинный.
Здесь наш предыдущий пример уже отработает по-другому:
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 || 100 > 200);
}
}
Вывод в консоль:
true
Выражение 100 > 200 по-прежнему ложно, но оператору "или" вполне достаточно, что первая часть (100 > 10) является истинной.
Сводная таблица операций над числами
Чтобы все операции были перед глазами, соберем их в одну таблицу:
Категория
Операторы
Что делают
Пример
Арифметические
+-*/
сложение, вычитание, умножение, деление
x + y
Остаток от деления
%
возвращает остаток от деления
33 % 2 дает 1
Сравнение
==!=><>=<=
сравнивают значения, результат boolean
x == y
Присваивание
=
задает переменной значение
x = 5
Унарный минус
-
меняет знак числа
x = -x
Инкремент и декремент
++--
увеличивает или уменьшает на 1
x++, x--
Комбинированные
+=-=*=/=%=
арифметическая операция плюс присваивание
x += y это x = x + y
Логические
!&&||
НЕ, И, ИЛИ для значений boolean
a && b
Часто числа, над которыми выполняются эти операции, вводит сам пользователь. Как считать их с клавиатуры, разобрано в статье про класс Scanner.
Читайте также
Класс Scanner: как считывать числа и строки с клавиатуры.
Принципы ООП: следующий большой шаг после базового синтаксиса.
Вопросы и ответы
Какие арифметические операции есть в Java?
Сложение (+), вычитание (-), умножение (*), деление (/) и остаток от деления (%).
Чем отличается = от == в Java?
Один знак = это присваивание (переменной задается значение), а два знака == это сравнение на равенство, которое возвращает true или false. Их путаница частая ошибка новичков.
Что делает оператор % (остаток от деления)?
Он возвращает остаток от деления одного числа на другое. Например, 33 % 2 равно 1.
Чем префиксный инкремент отличается от постфиксного?
При постфиксном x++ сначала используется текущее значение x, а потом оно увеличивается. При префиксном ++x значение сначала увеличивается, а потом используется.
Что такое комбинированные операции?
Это сокращения, объединяющие арифметику и присваивание: +=, -=, *=, /=, %=. Например, x += y означает x = x + y.
Как работают логические операторы && и ||?
&& (И) возвращает true, только если оба условия истинны. || (ИЛИ) возвращает true, если истинно хотя бы одно условие. ! (НЕ) меняет булево значение на противоположное.
Главный архитектор программного обеспечения в Tribunal de Justiça da Paraíba
Джесси - инженер-программист, увлеченный поиском решений, которые помогают людям жить лучше. Он работает с технологиями с 2008 год ...
[Читать полную биографию]
во с числами обожаю работать не то что с строками. за минуту всё пролистал и всё понял и запомнил)) ну точнее даже сказать напомнил себе. чё-то написано но можно не читать посмотрел пример кода и всё сразу становится понятно)
подскажите есть ли похожая статья по всем логическим операциям? хотелось бы подробно почитать про & | ^. И было бы здорово если кто даст ссылку про побитовые операции, вообще не знаком с ними
В далеких нулевых, когда все мы еще ощущали особую глубину интернета, а я был классе в 7 мне довелось взаимодействовать с Си подобным языком Pawn, на нем тогда можно было пилить сервера для GTA:Sa Online. Было очень ценно находить материалы для изучения и еще более ценным было когда, что-то получалось. Прошли года, прежде чем я твердо решил, что для самоуважения (и не только😉) необходимо полноценно освоить язык программирования. Выбрал Java. Повезло узнать о JavaRush. Уважаемые коллеги, спасибо за всю ту ГЛУБИНУ, которую я ощущаю на JavaRush. Это очень приятно! 👍
Совсем не догоняю логику как работает постфиксная операция в описанном примере.
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
999
1000
Говорится что сначала выполняется y = x (и переменной y будет присвоено изначальное значение x), а только потом x++.
Т.е значению y присваивается значение 999,а потом 1000.
Но зачем мне знать 2 присваеваемых значения y? Если выводится один x и один y.
Даже если так, y=1000, а x=999, то с ответами не бъется.
int y = x++;
следует читать так:
int y = x = x + 1;
- в случае "x++" сначала "y" будет присвоено текущее значение "x" (999), а затем "х" будет увеличен на 1;
- в случае "++x" сначала текущее значение "x" (999) будет увеличено на 1, а затем "y" будет присвоено значение "x" ( уже 1000).
Все еще не понимаю как компилятор читает код. Вроде как слева направо, но присвоение идет справа налево. А когда идет постфик++ сначала справа налево, а потом слева направо.
Как так работает, что у = сначала х, а только потом х++. Почему она сразу не присваивает? Вообщем, мне кажется нужна подробная лекция или объяснение о всей сути чтения программ.
компилятор читает последовательно по выражениям разделенным точкой с запятой. При чтении такого выражения нет никакого слева направо, а есть приоритет операций, про него тут пока информации действительно не давали. Про такие нюансы кстати постоянно забывают объяснять на многих курсах. Зато в любом стареньком ВУЗовском учебнике по программированию про это будет.
Купить нет, а почитать да. Лично я про приоритеты операций читал в учебнике МГТУ им Баумана. Г.С. Ивановой "Основы программирования" когда в вузе учился на начальных курсах. Учебник этот легко находится и скачивается в интернете.
Насчёт инкремента и декремента.
1.Постфиксная форма записи это i++. То есть переменной i сначала возвращается текущее значение, а после уже значение i увеличивается на 1.
2.Префиксная форма записи это ++i, то есть сразу значение i увеличится на 1, и после этого сразу же присвоится переменной i.
Самый простой пример.
5 % 2 = ?
1. Делимое делим на делитель: 5/2, будет 2.5, так стоит помнить что при делении целого числа на целое число остаток отбрасывается в меньшую сторону, получили 2.
2. Наше полученное 2 мы умножаем на делитель, то есть 2. 2*2 = 4.
3. Далее нашу полученную 4 мы отнимаем от делимого. 5 - 4 = 1.
Вот и всё: 5 % 2 = 1.
% - остаток от деления.
Ещё легче, просто капец:
5%2 = 1? Почему? Мы просто вмещаем 2 в 5 до того момента, пока 2 целиком не вместится в 5. То есть:
Берем 2 и вмещаем в 5, далее, делаем это еще раз, а вот уже на 3 раз, мы не можем вместить 2 в 5, остаток:1.
Подкреплю примерами:
8%3 = ? Окей, вмещаем 3 в 8, до того момента, пока 3 не сможет целиком вместиться в 8. То есть:
1 раз: 3 вместилось в 8, осталось 5.
2 раз: 3 вместилось в 8, осталось 2.
3 раз: 3 не вместилось в 8, осталось:2, вот и остаток от деления.
В общем, смысл поняли?
Здесь нет ошибки? Все корректно? Не совсем понятно как будет работать,если будет например 7 чисел,как будет работать сравнение?? По логике просто слева направо должно,а здесь все запутно
Если проще про постфиксный/префиксный инкремент:
(X++) Сначала возвращается текущее значение X (9) для использования в выражении, а затем значение X увеличивается на 1.
После выполнения X++,X становится равным 10
(++X) Сначала значение X увеличивается на 1, а затем новое значение (10) возвращается для использования в выражении.
После выполнения ++X, X становится равным 10.
p.s мог где-то ошибку допустить но всё вроде так)
Супер, отличное объяснение комбинированных операций. Когда первый раз проходил урок, не зашел на доп. лекции, а потом не понимал почему в задачах используют то, что мы не проходили, откуда там += какой-то)
Прежде чем решил оплатить курс я прошел бесплатную часть тут и на другом популЯрном сервисе. И вот там было объяснение инкремента i++, однако ничего про префиксную/постфиксную запись. И я не врубал почему не работает такой код:
int x = 2;
int y = 1;
System.out.println(x + y++);
Полезная лекция)
Мне в первое время приходилось задумываться когда я видел комбинированные операции типа x += y.
Мозг сразу не воспринимал что надо сделать. У кого такая же проблема попробуйте читать это следующим образом "x увеличить(+) на (=) y" или x /= y - читать как "x разделить (/) на (=) y"
Операций над числами в программировании существует великое множество, поэтому мы рассмотрим наиболее важные из них с примерами :)
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ