Как проверить, является ли объект Double равным null в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, является ли объект Double в Java равным null. Мы рассмотрим различия между примитивным типом double и оберточным классом Double, а также узнаем, как обрабатывать потенциальные ошибки NullPointerException.

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

Skills Graph

Проверка обёртки Double на null

На этом этапе мы рассмотрим, как работать с объектами обёртки Double в Java, в частности, как проверить, является ли переменная типа Double равной null. В отличие от примитивных типов, таких как double, обёрточные классы, такие как Double, могут иметь значение null, которое представляет отсутствие значения. Правильная обработка значений null является важной частью программирования на Java, чтобы избежать ошибок NullPointerException в ваших программах.

Создадим простую Java-программу, которая демонстрирует проверку объекта Double на null.

1. Откройте файл HelloJava.java в редакторе WebIDE. Если он не открыт, вы можете найти его в проводнике файлов слева в каталоге ~/project.

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

   public class HelloJava {
       public static void main(String[] args) {
           Double price = null; // Объявляем переменную типа Double и инициализируем ее значением null
   
           if (price == null) {
               System.out.println("Price is not set (it is null).");
           } else {
               System.out.println("Price is set to: " + price);
           }
   
           Double quantity = 10.5; // Объявляем еще одну переменную типа Double и присваиваем ей значение
   
           if (quantity == null) {
               System.out.println("Quantity is not set (it is null).");
           } else {
               System.out.println("Quantity is set to: " + quantity);
           }
       }
   }

   Рассмотрим новые части этого кода:

   • Double price = null;: Мы объявляем переменную с именем price типа Double и присваиваем ей значение null.
   • if (price == null): Это условный оператор if, который проверяет, равно ли значение переменной price null. Оператор == используется для сравнения, является ли ссылка на объект равной null.
   • System.out.println("Price is not set (it is null).");: Эта строка будет выполнена, если значение price действительно равно null.
   • Double quantity = 10.5;: Мы объявляем еще одну переменную типа Double с именем quantity и присваиваем ей числовое значение.
   • Второй условный оператор if проверяет, равно ли значение quantity null. Поскольку мы присвоили ей значение, это условие будет ложным.

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

4. Теперь скомпилируйте модифицированную программу. Откройте терминал внизу WebIDE и выполните следующую команду:

   javac HelloJava.java

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

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

   java HelloJava

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

   Price is not set (it is null).
   Quantity is set to: 10.5

   Этот вывод подтверждает, что наша программа правильно определила, что значение price было равно null, а переменная quantity имела значение.

Понимание того, как проверять на null, является фундаментальным навыком при работе с объектами Java, особенно с обёрточными классами. На следующем этапе мы рассмотрим разницу между Double со значением null и Double со значением ноль.

Обработка значений null и нуля

На предыдущем этапе мы научились проверять, является ли объект обёртки Double равным null. Теперь рассмотрим разницу между Double, имеющим значение null, и Double, имеющим значение ноль (0.0). Это различие важно, так как null означает "отсутствие значения", в то время как 0.0 - это конкретное числовое значение.

Представьте, что вы отслеживаете скидку, примененную к продукту. Скидка, равная null, может означать, что информация о скидке недоступна, в то время как скидка в размере 0.0 означает, что скидка явно не применена.

Давайте модифицируем нашу программу HelloJava.java, чтобы продемонстрировать эту разницу.

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

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

   public class HelloJava {
       public static void main(String[] args) {
           Double discount = null; // Discount information not available
   
           if (discount == null) {
               System.out.println("Discount information is not available (it is null).");
           } else if (discount == 0.0) {
               System.out.println("There is no discount (value is 0.0).");
           } else {
               System.out.println("Discount applied: " + discount);
           }
   
           System.out.println("---"); // Separator for clarity
   
           Double zeroDiscount = 0.0; // Explicitly no discount
   
           if (zeroDiscount == null) {
               System.out.println("Discount information is not available (it is null).");
           } else if (zeroDiscount == 0.0) {
               System.out.println("There is no discount (value is 0.0).");
           } else {
               System.out.println("Discount applied: " + zeroDiscount);
           }
   
           System.out.println("---"); // Separator for clarity
   
           Double appliedDiscount = 5.5; // A specific discount value
   
           if (appliedDiscount == null) {
               System.out.println("Discount information is not available (it is null).");
           } else if (appliedDiscount == 0.0) {
               System.out.println("There is no discount (value is 0.0).");
           } else {
               System.out.println("Discount applied: " + appliedDiscount);
           }
       }
   }

   В этом обновленном коде:

   • Мы вводим три переменные типа Double: discount (инициализированную значением null), zeroDiscount (инициализированную значением 0.0) и appliedDiscount (инициализированную значением 5.5).
   • Мы используем структуру if-else if-else для проверки состояния каждой переменной:
     • Сначала мы проверяем, является ли переменная равной null.
     • Если она не равна null, то мы проверяем, равно ли ее значение 0.0.
     • В противном случае мы предполагаем, что применена конкретная скидка.

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

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

   javac HelloJava.java

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

   java HelloJava

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

   Discount information is not available (it is null).
   ---
   There is no discount (value is 0.0).
   ---
   Discount applied: 5.5

   Этот вывод четко показывает, как Java различает Double со значением null и Double со значением 0.0. Правильная обработка этих случаев является важной частью написания надежных Java-приложений.

На следующем этапе мы рассмотрим более современный подход к обработке потенциальных значений null с использованием класса Optional, который может сделать ваш код более безопасным и читаемым.

Тестирование с использованием класса Optional

В современной Java (Java 8 и выше) класс Optional часто используется для представления значения, которое может быть или отсутствовать. Это предоставляет более явный и безопасный способ обработки потенциальных значений null по сравнению с простым использованием ссылок на null. Использование Optional может помочь предотвратить ошибки NullPointerException и сделать ваш код более читаемым.

Давайте перепишем наш пример скидки, используя класс Optional<Double>.

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

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

   import java.util.Optional;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Representing a discount that might be null
           Optional<Double> optionalDiscount = Optional.empty();
   
           if (optionalDiscount.isPresent()) {
               System.out.println("Discount is present: " + optionalDiscount.get());
           } else {
               System.out.println("Discount is not present (Optional is empty).");
           }
   
           System.out.println("---"); // Separator for clarity
   
           // Representing a discount with a value of 0.0
           Optional<Double> optionalZeroDiscount = Optional.of(0.0);
   
           if (optionalZeroDiscount.isPresent()) {
               System.out.println("Discount is present: " + optionalZeroDiscount.get());
           } else {
               System.out.println("Discount is not present (Optional is empty).");
           }
   
           System.out.println("---"); // Separator for clarity
   
           // Representing a discount with a specific value
           Optional<Double> optionalAppliedDiscount = Optional.of(5.5);
   
           if (optionalAppliedDiscount.isPresent()) {
               System.out.println("Discount is present: " + optionalAppliedDiscount.get());
           } else {
               System.out.println("Discount is not present (Optional is empty).");
           }
   
           System.out.println("---"); // Separator for clarity
   
           // A common way to handle Optional: using orElse
           Double finalDiscount = optionalDiscount.orElse(0.0);
           System.out.println("Using orElse: Final discount is " + finalDiscount);
   
           Double finalZeroDiscount = optionalZeroDiscount.orElse(0.0);
           System.out.println("Using orElse: Final zero discount is " + finalZeroDiscount);
       }
   }

   Рассмотрим ключевые изменения:

   • import java.util.Optional;: Мы импортируем класс Optional.
   • Optional<Double> optionalDiscount = Optional.empty();: Мы создаем пустой Optional<Double>, представляющий отсутствие значения скидки.
   • Optional<Double> optionalZeroDiscount = Optional.of(0.0);: Мы создаем Optional<Double>, содержащий значение 0.0. Метод Optional.of() используется, когда вы уверены, что значение не равно null.
   • Optional<Double> optionalAppliedDiscount = Optional.of(5.5);: Мы создаем Optional<Double>, содержащий значение 5.5.
   • optionalDiscount.isPresent(): Этот метод проверяет, содержит ли Optional значение. Это рекомендуемый способ проверки вместо сравнения с null.
   • optionalDiscount.get(): Этот метод извлекает значение из Optional. Обратите внимание: Если Optional пуст, вызов get() вызовет исключение NoSuchElementException. Всегда проверяйте isPresent() перед вызовом get() или используйте альтернативные методы, такие как orElse().
   • optionalDiscount.orElse(0.0): Этот метод возвращает значение внутри Optional, если оно присутствует; в противном случае он возвращает предоставленное значение по умолчанию (в данном случае 0.0). Это безопасный способ получить значение и обработать случай, когда Optional пуст.

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

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

   javac HelloJava.java

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

   java HelloJava

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

   Discount is not present (Optional is empty).
   ---
   Discount is present: 0.0
   ---
   Discount is present: 5.5
   ---
   Using orElse: Final discount is 0.0
   Using orElse: Final zero discount is 0.0

   Этот вывод демонстрирует, как Optional помогает нам явно обрабатывать случаи, когда значение может отсутствовать. Использование Optional может привести к более чистому и надежному коду, уменьшая риск NullPointerException.

Теперь вы узнали, как проверять на null объекты обёртки Double, различать значения null и ноль, а также использовать класс Optional для более безопасной обработки потенциально отсутствующих значений. Эти важные концепции для написания надежного кода на Java.

Резюме

В этом практическом занятии мы научились проверять, является ли объект-обёртка Double в Java равным null. Мы увидели, что в отличие от примитивного типа double, тип Double может иметь значение null. Мы показали, как использовать сравнение == null для проверки отсутствия значения в переменной типа Double и предотвращения потенциальных ошибок NullPointerException. Мы также рассмотрели разницу между значением null и нулевым значением для объекта Double и научились корректно обрабатывать оба случая. Наконец, мы познакомились с классом Optional как современным подходом в Java для более явной и безопасной обработки потенциальных значений null.