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

Введение

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

С помощью практических упражнений вы будете использовать метод Double.isInfinite() для определения бесконечных значений, изучать, как деление на ноль может привести к бесконечности, и понимать разницу между бесконечными значениями и NaN (Not-a-Number - нечисло).

Skills Graph

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

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

В Java в классе Double предусмотрен встроенный метод isInfinite() специально для этой цели.

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

1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт. Вы должны находиться в директории ~/project.

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

   public class HelloJava {
       public static void main(String[] args) {
           double positiveInfinity = Double.POSITIVE_INFINITY;
           double negativeInfinity = Double.NEGATIVE_INFINITY;
           double finiteNumber = 10.0;
   
           System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));
           System.out.println("Is negativeInfinity infinite? " + Double.isInfinite(negativeInfinity));
           System.out.println("Is finiteNumber infinite? " + Double.isInfinite(finiteNumber));
       }
   }

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

   • double positiveInfinity = Double.POSITIVE_INFINITY;: Эта строка объявляет переменную типа double и присваивает ей специальное значение, представляющее положительную бесконечность.
   • double negativeInfinity = Double.NEGATIVE_INFINITY;: Эта строка объявляет переменную типа double и присваивает ей специальное значение, представляющее отрицательную бесконечность.
   • double finiteNumber = 10.0;: Эта строка объявляет обычную переменную типа double с конечным значением.
   • System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));: Эта строка вызывает метод Double.isInfinite() с аргументом positiveInfinity. Метод возвращает true, если значение является бесконечным (положительной или отрицательной), и false в противном случае. Затем результат выводится в консоль.
   • Следующие две строки System.out.println выполняют то же самое для negativeInfinity и finiteNumber.

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

4. Теперь скомпилируем нашу программу. Откройте терминал в нижней части WebIDE и убедитесь, что вы находитесь в директории ~/project. Выполните следующую команду:

   javac HelloJava.java

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

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

   java HelloJava

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

   Is positiveInfinity infinite? true
   Is negativeInfinity infinite? true
   Is finiteNumber infinite? false

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

Тестирование делением на ноль

На предыдущем этапе мы увидели, как работает метод Double.isInfinite() с предопределенными значениями бесконечности. Теперь рассмотрим распространенный сценарий, при котором в вычислениях может возникнуть бесконечность: деление на ноль.

В стандартной арифметике деление на ноль не определено. Однако в арифметике с плавающей запятой (которая используется для типа double), деление ненулевого числа на ноль приводит к положительной или отрицательной бесконечности, в зависимости от знака числителя. Деление нуля на ноль или бесконечности на бесконечность приводит к специальному значению, называемому "Not a Number" (NaN - нечисло), которое мы рассмотрим на следующем этапе.

Модифицируем нашу программу, чтобы продемонстрировать деление на ноль и проверить результат с помощью метода Double.isInfinite().

1. Откройте файл HelloJava.java в редакторе WebIDE. Вы должны находиться в директории ~/project.

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

   public class HelloJava {
       public static void main(String[] args) {
           double positiveResult = 10.0 / 0.0;
           double negativeResult = -10.0 / 0.0;
           double zeroResult = 0.0 / 10.0;
   
           System.out.println("Result of 10.0 / 0.0: " + positiveResult);
           System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveResult));
   
           System.out.println("Result of -10.0 / 0.0: " + negativeResult);
           System.out.println("Is -10.0 / 0.0 infinite? " + Double.isInfinite(negativeResult));
   
           System.out.println("Result of 0.0 / 10.0: " + zeroResult);
           System.out.println("Is 0.0 / 10.0 infinite? " + Double.isInfinite(zeroResult));
       }
   }

   Рассмотрим, что происходит в этом новом коде:

   • double positiveResult = 10.0 / 0.0;: Мы делим положительное число (10.0) на ноль (0.0). В арифметике с плавающей запятой это приводит к положительной бесконечности.
   • double negativeResult = -10.0 / 0.0;: Мы делим отрицательное число (-10.0) на ноль (0.0). Это приводит к отрицательной бесконечности.
   • double zeroResult = 0.0 / 10.0;: Мы делим ноль (0.0) на ненулевое число (10.0). Это приводит к нулю, которое является конечным числом.
   • Затем мы выводим результаты этих делений и используем метод Double.isInfinite() для проверки, является ли каждый результат бесконечным.

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

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

   javac HelloJava.java

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

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

   java HelloJava

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

   Result of 10.0 / 0.0: Infinity
   Is 10.0 / 0.0 infinite? true
   Result of -10.0 / 0.0: -Infinity
   Is -10.0 / 0.0 infinite? true
   Result of 0.0 / 10.0: 0.0
   Is 0.0 / 10.0 infinite? false

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

Различие между бесконечностью и NaN

На предыдущих этапах мы изучили метод Double.isInfinite() и то, как деление на ноль может привести к бесконечности. Однако в арифметике с плавающей запятой есть еще одно специальное значение, называемое NaN, что означает "Not a Number" (нечисло). NaN представляет результат неопределенной или нерепрезентируемой операции, например, деление нуля на ноль или взятие квадратного корня из отрицательного числа.

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

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

1. Откройте файл HelloJava.java в редакторе WebIDE. Вы должны находиться в директории ~/project.

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

   public class HelloJava {
       public static void main(String[] args) {
           double positiveInfinity = 10.0 / 0.0;
           double nanResult = 0.0 / 0.0;
           double finiteNumber = 5.0;
   
           System.out.println("Result of 10.0 / 0.0: " + positiveInfinity);
           System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveInfinity));
           System.out.println("Is 10.0 / 0.0 NaN? " + Double.isNaN(positiveInfinity));
   
           System.out.println("Result of 0.0 / 0.0: " + nanResult);
           System.out.println("Is 0.0 / 0.0 infinite? " + Double.isInfinite(nanResult));
           System.out.println("Is 0.0 / 0.0 NaN? " + Double.isNaN(nanResult));
   
           System.out.println("Result of 5.0: " + finiteNumber);
           System.out.println("Is 5.0 infinite? " + Double.isInfinite(finiteNumber));
           System.out.println("Is 5.0 NaN? " + Double.isNaN(finiteNumber));
       }
   }

   Рассмотрим изменения:

   • double positiveInfinity = 10.0 / 0.0;: Мы сохраняем деление, которое дает положительную бесконечность.
   • double nanResult = 0.0 / 0.0;: Эта строка выполняет деление нуля на ноль, которое дает NaN.
   • double finiteNumber = 5.0;: Обычное конечное число для сравнения.
   • Теперь мы добавили вызовы метода Double.isNaN() для каждого результата, помимо метода Double.isInfinite().

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

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

   javac HelloJava.java

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

   java HelloJava

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

   Result of 10.0 / 0.0: Infinity
   Is 10.0 / 0.0 infinite? true
   Is 10.0 / 0.0 NaN? false
   Result of 0.0 / 0.0: NaN
   Is 0.0 / 0.0 infinite? false
   Is 0.0 / 0.0 NaN? true
   Result of 5.0: 5.0
   Is 5.0 infinite? false
   Is 5.0 NaN? false

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

Резюме

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