Как проверить, является ли число нулем в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, является ли число нулем на Java. Этот фундаментальный навык важен для управления потоком выполнения программы с использованием условных операторов. Мы начнем с изучения использования оператора равенства (==) для сравнения целочисленных значений с нулем.

После этого мы рассмотрим особые аспекты и возможные подводные камни при работе с числами с плавающей запятой и нулем из-за проблем с точностью. Наконец, мы изучим, как выполнять проверки на равенство нулю при работе с обертками (wrapper classes) примитивных типов в Java.

Использование оператора равенства для проверки на ноль

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

В Java оператор равенства обозначается ==. Он используется для сравнения двух значений и возвращает true, если они равны, и false в противном случае.

Создадим простую Java-программу, чтобы продемонстрировать это.

1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

2. Замените все содержимое файла следующим кодом:

   public class HelloJava {
       public static void main(String[] args) {
           int number = 0;
   
           if (number == 0) {
               System.out.println("The number is zero.");
           } else {
               System.out.println("The number is not zero.");
           }
       }
   }
   

   Разберем этот новый код:

   • int number = 0;: Эта строка объявляет целочисленную переменную с именем number и инициализирует ее значением 0.
   • if (number == 0): Это оператор if, который используется для принятия решений в коде. Условие в скобках (number == 0) проверяет, равно ли значение переменной number 0.
   • System.out.println("The number is zero.");: Эта строка будет выполнена только в том случае, если условие number == 0 равно true.
   • else: Это ключевое слово представляет блок кода, который будет выполнен, если условие оператора if равно false.
   • System.out.println("The number is not zero.");: Эта строка будет выполнена только в том случае, если условие number == 0 равно false.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Теперь скомпилируем нашу модифицированную программу. В терминале убедитесь, что вы находитесь в директории ~/project. Если необходимо, используйте команду cd ~/project. Затем выполните:

   javac HelloJava.java
   

   Если компиляция прошла успешно, вы не увидите никакого вывода.

5. Наконец, запустим нашу программу:

   java HelloJava
   

   Вы должны увидеть следующий вывод:

   The number is zero.
   

   Это подтверждает, что наша программа правильно проверила, равно ли значение переменной number нулю с использованием оператора ==.

Теперь попробуйте изменить значение переменной number на ненулевое (например, int number = 5;), сохранить файл, перекомпилировать и запустить программу снова, чтобы увидеть другой вывод.

Обработка точности чисел с плавающей запятой

На этом этапе мы рассмотрим общую проблему при работе с числами с плавающей запятой (числами с десятичной точкой) в программировании: точность. Из-за того, как компьютеры хранят эти числа, прямые сравнения на равенство с использованием == иногда могут привести к неожиданным результатам.

Давайте посмотрим, как это работает.

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените существующий код следующим:

   public class HelloJava {
       public static void main(String[] args) {
           double num1 = 0.1 + 0.2;
           double num2 = 0.3;
   
           System.out.println("num1: " + num1);
           System.out.println("num2: " + num2);
   
           if (num1 == num2) {
               System.out.println("num1 is equal to num2.");
           } else {
               System.out.println("num1 is not equal to num2.");
           }
       }
   }
   

   В этом коде:

   • Мы объявляем две переменные типа double, num1 и num2. double - это тип данных в Java, используемый для хранения чисел с плавающей запятой.
   • Мы присваиваем значение 0.1 + 0.2 переменной num1 и 0.3 переменной num2. Математически эти значения должны быть равны.
   • Мы выводим значения num1 и num2, чтобы увидеть их точное представление.
   • Мы используем оператор == для проверки, равно ли num1 num2.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java
   

5. Запустите скомпилированную программу:

   java HelloJava
   

   Вы, возможно, будете удивлены выводом:

   num1: 0.30000000000000004
   num2: 0.3
   num1 is not equal to num2.
   

   Как вы можете видеть, num1 не является точно равным 0.3 из-за способа хранения чисел с плавающей запятой. Это общая проблема, и именно поэтому прямое сравнение чисел с плавающей запятой на равенство с использованием == обычно не рекомендуется.

Для обработки этой проблемы, вместо проверки на точное равенство, мы обычно проверяем, находится ли абсолютная разность между двумя числами в пределах очень малой допустимой погрешности (часто называемой "эпсилон").

Давайте модифицируем код, чтобы использовать этот подход.

1. Откройте HelloJava.java снова.

2. Замените оператор if следующим:

   double epsilon = 0.000001; // A small tolerance
   
   if (Math.abs(num1 - num2) < epsilon) {
       System.out.println("num1 is approximately equal to num2.");
   } else {
       System.out.println("num1 is not approximately equal to num2.");
   }
   

   Здесь:

   • Мы определяем небольшое значение epsilon.
   • Math.abs(num1 - num2) вычисляет абсолютную разность между num1 и num2.
   • Мы проверяем, меньше ли эта абсолютная разность нашего epsilon.

3. Сохраните файл.

4. Скомпилируйте программу:

   javac HelloJava.java
   

5. Запустите программу:

   java HelloJava
   

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

   num1: 0.30000000000000004
   num2: 0.3
   num1 is approximately equal to num2.
   

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

Тестирование с использованием обёрточных классов

На этом этапе мы рассмотрим, как работает сравнение на равенство с оберточными классами Java. Оберточные классы - это специальные классы, которые позволяют использовать примитивные типы данных (например, int, double, boolean) как объекты. Например, оберточным классом для int является Integer, а для double - Double.

При сравнении объектов в Java оператор == проверяет, ссылаются ли две переменные на один и тот же объект в памяти, а не на то, равны ли их значения. Чтобы сравнить значения объектов, вы должны использовать метод equals().

Давайте посмотрим, как это применяется к оберточным классам.

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените существующий код следующим:

   public class HelloJava {
       public static void main(String[] args) {
           Integer intObj1 = new Integer(100);
           Integer intObj2 = new Integer(100);
           Integer intObj3 = intObj1; // intObj3 refers to the same object as intObj1
   
           System.out.println("Comparing Integer objects with ==:");
           if (intObj1 == intObj2) {
               System.out.println("intObj1 == intObj2 is true");
           } else {
               System.out.println("intObj1 == intObj2 is false");
           }
   
           if (intObj1 == intObj3) {
               System.out.println("intObj1 == intObj3 is true");
           } else {
               System.out.println("intObj1 == intObj3 is false");
           }
   
           System.out.println("\nComparing Integer objects with equals():");
           if (intObj1.equals(intObj2)) {
               System.out.println("intObj1.equals(intObj2) is true");
           } else {
               System.out.println("intObj1.equals(intObj2) is false");
           }
   
           if (intObj1.equals(intObj3)) {
               System.out.println("intObj1.equals(intObj3) is true");
           } else {
               System.out.println("intObj1.equals(intObj3) is false");
           }
       }
   }
   

   В этом коде:

   • Мы создаем два объекта Integer, intObj1 и intObj2, с одинаковым значением (100) с использованием new Integer(). Это создает два отдельных объекта в памяти.
   • Мы создаем intObj3 и присваиваем ему intObj1. Это означает, что intObj3 и intObj1 теперь ссылаются на один и тот же объект в памяти.
   • Мы используем == для сравнения intObj1 с intObj2 и intObj3.
   • Мы используем метод equals() для сравнения значений intObj1 с intObj2 и intObj3.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java
   

5. Запустите скомпилированную программу:

   java HelloJava
   

   Вывод должен быть таким:

   Comparing Integer objects with ==:
   intObj1 == intObj2 is false
   intObj1 == intObj3 is true
   
   Comparing Integer objects with equals():
   intObj1.equals(intObj2) is true
   intObj1.equals(intObj3) is true
   

   Этот вывод четко показывает разницу:

   • intObj1 == intObj2 равно false, потому что они - разные объекты в памяти, даже если их значения одинаковы.
   • intObj1 == intObj3 равно true, потому что они ссылаются на один и тот же объект.
   • intObj1.equals(intObj2) равно true, потому что метод equals() сравнивает значения объектов, которые оба равны 100.
   • intObj1.equals(intObj3) также равно true, потому что они ссылаются на один и тот же объект, и их значения одинаковы.

   Важное примечание: Для небольших целочисленных значений (обычно от -128 до 127) Java использует кэш для объектов Integer. Это означает, что Integer intObjA = 50; Integer intObjB = 50; может привести к тому, что intObjA == intObjB будет true, потому что они могут ссылаться на один и тот же кэшированный объект. Однако полагаться на это кэширование при проверках на равенство не рекомендуется. Всегда используйте метод equals() для сравнения значений объектов оберточных классов.

Этот этап подчеркивает важную разницу между сравнением примитивных типов и объектов в Java и важность использования метода equals() для сравнения значений объектов.

Резюме

В этом практическом занятии (лабораторной работе) мы научились проверять, является ли число нулем в Java. Мы начали с использования фундаментального оператора равенства (==) для сравнения целочисленной переменной с нулем в операторе if. Это продемонстрировало базовый принцип условных проверок на основе числового равенства.

Затем мы рассмотрели тонкости работы с числами с плавающей запятой и потенциальные проблемы с точностью, которые возникают при их прямом сравнении с нулем с использованием ==. Наконец, мы изучили, как выполнять проверки на ноль с помощью оберточных классов Java, поняв, как получить доступ к и сравнить базовые примитивные значения.