Какие плюсы и минусы хранения денежных средств во float?

Хранение денежных средств во float: плюсы и минусы

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

Минусы хранения денег во float (критичные)

Потеря точности из-за двоичной разряда Float и Double используют двоичное представление, что не может точно представить некоторые десятичные числа:

float price = 0.1f;  // Хотим 0.1
float quantity = 3;
float result = price * quantity;

System.out.println(result);  // 0.30000001 вместо 0.3!
// В финансовых системах это недопустимо

float amount = 0.2f;
float payment = 0.1f;
float change = amount - payment;

System.out.println(change);  // Может быть что-то типа 0.0999999

Ошибки накапливаются При множественных операциях ошибки округления растут:

float total = 0.0f;
for (int i = 0; i < 1000000; i++) {
    total += 0.01f;  // Добавляем по 0.01
}
System.out.println(total);  // Ожидаем 10000.0, но получим что-то другое
// Ошибка может быть в центах или даже в долларах!

Финансовые потери Это не просто математическая проблема, это может привести к реальным потерям денег:

// Банк 1: сумма = 0.1 * 1000000 = 100000
float bank1Balance = 100000.0f;
for (int i = 0; i < 1000000; i++) {
    bank1Balance -= 0.1f;
}

// bank1Balance != 0.0f из-за ошибок округления
// Деньги потеряны или созданы из ничего!

Непредсказуемое поведение при сравнении Компарирование float чисел может быть обманчивым:

float a = 0.1f + 0.2f;  // 0.3
float b = 0.3f;
System.out.println(a == b);  // false!

System.out.println(String.format("%.20f", a));  // 0.30000000000000004
System.out.println(String.format("%.20f", b));  // 0.29999999999999999

// Для денег это критично
if (payment == expectedAmount) {  // Может неправильно сработать!
    confirmPayment();
}

Проблемы при работе с БД Разные системы могут интерпретировать float по-разному:

// Java: float price = 99.99f
// В БД может сохраниться как 99.990001
// При загрузке будет другое значение

Плюсы float (очень ограниченные)

Производительность Float занимает меньше памяти и работает быстрее:

float[] prices = new float[1000000];  // Меньше памяти
Double[] prices = new double[1000000];  // Больше памяти

// Float вычисления немного быстрее на старых процессорах

Но для денег эта «производительность» неприемлема

Правильные подходы хранения денег

1. Использование BigDecimal (РЕКОМЕНДУЕТСЯ) Это стандарт для финансовых систем:

BigDecimal price = new BigDecimal("0.1");
BigDecimal quantity = new BigDecimal("3");
BigDecimal result = price.multiply(quantity);

System.out.println(result);  // 0.3 (точно!)

// Сравнение работает правильно
BigDecimal a = new BigDecimal("0.1").add(new BigDecimal("0.2"));
BigDecimal b = new BigDecimal("0.3");
System.out.println(a.equals(b));  // true

Почему BigDecimal лучше

• Десятичное представление (как люди считают)
• Произвольная точность
• Контролируемое округление

BigDecimal amount = new BigDecimal("100.00");
BigDecimal parts = new BigDecimal("3");

// RoundingMode.HALF_UP — стандартное округление
BigDecimal perPart = amount.divide(parts, 2, RoundingMode.HALF_UP);
System.out.println(perPart);  // 33.33

// Проверка распределения
BigDecimal total = perPart.multiply(parts);
System.out.println(total);  // 99.99
BigDecimal remainder = amount.subtract(total);
System.out.println(remainder);  // 0.01

2. Хранение денег в целых единицах (центах) Это популярный подход:

// Хранить в центах, не в долларах
private long amountInCents;  // 9999 = $99.99

public void addAmount(long cents) {
    this.amountInCents += cents;  // Целые числа — нет ошибок
}

public String getFormattedAmount() {
    long dollars = amountInCents / 100;
    long cents = amountInCents % 100;
    return String.format("$%d.%02d", dollars, cents);
}

Преимущества

• Нет проблем с плавающей запятой
• Быстрые операции (целые числа)
• Компактное хранение в БД

long balance1 = 10000;  // $100.00
long balance2 = 500;     // $5.00
long total = balance1 + balance2;  // 10500 = $105.00
// Всё работает идеально!

3. Использование Decimal СУБД типов При работе с БД использовать DECIMAL/NUMERIC:

-- Правильно
CREATE TABLE accounts (
    id INT PRIMARY KEY,
    balance DECIMAL(19, 2)  -- 19 цифр, 2 после запятой
);

-- Неправильно
CREATE TABLE accounts (
    id INT PRIMARY KEY,
    balance FLOAT  -- Приведёт к ошибкам!
);

Пример правильной финансовой операции

@Entity
public class Account {
    @Id
    private Long id;
    
    @Column(precision = 19, scale = 2)
    private BigDecimal balance;  // Или long amountInCents
}

@Service
public class PaymentService {
    
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        // Валидация
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        
        // Атомарная операция
        Account from = accountRepository.findById(fromId);
        Account to = accountRepository.findById(toId);
        
        if (from.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        
        accountRepository.save(from);
        accountRepository.save(to);
        
        // Логирование для аудита
        transactionLog.record(fromId, toId, amount);
    }
}

Резюме

НИКОГДА не используй float/double для денег!

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

1. Используй BigDecimal — стандарт индустрии
2. Или храни в целых единицах (центах) как long
3. DECIMAL/NUMERIC в БД — не FLOAT
4. Всегда логируй финансовые операции для аудита
5. Тестируй граничные случаи (0.01, округление)
6. Используй транзакции для атомарности

В финансовых системах точность — не опция, это требование. Выбор между float и BigDecimal — это выбор между жизнеспособной системой и системой с ошибками.