Java не равно оператор

Логические операции — Основы Java

В этом уроке мы разберем логические операции, научимся использовать логические выражения и писать методы-предикаты.

Операции сравнения

Кроме арифметических операций, из школьной математики нам известны еще и операции сравнения, например:

Это звучит как вопрос: «Пять больше четырех?». В данном случае, ответ «да». В других случаях, ответом может быть «нет», например, для такого выражения:

Операции сравнения не имеют привязки к числам. Сравнивать можно практически что угодно — например, строки. Когда мы входим на какой-то сайт, внутри происходит сравнение введенного логина и пароля с теми, какие есть в базе. Если совпадение есть, то происходит авторизация.

Языки программирования адаптировали все математические операции сравнения практически в неизменном виде. Единственное серьезное отличие – операторы равенства и неравенства.

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

Список операций сравнения в Java:

Посмотрим на пару примеров логических операций:

Оба примера — это выражения. Результат вычисления этих выражений — это одно из двух специальных значений:

Это новый для нас тип данных — boolean. Он содержит всего лишь два этих значения. Так выглядит пример кода с ним:

var result = 5 > 4; System.out.println(result); // => true 

Попробуем написать метод, который принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года:

// Метод, возвращающий boolean, называется предикатом // Обычно такие методы имеют префикс has, can, is, was и так далее public static boolean isInfant(int age)  return age  1; > 

Пользуемся тем фактом, что любая операция — это выражение. Поэтому единственной строчкой функции пишем «вернуть то значение, которое получится в результате сравнения age < 1 ».

В зависимости от пришедшего параметра, сравнение будет либо истинным ( true ), либо ложным ( false ). В итоге return вернет этот результат:

System.out.println(App.isInfant(3)); // => false System.out.println(App.isInfant(0)); // => true 

Сравнение строк

Посмотрите на код и попытайтесь ответить, чему равны значения этих выражений:

// Какой результат будет в этих примерах — `true` или `false`? "a" == "a"; "a".toUpperCase() == "a".toUpperCase(); 

Правильный ответ: в первом случае true , во втором — false . Почему? Для ответа на этот вопрос нужно немного погрузиться в то, как работают компьютеры.

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

Так свою работу видит программист. Но внутри компьютера все немного по-другому. Во время работы программа получает доступ и манипулирует данными через их адреса в памяти:

// Под хранение переменной выделяется область памяти // Программа запоминает адрес этой области и работает с ней внутри себя var name = "CodeBasics"; // Программа считала значение переменной по адресу, где хранится значение System.out.println(name); 

Память — это большая область для хранения данных, которая очень похожа на склад. В памяти любое значение получает номер, по которому его можно извлечь и заменить. Этот номер и есть адрес.

Сравнение по ссылке и по значению

Из-за этих технических особенностей на сравнение данных между собой можно смотреть двумя способами:

• То же самое — тот же участок памяти
• Такое же — одинаковые значения независимо от того, куда указывают адреса

Пример из реальной жизни: два одинаковых стакана из одного набора. Несмотря на свою одинаковость, все же разные стаканы.

Языки программирования по-разному работают с этими понятиями. Как и во многих других языках, в Java все данные делятся на два больших типа:

• Примитивные данные сравниваются по значению, независимо от адресов
• Ссылочные данные сравниваются по адресам

Так работают примитивные данные:

// Сравнение идет по значению, а не адресам 4 == 4; // true true == true; // true 10.0 == 10.0; // true 

Из ссылочных данных мы пока знакомы только со строками, но они работают хитро, поэтому в качестве примера посмотрим на массивы. Не обращайте внимание на незнакомый синтаксис. Просто обратите внимание, что в этом коде вроде бы одинаковые штуки не равны друг другу:

// Создание массивов int[] a = 1, 2> int[] b = 1, 2> // Значения одинаковые, но ссылки разные a == b; // false 

Особенности строк

Строки относятся к ссылочным типам данных, но ведут себя странно:

// Сравнение, как у примитивных типов данных "hm" == "hm"; // true // Сравнение, как у ссылочных типов данных "hexlet".toUpperCase() == "hexlet".toUpperCase(); // false 

Программы постоянно оперируют строками, поэтому эффективность работы с ними выходит на первое место. Если бы строка всегда вела себя как ссылочный тип, то на каждое значение в коде выделялась дополнительная память:

// Без оптимизаций это выражение привело бы к двойному выделению памяти // По одной единице памяти на каждый "hm" "hm" == "hm"; 

Но этого не происходит. Когда Java встречает явно создаваемую строку, выполняется проверка, а есть ли уже в памяти такая строка.

Если есть, то она переиспользуется, если нет — создается:

// Выделяется память var name1 = "Java"; // Такая строка уже есть, поэтому подставляется ссылка на уже созданную строку // В результате экономится память var name2 = "Java"; // Сравнение по ссылке // Обе переменные указывают на один участок памяти name1 == name2; // true 

Но если строка возвращается из метода, то она помещается в свою область памяти со своим уникальным адресом:

// Выделяется новая память в любом случае var name1 = "java".toUpperCase(); // "JAVA" // Выделяется новая память в любом случае var name2 = "java".toUpperCase(); // "JAVA" name1 == name2; // false 

Может показаться, что ссылочные данные приносят сплошные проблемы. На самом деле они нужны. Это станет понятно, когда мы столкнемся с изменяемостью в будущем.

В прикладном программировании мы чаще сравниваем строки по значению, чем по ссылке. Для этого в строки встроен метод equals() :

var name1 = "java".toUpperCase(); // "JAVA" var name2 = "java".toUpperCase(); // "JAVA" name1.equals(name2); // true 

Помимо equals() , в строки встроен метод equalsIgnoreCase() , который выполняет проверку по значению без учета регистра:

var name1 = "java".toUpperCase(); // "JAVA" var name2 = "java".toLowerCase(); // "java" name1.equalsIgnoreCase(name2); // true 

Иногда сравнение строк в Java ведет себя как сравнение значений, но никогда не делайте ставку на это. При изменении кода легко забыть поправить проверку и получить ошибку. Всегда используйте методы, когда нужно сравнивать по значению.

Комбинирование операций и методов

Логические операции — это выражения. Значит, логические операции можно комбинировать с другими выражениями. Разберем на примере. Допустим, мы хотим проверить четность числа. В программировании четность проверяется через остаток от деления на 2:

Остаток от деления — простая, но очень важная концепция в арифметике, алгебре, теории чисел и криптографии. Идея проста: нужно разделить число на несколько равных групп. Если в конце что-то останется, это и есть остаток от деления.

Делим конфеты поровну между людьми:

• 7 конфет, 2 человека: 2 x 3 + остаток 1. Значит, 7 не кратно 2
• 21 конфету, 3 человека: 3 x 7 + остаток 0. Значит, 21 кратно 3
• 19 конфет, 5 человек: 5 x 3 + остаток 4. Значит, 19 не кратно 5

В коде остаток вычисляется с помощью оператора % :

С помощью него напишем метод для проверки четности:

// Определен в классе App public static boolean isEven(int number)  return number % 2 == 0; > App.isEven(10); // true App.isEven(3); // false 

В одном выражении мы скомбинировали два логических оператора:

Приоритет арифметических операций выше логических. Значит, сначала вычисляется арифметическое выражение number % 2 , затем результат участвует в логическом сравнении.

По-русски это можно расшифровать так: «Нужно вычислить остаток от деления числа number на 2 и сравнить с нулем; затем вернуть результат сравнения».

Рассмотрим еще один пример. Напишем метод, который принимает строку и проверяет, заглавная ли первая буква. Алгоритм действий будет такой:

1. Получим и запишем в переменную первый символ из строки-аргумента
2. Сравним, равен ли символ своей заглавной версии
3. Вернем результат

А так будет выглядеть реализация в коде:

public static boolean isFirstLetterInUpperCase(String string)  var firstLetter = string.charAt(0); // Класс Character содержит различные методы для работы с символом // Метод isUpperCase() проверяет, что переданный символ в верхнем регистре return Character.isUpperCase(firstLetter); > App.isFirstLetterInUpperCase("marmont"); // false App.isFirstLetterInUpperCase("Robb"); // true 

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Источник

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

Операторы сравнения выдают логический результат (boolean). Если условие проверки истинно, оператор выдает true, а если ложно — false. К операторам сравнения относятся (меньше чем), > (больше чем), (меньше чем или равно), >= (больше чем или равно), == (равно), != (не равно). Операторы «Равно» и «не равно» можно использовать для всех примитивных типов данных, однако остальные сравнения нельзя использовать к типу boolean.

 int x = 5; int y = 7; boolean z = a < b; // результат сохраняется в переменной типа boolean 

 int cat_age; if(cat_age == 4) // нельзя if(cat_age) - нет сравнения if(cat_age != 9) // нельзя if(!cat_age) - нет сравнения 

 boolean a = true; boolean b; b = a || true; // b истинно b = !b; // b ложно System.out.println(b); // выведет false a = a || b; // a истинно boolean c; c = a && (a||b); //с истинно System.out.println(c); // выведет true 

 boolean m; m = 5 >= 4; // истина m = 5 != 5 || false; // ложь boolean w; w = m == false; // истина System.out.println(w); // выведет true 

 // Пример 1 int a = 25; if (a != 0) System.out.println( 100/a ); // Пример 2 int b = 25; if (b != 0) < System.out.println( 100/b ); >

 if (условие) инструкция1; else инструкция2; 

 int a = 0; if (a != 0) System.out.println( 100/a ); else System.out.println("На нуль делить нельзя");