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

Логический тип

Кроме арифметических операций со школы нам известны операции сравнения. Например, 5 > 4. Это звучит как вопрос: «5 больше 4?». В данном случае ответ «да». В других случаях ответом может быть «нет», например, для 3 < 1.

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

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

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

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

Логическая операция типа 5 > 4 или password == text — это выражение, и его результат — специальное значение true («истина») или false («ложь»). Это новый для нас тип данных — 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:

• если остаток 0, то число было чётным
• если остаток не 0, то число было нечётным

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

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

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

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

• 7 % 2 → 1
• 21 % 3 → 0
• 19 % 5 → 4

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

// Определен в классе 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);
    // Проверяет то, что переданный символ в верхнем регистре
    return Character.isUpperCase(firstLetter);
}

App.isFirstLetterInUpperCase("marmont"); // false
App.isFirstLetterInUpperCase("Robb"); // true

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

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