Какой числовой класс подходит для работы с денежными операциями?

Числовой класс для денежных операций

Это один из самых важных вопросов для разработки financial-critical приложений. Неправильный выбор типа данных может привести к потере денег.

Краткий ответ: BigDecimal

Для денежных операций ВСЕГДА используй BigDecimal, никогда не используй float или double.

import java.math.BigDecimal;
import java.math.RoundingMode;

public class MoneyOperations {
    
    // ❌ НЕПРАВИЛЬНО: float/double
    public double badCalculation() {
        double balance = 0.1;
        balance += 0.2;
        System.out.println(balance); // 0.30000000000000004 (!!! ошибка)
        return balance;
    }
    
    // ✅ ПРАВИЛЬНО: BigDecimal
    public BigDecimal goodCalculation() {
        BigDecimal balance = new BigDecimal("0.1");
        balance = balance.add(new BigDecimal("0.2"));
        System.out.println(balance); // 0.3 (верно)
        return balance;
    }
}

Почему BigDecimal, а не float/double?

Проблема с float/double — это binary representation:

public class FloatProblems {
    
    public static void main(String[] args) {
        // ❌ Double: 0.1 + 0.2 != 0.3
        double d1 = 0.1;
        double d2 = 0.2;
        double sum = d1 + d2;
        
        System.out.println(sum);                    // 0.30000000000000004
        System.out.println(sum == 0.3);             // false (!)
        System.out.println(String.format("%.20f", sum)); // 0.30000000000000004441
        
        // ✅ BigDecimal: точный результат
        BigDecimal b1 = new BigDecimal("0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        BigDecimal bsum = b1.add(b2);
        
        System.out.println(bsum);      // 0.3
        System.out.println(bsum.equals(new BigDecimal("0.3"))); // true
    }
}

Основные операции с BigDecimal

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalOperations {
    
    public void basicArithmetic() {
        BigDecimal a = new BigDecimal("100.00");
        BigDecimal b = new BigDecimal("25.50");
        
        // Сложение
        BigDecimal sum = a.add(b);
        System.out.println("Sum: " + sum); // 125.50
        
        // Вычитание
        BigDecimal difference = a.subtract(b);
        System.out.println("Difference: " + difference); // 74.50
        
        // Умножение
        BigDecimal product = a.multiply(b);
        System.out.println("Product: " + product); // 2550.0000
        
        // Деление (ОБЯЗАТЕЛЬНО указать масштаб и режим округления!)
        BigDecimal division = a.divide(b, 2, RoundingMode.HALF_UP);
        System.out.println("Division: " + division); // 3.92
    }
    
    public void comparison() {
        BigDecimal a = new BigDecimal("100.00");
        BigDecimal b = new BigDecimal("100");
        
        // Сравнение: используй compareTo(), не equals()!
        System.out.println(a.equals(b));      // false (разный масштаб: 2 vs 0)
        System.out.println(a.compareTo(b));   // 0 (эквивалентны по значению)
    }
}

ВАЖНО: При делении указывай масштаб и режим округления

public class DivisionBestPractices {
    
    public void divisionWithRounding() {
        BigDecimal price = new BigDecimal("10.00");
        BigDecimal quantity = new BigDecimal("3");
        
        // ❌ Ошибка: ArithmeticException при делении, не дающем конечного результата
        // BigDecimal result = price.divide(quantity);
        
        // ✅ ПРАВИЛЬНО: указывай масштаб и режим округления
        // Масштаб: количество знаков после запятой
        // RoundingMode: как округлять
        BigDecimal result = price.divide(quantity, 2, RoundingMode.HALF_UP);
        System.out.println("Price per item: " + result); // 3.33
    }
    
    public void roundingModes() {
        BigDecimal value = new BigDecimal("10.125");
        
        // RoundingMode.HALF_UP — 10.12 или 10.13? Ответ: 10.13 (стандартное округление)
        BigDecimal halfUp = value.setScale(2, RoundingMode.HALF_UP);
        System.out.println("HALF_UP: " + halfUp);      // 10.13
        
        // RoundingMode.DOWN — всегда вниз
        BigDecimal down = value.setScale(2, RoundingMode.DOWN);
        System.out.println("DOWN: " + down);           // 10.12
        
        // RoundingMode.UP — всегда вверх
        BigDecimal up = value.setScale(2, RoundingMode.UP);
        System.out.println("UP: " + up);               // 10.13
        
        // RoundingMode.CEILING — всегда вверх (математический потолок)
        BigDecimal ceiling = value.setScale(2, RoundingMode.CEILING);
        System.out.println("CEILING: " + ceiling);     // 10.13
    }
}

Практический пример: Расчёт цены с налогом

import java.math.BigDecimal;
import java.math.RoundingMode;

public class PriceCalculation {
    
    private static final BigDecimal TAX_RATE = new BigDecimal("0.20"); // 20%
    private static final int SCALE = 2;  // 2 знака после запятой
    private static final RoundingMode ROUNDING = RoundingMode.HALF_UP;
    
    public BigDecimal calculateFinalPrice(BigDecimal basePrice) {
        // Базовая цена
        if (basePrice.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Price cannot be negative");
        }
        
        // Налог = базовая цена * 20%
        BigDecimal tax = basePrice.multiply(TAX_RATE)
            .setScale(SCALE, ROUNDING);
        
        // Итоговая цена = базовая цена + налог
        BigDecimal finalPrice = basePrice.add(tax)
            .setScale(SCALE, ROUNDING);
        
        return finalPrice;
    }
    
    // Пример использования
    public static void main(String[] args) {
        PriceCalculation calculator = new PriceCalculation();
        
        BigDecimal basePrice = new BigDecimal("100.00");
        BigDecimal finalPrice = calculator.calculateFinalPrice(basePrice);
        
        System.out.println("Base price: " + basePrice);    // 100.00
        System.out.println("Final price: " + finalPrice);  // 120.00
    }
}

Правильная реализация денежного класса

public class Money implements Comparable<Money> {
    
    private final BigDecimal amount;
    private final String currency; // USD, EUR, RUB
    private static final int SCALE = 2;
    private static final RoundingMode ROUNDING = RoundingMode.HALF_UP;
    
    public Money(String amount, String currency) {
        this.amount = new BigDecimal(amount).setScale(SCALE, ROUNDING);
        this.currency = currency;
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount).toString(), this.currency);
    }
    
    public Money subtract(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot subtract different currencies");
        }
        return new Money(this.amount.subtract(other.amount).toString(), this.currency);
    }
    
    public Money multiply(BigDecimal factor) {
        BigDecimal result = this.amount.multiply(factor).setScale(SCALE, ROUNDING);
        return new Money(result.toString(), this.currency);
    }
    
    @Override
    public int compareTo(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot compare different currencies");
        }
        return this.amount.compareTo(other.amount);
    }
    
    @Override
    public String toString() {
        return currency + " " + amount;
    }
}

Сравнение числовых типов

┌────────┬──────────────────────┬──────────────────┬─────────────┐
│ Тип    │ Точность             │ Использование    │ Допустимо?  │
├────────┼──────────────────────┼──────────────────┼─────────────┤
│ int    │ Целые числа          │ Копейки/центы    │ Только с    │
│        │ -2^31 to 2^31-1      │ (не полные руб.) │ преобразов. │
├────────┼──────────────────────┼──────────────────┼─────────────┤
│ long   │ Целые числа 64-бит   │ Копейки больших  │ Условно,    │
│        │ -2^63 to 2^63-1      │ сумм             │ сложнее     │
├────────┼──────────────────────┼──────────────────┼─────────────┤
│ float  │ ~7 знаков после ","  │ Никогда!         │ НЕТ!        │
│        │ binary representation│ Ошибки округлен. │ ❌❌❌       │
├────────┼──────────────────────┼──────────────────┼─────────────┤
│ double │ ~15 знаков после ","│ Никогда!         │ НЕТ!        │
│        │ binary representation│ Ошибки округлен. │ ❌❌❌       │
├────────┼──────────────────────┼──────────────────┼─────────────┤
│BigDeci-│ Произвольная точность│ ДА! Идеально    │ ✅ ВСЕГДА!  │
│mal     │ decimal representation                  │ ✅✅✅      │
└────────┴──────────────────────┴──────────────────┴─────────────┘

Checklist для денежных операций

• Использую BigDecimal, никогда не float/double
• При делении указываю масштаб и RoundingMode
• Создаю BigDecimal из String, не из double (BigDecimal("100.00"), не BigDecimal(100.0))
• Сравниваю через compareTo(), не equals()
• Валидирую, что сумма >= 0
• Не смешиваю разные валюты
• Устанавливаю фиксированный масштаб (обычно 2 знака после запятой)
• Документирую, какой RoundingMode использую и почему
• Пишу unit-тесты для всех расчётов

Вывод

Для работы с деньгами используй ТОЛЬКО BigDecimal. Это не мнение, а requirement в любом финансовом приложении:

• BigDecimal гарантирует точность
• Поддерживает произвольную точность
• Позволяет контролировать округление
• Предотвращает потерю денег из-за ошибок вычисления

Цена неправильного выбора типа — потеря денег клиентов или компании.