Подойдет ли float для точного хранения

Float и точность: почему это опасно

Прямой ответ

Нет, float категорически не подходит для точного хранения значений. Это одна из самых частых ошибок в промышленном коде, которая приводит к потере денег (буквально в финансовых системах).

Почему float неточен

Float использует IEEE 754 (одинарная точность):

32 бита (4 байта):
┌─┬───────────────────────────────────────────────────┐
│S│ Экспонента (8 бит)│       Мантисса (23 бита)      │
└─┴───────────────────────────────────────────────────┘

Без целой части!
Машинный эпсилон ≈ 1.19e-7

Double использует IEEE 754 (двойная точность):

64 бита (8 байт):
┌─┬─────────────────────────────────────────────────────────────────┐
│S│ Экспонента (11 бит)│     Мантисса (52 бита)                    │
└─┴─────────────────────────────────────────────────────────────────┘

Машинный эпсилон ≈ 2.22e-16

Проблема 1: Бинарное представление

Многие десятичные числа невозможно представить точно в двоичной системе:

float f = 0.1f;
System.out.println(f);  // 0.1 (выглядит нормально)
System.out.printf("%.20f%n", f);  // 0.10000000149011611938 (на самом деле)

double d = 0.1;
System.out.println(d);  // 0.1
System.out.printf("%.20f%n", d);  // 0.10000000000000000555 (лучше, но всё ещё неточно)

Проблема 2: Накопление ошибок при арифметике

float sum = 0;
for (int i = 0; i < 1000000; i++) {
    sum += 0.01f;
}
System.out.println(sum);  // 9999.99 (ожидали 10000)

double sum = 0;
for (int i = 0; i < 1000000; i++) {
    sum += 0.01;
}
System.out.println(sum);  // 10000.000000000002 (лучше, но всё ещё ошибка)

Проблема 3: Сравнение

float a = 0.1f + 0.1f + 0.1f;
float b = 0.3f;

if (a == b) {
    System.out.println("Равны");  // НЕ ВЫВЕДЕТСЯ!
} else {
    System.out.println("Не равны");  // ВЫВЕДЕТСЯ
    System.out.printf("a = %.20f%n", a);  // 0.30000001192092895508
    System.out.printf("b = %.20f%n", b);  // 0.29999999999999998889
}

Где Float опасен

1. Финансовые расчёты (НИКОГДА float/double)

// ПЛОХО: потеря денег
public double calculateTotal(double price, int quantity) {
    return price * quantity;  // 0.1 * 3 = 0.30000000000000004
}

// ХОРОШО: использовать BigDecimal
public BigDecimal calculateTotal(BigDecimal price, int quantity) {
    return price.multiply(new BigDecimal(quantity));
}

// Пример с реальными деньгами:
BigDecimal money = new BigDecimal("0.10");
for (int i = 0; i < 1000; i++) {
    money = money.add(new BigDecimal("0.01"));
}
System.out.println(money);  // 10.10 (идеально!)

2. Научные вычисления (осторожно)

// Double лучше, чем float, но нужна проверка точности
public static double calculatePI(int iterations) {
    double pi = 0;
    for (int i = 0; i < iterations; i++) {
        pi += Math.pow(-1, i) / (2 * i + 1);
    }
    return pi * 4;
}

// Нужно проверять: Math.abs(calculated - Math.PI) < EPSILON
final double EPSILON = 1e-10;
if (Math.abs(result - expected) < EPSILON) {
    System.out.println("Точность хороша");
}

3. Базы данных и сбережение

// ПЛОХО: float потеряет точность при сохранении
float salary = 1500.55f;  // может быть 1500.549987793

// ХОРОШО: сохранять в центах как целое число
long salaryInCents = 150055;  // 1500.55 в центах

// Или использовать NUMERIC/DECIMAL в БД
BigDecimal salary = new BigDecimal("1500.55");

Правильные типы для разных сценариев

// 1. ФИНАНСЫ — ВСЕГДА BigDecimal
BigDecimal price = new BigDecimal("99.99");
BigDecimal total = price.multiply(new BigDecimal("3"));

// 2. НАУЧНЫЕ РАСЧЁТЫ — double (с проверкой EPSILON)
double result = calculateScientificValue();
if (Math.abs(result - expected) < 1e-10) {
    System.out.println("OK");
}

// 3. ЦЕЛЫЕ ЧИСЛА — int / long
long count = 1000000;  // не 1000000.0

// 4. ПРОЦЕНТИЛИ / РЕЙТИНГИ — double (если нужна дробная часть)
double rating = 4.5;

BigDecimal vs Double

// СРАВНЕНИЕ

// Double (быстро, но неточно)
double price = 19.99;
double tax = price * 0.20;
System.out.println(tax);  // 3.9979999999999996

// BigDecimal (медленнее, но точно)
BigDecimal price = new BigDecimal("19.99");
BigDecimal tax = price.multiply(new BigDecimal("0.20"));
System.out.println(tax);  // 3.99

Рекомендации по точности

Для float:

✓ Компьютерная графика (OpenGL, игры)
✓ Научные вычисления (если точность ± 0.0001 приемлема)
✗ Финансы
✗ Любые денежные расчёты
✗ Критичные инженерные расчёты

Для double:

✓ Большинство численных расчётов
✓ Статистика
✓ Машинное обучение
✗ Финансы (всегда BigDecimal)

Для BigDecimal:

✓ Финансы (обязательно)
✓ Денежные расчёты
✓ Любые операции, где нужна точная дробь
✗ Очень большие объёмы данных (медленнее)
✗ Интенсивные вычисления (используй double, потом округли)

Лучшие практики

// 1. Никогда не сравнивай float/double на равенство
// ПЛОХО:
if (a == b) { }

// ХОРОШО:
if (Math.abs(a - b) < EPSILON) { }

// 2. Используй BigDecimal для денег
BigDecimal amount = new BigDecimal("100.50");

// 3. Инициализируй правильно
// ПЛОХО:
BigDecimal price = new BigDecimal(99.99);

// ХОРОШО:
BigDecimal price = new BigDecimal("99.99");

// 4. Устанавливай precision и scale
BigDecimal result = amount.setScale(2, RoundingMode.HALF_UP);

Реальный пример: платёжная система

public class PaymentProcessor {
    // НЕПРАВИЛЬНО:
    public double processPayment(double amount, double tax) {
        return amount + (amount * tax);
    }
    
    // ПРАВИЛЬНО:
    public BigDecimal processPayment(BigDecimal amount, BigDecimal taxRate) {
        BigDecimal tax = amount.multiply(taxRate);
        return amount.add(tax).setScale(2, RoundingMode.HALF_UP);
    }
}

Итог

• Float/Double неточны из-за IEEE 754 представления
• Никогда не используй для денег — используй BigDecimal
• BigDecimal медленнее, но гарантирует точность
• Сравнение должно быть через EPSILON, не ==
• Правило: если сомневаешься — используй BigDecimal