1. Введение
Кажется, что если компьютер "умный", то 0.1 + 0.2 должно быть просто 0.3. Но это не совсем так. Давайте разберёмся на простом примере.
double x = 0.1;
double y = 0.2;
double sum = x + y;
System.out.println(sum); // Что выведет программа?А теперь попробуйте сравнить с 0.3:
System.out.println(sum == 0.3); // А тут будет true или false?Если вы увидите false, не удивляйтесь!
Причина кроется в представлении чисел в памяти
Компьютеры работают с числами в двоичной системе. Но далеко не все десятичные дроби можно представить конечной двоичной дробью, так же как 1/3 нельзя точно записать десятичной дробью (0.333...). Например, 0.1 в двоичной системе — это бесконечная дробь, и её приходится "округлять" для хранения.
Если перевести это на бытовой язык, то double иногда "делает вид", что хранит ваше число точно, но на самом деле хранит лишь очень близкое приближённое значение.
2. Какие "глюки" бывают при арифметике с double?
Давайте рассмотрим практические примеры.
Пример 1. Классическая "магия" 0.1 + 0.2
double a = 0.1;
double b = 0.2;
double sum = a + b;
System.out.println(sum); // 0.30000000000000004
System.out.println(sum == 0.3); // falseКомпьютер вывел не 0.3, а 0.30000000000000004. Разница маленькая, но если вы занимаетесь, например, финансами — это уже критично.
Пример 2. Итеративное сложение
double result = 0;
for (int i = 0; i < 10; i++)
{
result += 0.1;
}
System.out.println(result); // 0.9999999999999999Хотели 1.0 — получили чуть меньше. Снова, причина в округлении внутри double.
Почему это важно в реальных задачах
Многие думают: "Какая разница, ну небольшая ошибка, подумаешь!" Рассмотрим пример из мира платежей.
Допустим, ваш интернет-банк складывает 100 транзакций по 0.1 евро. Если ваша программа "теряет" по одной стотысячной евро на каждую итерацию, то на масштабе банка вы уже "потеряете" реальные деньги. Вот тут к вам сразу придёт бухгалтер и спросит: "Где наши деньги?!"
3. Как правильно сравнивать вещественные числа
Поскольку double часто не может хранить именно то значение, которое вы ожидаете, прямое сравнение через == может подвести. Вместо этого принято сравнивать модуль разности чисел с некоторым очень маленьким числом (epsilon).
Пример сравнения с допуском
double a = 0.1 + 0.2;
double b = 0.3;
double epsilon = 0.000001;
if (Math.abs(a - b) < epsilon)
{
System.out.println("Почти равно!"); // Так сравнивать безопаснее
} Здесь мы говорим: "Если разница между числами меньше, чем одна миллионная, считаем, что числа равны".
Примечание: функция Math.abs(value) возвращает абсолютное значение (модуль) переданного в неё числа.
4. Специальные значения double: Infinity, NaN, -Infinity
Тип double хранит не только числа, но и особые значения. Они возникают в ситуациях, которые математик обычному студенту строго-настрого запрещает.
Бесконечность (Infinity)
Что будет, если поделить 1 на 0?
double result = 1.0 / 0.0;
System.out.println(result); // InfinityВ Java (и многих языках) деление на 0 для double не вызывает исключения! Вместо этого результат становится специальным значением "положительная бесконечность".
Минус бесконечность (-Infinity)
Если поделить отрицательное число на 0, то вы получите отрицательную бесконечность:
double result = -1.0 / 0.0;
System.out.println(result); // -Infinity"Не число" (NaN — Not a Number)
Если сделать что-то совсем странное, например, попытаться вычислить корень из отрицательного числа:
double result = Math.sqrt(-1);
System.out.println(result); // NaNИли результат деления 0.0 / 0.0:
double result = 0.0 / 0.0;
System.out.println(result); // NaNNaN — это "всё, что не являлось бы числом в реальной жизни".
Проверка на специальные значения
В Java есть функции для проверки специальных значений:
System.out.println(Double.isInfinite(result)); // true, если бесконечность
System.out.println(Double.isNaN(result)); // true, если NaNТаблица: Как double реагирует на необычные операции
| Операция | Результат | Что хранится в double |
|---|---|---|
|
Infinity | +∞ |
|
-Infinity | -∞ |
|
NaN | Не число |
|
NaN | Не число |
5. Типичные ошибки при работе с вещественными числами
Ошибка №1: Сравнение дробных чисел через ==
Самая распространённая ловушка: попытка проверить, равны ли два вычисленных числа с плавающей точкой через обычное сравнение. Из-за накопления ошибок округления вы почти всегда получите неожиданный результат. Всегда используйте сравнение с допуском (epsilon).
Ошибка №2: Неожиданные NaN и Infinity в вычислениях
Если не контролировать деление на ноль или корни из отрицательных чисел, в программе могут появиться NaN или Infinity и "заразить" все последующие расчёты. Не забывайте проверять подозрительные значения с помощью Double.isNaN() и Double.isInfinite() — это поможет избежать неприятных сюрпризов.
Ошибка №3: Использование NaN в качестве "маркера"
Некоторые новички используют NaN как "специальное" значение для проверки, например, "если не найдено — вернём NaN". Но помните: NaN коварен, и сравнение через == не сработает! Проверяйте только через специальные методы.
Ошибка №4: Ожидание исключения при делении на 0.0
В отличие от деления целых чисел, деление на 0.0 для double не вызывает ошибку, а возвращает Infinity или NaN. Это может привести к тихим и трудноуловимым багам — результат есть, но он не такой, как вы ожидали.