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

Введение

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

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

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

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

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

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

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

Откройте файл HelloJava.java в редакторе WebIDE.
Замените существующий код следующим:
```
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, и выводим результаты.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь нам нужно скомпилировать эту новую программу. Поскольку мы изменили имя класса на CheckNaN, нам нужно скомпилировать файл CheckNaN.java. Откройте терминал и выполните следующую команду:
```
javac CheckNaN.java
```
Если компиляция прошла успешно, вы не должны увидеть никакого вывода.
Наконец, запустите скомпилированную программу:
```
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, чтобы протестировать некоторые из этих случаев.

Откройте файл CheckNaN.java в редакторе WebIDE.
Замените существующий код следующим:
```
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 - это простое число для сравнения.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в терминале:
```
javac CheckNaN.java
```
Опять же, отсутствие вывода означает успешную компиляцию.
Запустите программу:
```
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.

Создайте новый файл в директории ~/project с именем ParseAndCheck.java. Вы можете сделать это, щелкнув правой кнопкой мыши в проводнике файлов и выбрав "Новый файл", а затем введя ParseAndCheck.java.
Откройте файл 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 гарантирует, что сканер будет закрыт.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу в терминале:
```
javac ParseAndCheck.java
```
Запустите программу:
```
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, а также на примерах с обычными числовыми результатами.