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

Введение

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

Skills Graph

Использование метода Double.isNaN() для проверки

На этом этапе мы научимся проверять, является ли число с плавающей запятой "Не числом" (NaN) в Java с помощью метода Double.isNaN().

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

Важно уметь обнаруживать значения NaN в своих программах, так как они ведут себя иначе, чем обычные числа. Например, сравнение значения NaN с любым другим числом (даже с другим NaN) с использованием стандартных операторов сравнения (==, <, >) всегда даст false.

Java предоставляет специальный метод для проверки на NaN: Double.isNaN(). Этот метод принимает значение типа double в качестве входных данных и возвращает true, если значение является NaN, и false в противном случае.

Создадим простую Java-программу, чтобы показать, как использовать Double.isNaN().

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

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

   public class CheckNaN {
       public static void main(String[] args) {
           double result1 = 0.0 / 0.0; // This will result in NaN
           double result2 = 10.0 / 2.0; // This is a regular number
   
           System.out.println("Is result1 NaN? " + Double.isNaN(result1));
           System.out.println("Is result2 NaN? " + Double.isNaN(result2));
       }
   }

   В этом коде:

   • Мы объявляем две переменные типа double, result1 и result2.
   • Переменной result1 присваивается результат выражения 0.0 / 0.0, которое представляет собой неопределенную форму и даст значение NaN.
   • Переменной result2 присваивается результат выражения 10.0 / 2.0, которое представляет собой обычное число (5.0).
   • Затем мы используем метод Double.isNaN() для проверки, являются ли result1 и result2 значениями NaN, и выводим результаты.

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

4. Теперь нам нужно скомпилировать эту новую программу. Поскольку мы изменили имя класса на CheckNaN, нам нужно скомпилировать файл CheckNaN.java. Откройте терминал и выполните следующую команду:

   javac CheckNaN.java

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

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

   java CheckNaN

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

   Is result1 NaN? true
   Is result2 NaN? false

   Этот вывод подтверждает, что метод Double.isNaN() правильно определил result1 как значение NaN и result2 как обычное число.

Использование метода Double.isNaN() является правильным и надежным способом проверки на значения NaN в Java. Не рекомендуется полагаться на прямое сравнение (== Double.NaN), так как, как упоминалось ранее, выражение NaN == NaN возвращает false.

Тестирование с использованием операций с плавающей запятой

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

Кроме деления нуля на ноль, другие операции, связанные с бесконечностью или некорректными математическими функциями, также могут привести к значению NaN. Java имеет специальные представления для положительной и отрицательной бесконечности (Double.POSITIVE_INFINITY и Double.NEGATIVE_INFINITY).

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

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

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

   public class CheckNaN {
       public static void main(String[] args) {
           double result1 = 0.0 / 0.0; // NaN
           double result2 = Math.sqrt(-1.0); // NaN (square root of a negative number)
           double result3 = Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY; // NaN
           double result4 = 10.0 / 0.0; // Positive Infinity
           double result5 = -10.0 / 0.0; // Negative Infinity
           double result6 = 5.0; // Regular number
   
           System.out.println("Is result1 NaN? " + Double.isNaN(result1));
           System.out.println("Is result2 NaN? " + Double.isNaN(result2));
           System.out.println("Is result3 NaN? " + Double.isNaN(result3));
           System.out.println("Is result4 NaN? " + Double.isNaN(result4));
           System.out.println("Is result5 NaN? " + Double.isNaN(result5));
           System.out.println("Is result6 NaN? " + Double.isNaN(result6));
       }
   }

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

   • result1 по-прежнему представляет собой 0.0 / 0.0.
   • result2 использует Math.sqrt(-1.0), которое математически не определено для действительных чисел и приводит к значению NaN.
   • result3 представляет собой вычитание положительной бесконечности из положительной бесконечности, что является еще одной неопределенной формой и приводит к значению NaN.
   • result4 и result5 демонстрируют деление на ноль, которое приводит к положительной или отрицательной бесконечности, а не к значению NaN.
   • result6 - это простое число для сравнения.

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

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

   javac CheckNaN.java

   Опять же, отсутствие вывода означает успешную компиляцию.

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

   java CheckNaN

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

   Is result1 NaN? true
   Is result2 NaN? true
   Is result3 NaN? true
   Is result4 NaN? false
   Is result5 NaN? false
   Is result6 NaN? false

   Этот вывод показывает, что метод Double.isNaN() правильно определил три операции, которые приводят к значению NaN, и также правильно определил значения бесконечности и обычное число как не являющиеся значением NaN.

Тестирование различных операций с плавающей запятой позволяет вам лучше понять, когда может возникнуть значение NaN и как использовать метод Double.isNaN() для обработки таких случаев в своих программах.

Обработка нечисловых входных данных

В предыдущих шагах мы сосредоточились на том, как операции с плавающей запятой могут привести к значению NaN. Однако иногда вы можете получить входные данные, которые вовсе не являются допустимыми числами, например, текст. При попытке преобразования таких входных данных в число с плавающей запятой также могут возникнуть проблемы.

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

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

1. Создайте новый файл в директории ~/project с именем ParseAndCheck.java. Вы можете сделать это, щелкнув правой кнопкой мыши в проводнике файлов и выбрав "Новый файл", а затем введя ParseAndCheck.java.

2. Откройте файл ParseAndCheck.java в редакторе WebIDE и добавьте следующий код:

   import java.util.Scanner;
   
   public class ParseAndCheck {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
           System.out.print("Enter a floating-point number or an expression (e.g., 0.0/0.0): ");
           String input = scanner.nextLine();
   
           try {
               double value = Double.parseDouble(input);
   
               if (Double.isNaN(value)) {
                   System.out.println("The input resulted in NaN.");
               } else {
                   System.out.println("The input is a valid number: " + value);
               }
           } catch (NumberFormatException e) {
               System.out.println("Invalid input: Could not parse as a number.");
           } finally {
               scanner.close();
           }
       }
   }

   Разберем этот код:

   • Мы импортируем класс Scanner для чтения пользовательского ввода.
   • Мы просим пользователя ввести строку.
   • Мы используем блок try-catch для обработки возможных ошибок при преобразовании.
   • Double.parseDouble(input) пытается преобразовать входную строку в число типа double. Если строка не имеет допустимый числовой формат (например, "hello"), будет выброшено исключение NumberFormatException.
   • Внутри блока try, если преобразование прошло успешно, мы используем метод Double.isNaN(value) для проверки, является ли полученное число NaN.
   • Блок catch перехватывает исключение NumberFormatException и выводит сообщение об ошибке, если входные данные не могут быть преобразованы.
   • Блок finally гарантирует, что сканер будет закрыт.

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

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

   javac ParseAndCheck.java

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

   java ParseAndCheck

   Программа попросит вас ввести данные. Попробуйте ввести разные значения:

   • Введите 5.5:

     Enter a floating-point number or an expression (e.g., 0.0/0.0): 5.5
     The input is a valid number: 5.5

   • Введите 0.0/0.0:

     Enter a floating-point number or an expression (e.g., 0.0/0.0): 0.0/0.0
     Invalid input: Could not parse as a number.

     (Примечание: метод parseDouble не может напрямую вычислять математические выражения. Он только преобразует строковые представления чисел.)
   • Введите NaN:

     Enter a floating-point number or an expression (e.g., 0.0/0.0): NaN
     The input resulted in NaN.

   • Введите hello:

     Enter a floating-point number or an expression (e.g., 0.0/0.0): hello
     Invalid input: Could not parse as a number.

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

Резюме

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

Мы сосредоточились на использовании метода Double.isNaN(), который является стандартным и рекомендуемым способом точного определения значений NaN в Java. Мы продемонстрировали его использование на примерах операций с плавающей запятой, которые приводят к получению NaN, а также на примерах с обычными числовыми результатами.