Какие знаешь методы в числовых классах?

Методы в числовых классах Java

Числовые классы (Integer, Long, Double, Float, BigDecimal, BigInteger) предоставляют множество полезных методов для работы с числами, преобразования типов и математических операций.

Integer и Long

// Статические методы Integer
int value = 42;

// Преобразование в строку
String str = Integer.toString(value);     // "42"
String hex = Integer.toHexString(42);     // "2a"
String binary = Integer.toBinaryString(42); // "101010"
String octal = Integer.toOctalString(42);  // "52"

// Преобразование из строки
int fromString = Integer.parseInt("42");    // 42
int fromHex = Integer.parseInt("2a", 16);   // 42 (hex)

// Проверки
int result = Integer.compare(10, 20);       // Возвращает -1
boolean isEven = (value & 1) == 0;

// Информация о типе
int bits = Integer.SIZE;                    // 32
int maxValue = Integer.MAX_VALUE;           // 2147483647
int minValue = Integer.MIN_VALUE;           // -2147483648
int bytes = Integer.BYTES;                  // 4

// Кол-во битов
int bitCount = Integer.bitCount(42);        // 3 (в 101010 три единицы)
int leadingZeros = Integer.numberOfLeadingZeros(42);  // 26
int trailingZeros = Integer.numberOfTrailingZeros(42); // 1

// Операции с битами
int rotate = Integer.rotateLeft(42, 2);    // Rotate левый сдвиг
int reverse = Integer.reverse(42);          // Разворот битов

// Высший установленный бит
int highBit = Integer.highestOneBit(42);   // 32 (0010_0000)
int lowBit = Integer.lowestOneBit(42);     // 2 (0000_0010)

// Long аналогичен Integer
long value64 = 1234567890L;
long bitCount64 = Long.bitCount(value64);
String hex64 = Long.toHexString(value64);

Float и Double

// Статические методы
double value = 3.14159;

// Проверки специальных значений
boolean isNaN = Double.isNaN(Double.NaN);       // true
boolean isInf = Double.isInfinite(1.0 / 0.0);   // true (Infinity)
boolean isFinite = Double.isFinite(3.14);       // true

// Преобразование
String str = Double.toString(3.14);             // "3.14"
String scientific = Double.toString(1e-10);     // "1.0E-10"

// Сравнение с precision
int compare = Double.compare(3.14, 3.14);       // 0 (равны)
int compareOrdered = Double.compare(Double.NaN, 3.14); // 1 (NaN считается больше)

// Граничные значения
double maxValue = Double.MAX_VALUE;             // ~1.8e308
double minValue = Double.MIN_VALUE;             // ~4.9e-324
double minPositive = Double.MIN_NORMAL;         // ~2.2e-308

// Преобразование битов (для сравнения двух doubles)
long bits1 = Double.doubleToLongBits(3.14);
long bits2 = Double.doubleToLongBits(3.14);
boolean same = bits1 == bits2; // Точное сравнение

double reconstructed = Double.longBitsToDouble(bits1);

Number (базовый класс)

public class NumberMethods {
    public void demonstrate() {
        // Все числовые классы наследуют Number
        Number num = 42; // Integer
        
        // Методы Number
        byte b = num.byteValue();     // 42
        short s = num.shortValue();   // 42
        int i = num.intValue();       // 42
        long l = num.longValue();     // 42L
        float f = num.floatValue();   // 42.0f
        double d = num.doubleValue(); // 42.0
    }
}

BigDecimal (для денег и точных расчетов!)

// НИКОГДА не используй double для денег!
public class MoneyCalculation {
    public static void main(String[] args) {
        // ❌ Плохо: double
        double price = 0.1 + 0.2;
        System.out.println(price); // 0.30000000000000004 (ошибка!)
        
        // ✅ Хорошо: BigDecimal
        BigDecimal price1 = new BigDecimal("0.1");
        BigDecimal price2 = new BigDecimal("0.2");
        BigDecimal sum = price1.add(price2);
        System.out.println(sum); // 0.3
    }
}

// Методы BigDecimal
public class BigDecimalMethods {
    public void demonstrate() {
        BigDecimal amount = new BigDecimal("100.50");
        
        // Арифметика
        BigDecimal added = amount.add(new BigDecimal("10"));    // 110.50
        BigDecimal subtracted = amount.subtract(new BigDecimal("10")); // 90.50
        BigDecimal multiplied = amount.multiply(new BigDecimal("2"));  // 201.00
        BigDecimal divided = amount.divide(new BigDecimal("2"));       // 50.25
        BigDecimal remainder = amount.remainder(new BigDecimal("3")); // 1.50
        BigDecimal power = amount.pow(2);                       // 10100.25
        
        // Модификации
        BigDecimal abs = amount.abs();                          // 100.50
        BigDecimal negated = amount.negate();                   // -100.50
        
        // Сравнение (ВАЖНО!)
        int cmp = amount.compareTo(new BigDecimal("100.50"));   // 0
        // equals НЕ работает для BigDecimal с разными масштабами!
        BigDecimal a = new BigDecimal("10.0");
        BigDecimal b = new BigDecimal("10.00");
        a.equals(b);            // false (разные масштабы!)
        a.compareTo(b) == 0;    // true (значения равны)
        
        // Округление (масштабирование)
        BigDecimal rounded = amount.setScale(0, RoundingMode.HALF_UP);
        // setScale(digit count, rounding mode)
        // RoundingMode: HALF_UP, DOWN, UP, CEILING, FLOOR и т.д.
        
        // Преобразование
        String str = amount.toString();          // "100.50"
        String plain = amount.toPlainString();   // "100.50" (без scientific notation)
        double d = amount.doubleValue();         // 100.50
        int i = amount.intValue();               // 100
        long l = amount.longValue();             // 100
        
        // Степени
        BigDecimal ten = new BigDecimal("10");
        int scale = amount.scale();              // 2 (количество decimal places)
        
        // Минус значение
        boolean isNegative = amount.signum() < 0; // false
        // signum(): -1 если < 0, 0 если = 0, 1 если > 0
    }
}

// Best practice для денег
@Entity
public class Transaction {
    @Id
    private Long id;
    
    // ВСЕГДА используй BigDecimal для денег!
    @Column(precision = 19, scale = 4)
    private BigDecimal amount;
    
    private static final BigDecimal MINIMUM_AMOUNT = new BigDecimal("0.01");
    
    public void setAmount(BigDecimal amount) {
        if (amount.compareTo(MINIMUM_AMOUNT) < 0) {
            throw new IllegalArgumentException("Amount too small");
        }
        // Всегда нормализуй
        this.amount = amount.setScale(4, RoundingMode.HALF_UP);
    }
}

BigInteger (для больших целых чисел)

public class BigIntegerMethods {
    public void demonstrate() {
        BigInteger big = new BigInteger("999999999999999999999");
        
        // Арифметика (все операции не изменяют исходное значение)
        BigInteger added = big.add(BigInteger.ONE);
        BigInteger multiplied = big.multiply(new BigInteger("2"));
        BigInteger divided = big.divide(new BigInteger("3"));
        
        // Модульная арифметика (для криптографии)
        BigInteger modResult = big.mod(new BigInteger("1000"));     // Остаток
        BigInteger modPower = big.modPow(new BigInteger("2"), new BigInteger("1000"));
        // Вычисляет (big^2) mod 1000 эффективно
        
        // Инверсия (для криптографии)
        BigInteger inverse = big.modInverse(new BigInteger("997")); // big^-1 mod 997
        
        // GCD и LCM
        BigInteger gcd = big.gcd(new BigInteger("1000")); // Наибольший общий делитель
        
        // Проверка простоты
        boolean isProbablyPrime = new BigInteger("997").isProbablePrime(40);
        // 40 = уровень confidence
        
        // Битовые операции
        int bitLength = big.bitLength();            // Количество бит
        BigInteger shiftLeft = big.shiftLeft(2);   // big << 2
        BigInteger shiftRight = big.shiftRight(2); // big >> 2
        BigInteger andResult = big.and(new BigInteger("255"));
        BigInteger orResult = big.or(new BigInteger("255"));
        BigInteger xorResult = big.xor(new BigInteger("255"));
        BigInteger flipBits = big.flipBit(0);      // XOR с 2^0
        
        // Факториал (пример использования)
        BigInteger factorial = factorial(100);
    }
    
    public BigInteger factorial(int n) {
        BigInteger result = BigInteger.ONE;
        for (int i = 2; i <= n; i++) {
            result = result.multiply(BigInteger.valueOf(i));
        }
        return result;
    }
}

Math класс (утилиты)

public class MathMethods {
    public static void main(String[] args) {
        // Базовые операции
        Math.abs(-5);              // 5
        Math.max(10, 20);          // 20
        Math.min(10, 20);          // 10
        
        // Округление
        Math.round(3.6);           // 4 (long)
        Math.floor(3.6);           // 3.0
        Math.ceil(3.2);            // 4.0
        
        // Степени и корни
        Math.pow(2, 8);            // 256.0
        Math.sqrt(16);             // 4.0
        Math.cbrt(27);             // 3.0 (кубический корень)
        
        // Тригонометрия
        Math.sin(Math.PI / 2);     // 1.0
        Math.cos(0);               // 1.0
        Math.tan(Math.PI / 4);     // 1.0
        Math.asin(1);              // π/2
        
        // Логарифмы
        Math.log(Math.E);          // 1.0
        Math.log10(100);           // 2.0
        Math.log1p(1.0);           // ln(2)
        Math.exp(1);               // e
        
        // Угловые единицы
        Math.toRadians(180);       // π
        Math.toDegrees(Math.PI);   // 180
        
        // Константы
        double pi = Math.PI;       // 3.14159...
        double e = Math.E;        // 2.71828...
    }
}

Сравнение точности

// Для потребительских приложений
public class DecimalComparison {
    
    // ❌ Неправильно
    public boolean compare(double a, double b) {
        return a == b; // Опасно для floating point
    }
    
    // ✅ Правильно
    public boolean compare(double a, double b) {
        double epsilon = 1e-10;
        return Math.abs(a - b) < epsilon;
    }
    
    // ✅ Для денег - BigDecimal
    public void transactionAmount() {
        BigDecimal price = new BigDecimal("9.99");
        BigDecimal tax = new BigDecimal("0.10");
        BigDecimal total = price.add(tax);
    }
}

Правильный выбор числового типа критичен для надежности приложения, особенно для финансовых операций и точных расчетов.