Как округлить bigdecimal java

Советы по работе с BigDecimal в Java

Если вы работаете на Java с дробными числами и при этом вам очень важно не потерять в точности, то использовать примитивные типы данных float и double нельзя. Они эту точность не гарантируют, и определяя число 1.01 вы на самом деле получите длинную дробную часть. Это связано с особенностями представления чисел с плавающей точкой.

Вместо них нужно использовать класс BigDecimal. Этот тип данных позволяет хранить сколь угодно большие значения и со сколь угодно большим количеством знаков после запятой (лишь бы хватило памяти). Поскольку это ссылочный тип, а не примитив, он реализован как неизменяемый, подобно классу String. То есть совершая любые математические операции над исходным экземпляром, вы каждый раз будете получать новый, не меняя при этом исходный.

Инициализация через строку

Вы можете создать экземпляр класса BigDecimal на основании числа или строки. При этом использовать значения float и double в качестве исходных опять-таки не рекомендуется.

System.out.println( new BigDecimal( 10 )); // 10
System.out.println( new BigDecimal( «10.1» )); // 10.1

System.out.println( new BigDecimal( 10 . 1 ));
// 10.0999999999999996447286321199499070644378662109375

Инициализация с помощью целых чисел не позволяет вам указать дробные значения. Поэтому универсальным способом инициализации BigDecimal является именно строка. Тогда вы получите ровно то число и с тем количеством знаков, которое вы указали.

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

Поскольку BigDecimal не является встроенным типом, то обычные операторы вроде «+» и «-» к нему уже не применимы. Вместо этого вам нужно использовать соответствующие методы add(), subtract(), multiply() и divide() соответственно.

var a = new BigDecimal( «6.000» );
var b = new BigDecimal( «3.0» );
System.out.println(a.add(b)); // 9.000
System.out.println(a.subtract(b)); // 3.000
System.out.println(a.multiply(b)); // 18.0000
System.out.println(a.divide(b)); // 2.00

Как уже говорилось выше, любые операции над a и b порождают новый экземпляр BigDecimal. При этом исходные экземпляры никак не меняются.

Указывайте точность при делении

При операциях деления нужно проявлять осторожность и обязательно указывать точность в явном виде. В случаях, когда результат деления представляет собой бесконечную дробь, BigDecimal мог бы израсходовать для представления всю доступную память, ведь он позволяет хранить любую точность. Поэтому если точность явно не указана и при делении возникает такая ситуация, то BigDecimal кидает исключение ArithmeticException. Ниже показаны оба варианта деления:

var a = new BigDecimal( «10.0» );
var b = new BigDecimal( «3.0» );
System.out.println(a.divide(b, 4 , RoundingMode. HALF_UP )); // явно указали точность — получим 3.3333
System.out.println(a.divide(b)); // не указали точность — получим ArithmeticException

Правильно будет всегда явно указывать количество знаков после запятой (в нашем случае 4 знака) и способ округления RoundingMode. Есть несколько разных способов округления, HALF_UP означает, что если на конце стоит 5, то округляем в большую сторону. То есть 0.05 округляется до 0.1, а 0.04 станет 0.0.

Явно указывайте точность результата

После выполнения последовательности математических операций нелишним будет сделать явное округление. Например, перед сохранением в БД. Так как даже если вы перемножаете два целых числа, у которых есть разная дробная часть, то в результате вы получите ещё бОльшую дробную часть. Ниже приведены варианты с округлением и без.

var a = new BigDecimal( «10.00» ); // 2 знака после запятой
var b = new BigDecimal( «20.000» ); // 3 знака
System.out.println(a.multiply(b)); // 200.00000 — 5 знаков
System.out.println(a.multiply(b).setScale( 2 , RoundingMode. HALF_UP )); // 200.00 — 2 знака

Поэтому явно указывайте точность результата с помощью метода setScale(). И опять-таки этот метод не меняет исходное значение, а порождает новый экземпляр класса.

Сравнивайте два значения с помощью метода compareTo()

В Java объекты на равенство принято сравнивать с помощью метода equals(). Однако в случае с BigDecimal так делать не стоит, поскольку equals() не учитывает точность. Для него числа 10 и 10.0 не равны. Для этих целей используйте метод compareTo(), который в случае равенства возвращает 0.

var a = new BigDecimal( «10» );
var b = new BigDecimal( «10.0» );
System.out.println(a.equals(b)); // false
System.out.println(a.compareTo(b) == 0 ); // true

Метод compareTo() позволяет проверять не только равенство, но и те случаи, когда одно значение больше или меньше другого. Если a > b – метод вернёт 1. Если a var a = new BigDecimal( «2.5» );
var b = new BigDecimal( «3» );
System.out.println(a.compareTo(b) == 0 ); // проверяем условие a == b, false
System.out.println(a.compareTo(b) > 0 ); // a > b, false
System.out.println(a.compareTo(b) < 0 ); // a < b, true
System.out.println(a.compareTo(b) >= 0 ); // a >= b, false
System.out.println(a.compareTo(b)

Преобразование в целое число с проверкой

Иногда может потребоваться преобразование в целое число из BigDecimal в int или long. Класс предоставляет два метода: intValue() и intValueExact(). Первый просто отбрасывает дробную часть – фактически, округляет «вниз». Второй метод вернёт целое число только если нет дробной части. Если же она имеется, то кинет исключение ArithmeticException.

var a = new BigDecimal( «100.00» );
System.out.println(a.intValue()); // 100
System.out.println(a.intValueExact()); // 100

var b = new BigDecimal( «200.5» );
System.out.println(b.intValue()); // 200
System.out.println(b.intValueExact()); // ArithmeticException

Выбирайте один из двух подходов в зависимости от ваших требований. Но скорее всего для контроля точности вы будете использовать intValueExact(). Такая же пара методов имеется и для других целочисленных типов (byte, short, long и даже BigInteger).

Преобразуйте в строку с помощью toPlainString()

Чтобы получить текстовое представление объекта, в Java обычно используют метод toString(). Этот же метод используется по умолчанию при выводе значения в консоль или в лог. Однако в BigDecimal для этих целей лучше использовать метод toPlainString(). Чем же он отличается от стандартного? В большинстве случае текстовое представления, возвращаемое этими методами совпадает. Но есть и различия. Рассмотрим пример.

var a = new BigDecimal( «100.01» );
System.out.println(a); // неявно вызывается toString(), 100.01
System.out.println(a.toPlainString()); // 100.01

var b = new BigDecimal( «0.0000000001» );
System.out.println(b); // toString() вернёт 1E-10
System.out.println(b.toPlainString()); // 0.0000000001

Когда значение очень маленькое и содержит большое количество ведущих нулей в дробной части, toString() возвращает «инженерное» представление числа «1E-10», что означает 10 в степени -10. Такой формат может сбить с толку, если вы отображаете это где-то на интерфейсе. Поэтому всегда используйте toPlainString(), чтобы исключить такую ситуацию.

Итоги

Мы рассмотрели несколько полезных советов при работе с классом BigDecimal. Этот класс универсален и позволяет хранить любые значения без ограничения на размер как целой, так и дробной части. При этом он расходует больше памяти, т.к. не является примитивом.

Инициализацию BigDecimal следует делать через текстовое представление числа. Любая операция над BigDecimal порождает новый экземпляр класса, а старый остаётся без изменений. При совершении математических операций нельзя использовать привычные операторы. Вместо них нужно использовать соответствующие методы. Кроме того, имеет смысл явно указывать желаемую точность результата, а при делении это делать обязательно. Для сравнения двух значений также нужно использовать специальный метод compareTo().

Если у Вас остались вопросы по работе с BigDecimal – смело пишите их в комментариях.

Округление чисел до n десятичных знаков в Java

Одна из распространенных проблем, с которой сталкиваются новички в Java, — это округление чисел до определенного количества десятичных знаков. Например, имеется число 0.912385, которое требуется округлить до 5 десятичных знаков, причем округление должно происходить по методу «половина вверх», то есть если десятичная дробь для округления равна 5, она всегда округляется вверх до следующего числа.

Метод String.format

Одним из способов сделать это в Java является использование метода String.format . Например:

String.format("%.5g%n", 0.912385);

Этот код вернет 0.91239 , что является ожидаемым результатом. Однако этот метод всегда отображает числа с 5 десятичными знаками, даже если они не значимы. Например:

String.format("%.5g%n", 0.912300);

Этот код вернет 0.91230 , что не является желаемым результатом, поскольку ожидается 0.9123 , без завершающего нуля.

Метод DecimalFormat

Альтернативным способом является использование DecimalFormat :

DecimalFormat df = new DecimalFormat("#.#####"); df.format(0.912385);

Этот код вернет 0.91238 . Однако, данный метод использует округление «половина к ближайшему четному», то есть он округлит вниз, если предыдущая цифра четная.

Решение

Чтобы достичь желаемого результата, можно использовать комбинацию BigDecimal и DecimalFormat . Вот пример:

BigDecimal bd = new BigDecimal(Double.toString(0.912385)); bd = bd.setScale(5, RoundingMode.HALF_UP); DecimalFormat df = new DecimalFormat("#.#####"); df.format(bd.doubleValue());

Этот код сначала преобразует число в BigDecimal , затем устанавливает масштаб до 5 десятичных знаков с округлением вверх, и, наконец, форматирует его в DecimalFormat для удаления завершающих нулей. Это даст ожидаемый результат 0.91239 для 0.912385 и 0.9123 для 0.912300 .

Pro Java

Примитивные типы Java, как мы уже знаем, ограничены диапазоном значений, которые они могут представлять. Когда размеров (диапазона значений) примитивных типов не хватает, для представления тех или иных чисел, можно воспользоваться классами BigInteger и BigDecimal, которые могут работать с целыми или вещественными числами любой точности (разрядности). Хотя работа с ними может выглядеть несколько неуклюже по сравнению с примитивными типами и их обертками, но в замен мы получаем необходимую нам точность вычислений. Теперь рассмотрим все это более подробно. И хотя о классах мы еще не говорили, мне кажется более логичным рассмотреть эти два класса сразу после классов оберток, чтобы начать понимать что такое методы классов и как они работают, на примере замещения стандартных математических операторов на методы этих классов. Так же мы еще не говорили о массивах, которые тоже могут быть использованы для создания объектов этих классов, но надеюсь что все будет более или менее понятно.

Класс BigInteger

Все примитивные целые типы имеют ограниченный диапазон значений. В целочисленной арифметике Java нет переполнения, целые числа приводятся по модулю, равному диапазону значений. Для того чтобы было можно производить целочисленные вычисления с любой разрядностью, в состав Java API введен класс BigInteger, хранящийся в пакете java.math. Этот класс является потомком java.lang.Number и представляет целые числа произвольной длины, которая не ограничена 64 битами, как в типе long. Поскольку этот класс расширяет класс Number, следовательно, в нем переопределены методы doubleValue(), floatValue(), intValue(), longValue(). Методы byteValue() и shortValue() не переопределены, а прямо наследуются от класса Number.

Класс BigInteger содержит методы, дублирующие стандартные арифметические и побитовые операции Java. Метод compareTo() сравнивает два объекта BigInteger и возвращает результат сравнения в виде чисел −1, 0 или 1. Методы gcd(), modPow(), modInverse() и isProbablePrime() выполняют специальные операции и обычно применяются криптографическими и связанными с ними алгоритмами.

Класс BigInteger содержит множество других полезных методов, которые здесь перечислять мы не будем, так как их достаточно много и они хорошо задокументированы.

Действия с объектами класса BigInteger не приводят ни к переполнению, ни к приведению по модулю. Если результат операции велик, то число разрядов просто наращивается. Числа хранятся в двоичной форме с дополнительным кодом.

Шесть конструкторов класса создают объект класса BigInteger из строки символов (знака числа и цифр), массива байтов или задают случайное число. Приведу краткое описание этих конструкторов:

BigInteger(String value) — объект будет хранить большое целое число, заданное строкой цифр, перед которыми может стоять знак минус;
BigInteger(String value, int radix) — задается строка цифр со знаком value, записанная в системе счисления с основанием radix;
BigInteger(byte[] value) — объект будет хранить большое целое число, заданное массивом value, содержащим двоичное представление числа в дополнительном коде;
BigInteger(int signum, byte[] magnitude) – задает знак для числа заданного массивом byte, для signum возможны значения: –1 – для отрицательных чисел, 1 – для положительных и 0 для пустого массива;
BigInteger(int bitLength, int certainty, Random rnd) – генерирует случайное число, на основе заданных параметров: bitLength – задает число бит в которые будет занимать созданное число (вызывает ArithmeticException если меньше 2 или слишком большое), два других параметра влияют на то как часто возможны повторения случайных чисел;
BigInteger(int numBits, Random rnd) – так же генерирует случайное число, только используя два параметра.

Для преобразования обычного числа в число с произвольной точностью используется статический метод valueOf() с целочисленным литералом или целочисленной переменной, переданной методу как аргумент.

Три константы — ZERO, ONE и TEN — моделируют нуль, единицу и число десять в операциях с объектами класса BigInteger.

Метод toByteArray() преобразует объект в массив байтов.

Большинство методов класса BigInteger моделируют целочисленные операции и функции, возвращая объект класса BigInteger:

abs() — возвращает объект, содержащий абсолютное значение числа, хранящегося в данном объекте this;
add(x) — операция сложения this + x;
and(x) — операция побитовой конъюнкции this & x;
andNot(x) — операция побитовой дизъюнкции с дополнением this & (~x);
divide(x) — операция деления this / x;
divideAndRemainder(x) — возвращает массив из двух объектов класса BigInteger, содержащих частное и остаток от деления this на x;
gcd(x) — наибольший общий делитель абсолютных значений объекта this и аргумента x;
max(x) — наибольшее из значений объекта this и аргумента x;
min(x) — наименьшее из значений объекта this и аргумента x;
mod(x) — остаток от деления объекта this на аргумент метода x;
modInverse(x) — остаток от деления числа, обратного объекту this, на аргумент x;
modPow(n, m) — остаток от деления объекта this, возведенного в степень n, на m;
multiply(x) — операция умножения this * x;
negate() — перемена знака числа, хранящегося в объекте;
not() — операция отрицания ~this;
or(x) — операция побитовой дизъюнкции this | x;
pow(n) — операция возведения числа, хранящегося в объекте, в степень n;
remainder(x) — операция взятия остатка от деления this % x;
shiftLeft(n) — операция сдвига влево this
shiftRight(n) — операция арифметического сдвига вправо this >> n;
signum() — функция sign(x);
subtract(x) — операция вычитания this — x;
xor(x) — операция «исключающее ИЛИ» this ^ x.

Здесь далеко неполный перечень всех методов класса BigInteger. Все остальные можно посмотреть в документации на данный класс.

Стоит так же отметить что объекты классов BigInteger и BigDecimal являются immutable, то есть не изменяемыми . Это означает что методы данных классов не изменяют значение экземпляра класса, а лишь возвращают новое. Сейчас это может быть и не понятно, но практика все прояснит.

Теперь немного попрактикуемся для того, чтобы понять как работать с классом BigInteger. Чтобы использовать класс BigInteger в своей программе его необходимо импортировать командой

после чего его можно использовать.

И далее вывод данной программы:

BI0001

Класс BigDecimal

Примитивные вещественные типы данных, так же как и целочисленные ограничены количеством разрядов которым они могут быть представлены. Кроме того вещественные числа в Java имеют свой большой набор граблей, которые не позволяют их использовать в вычислениях где требуются точные значения, например в финансах. Для обхода этих граблей и представления вещественных чисел с нужной точностью был создан класс BigDecimal. Этот класс является потомком java.lang.Number и представляет число с плавающей точкой произвольной длины и точности. Класс BigDecimal расположен в пакете java.math.

Каждый объект этого класса хранит два целочисленных значения: мантиссу вещественного числа в виде объекта класса BigInteger и неотрицательный десятичный порядок числа типа int. Например, для числа 76,34862 будет храниться мантисса 7 634 862 в объекте класса BigInteger и порядок 5 как целое число типа int. Таким образом, мантисса может содержать любое количество цифр, а порядок ограничен значением константы Integer.MAX_VALUE.

Класс BigDecimal содержит методы, дублирующие стандартные арифметические операции Java. Но методов работы с битами как в BigInteger у него нет. Метод compareTo() сравнивает два объекта BigInteger и возвращает результат сравнения в виде чисел −1, 0 или 1.

При работе со значениями BigDecimal можно явно указать нужную точность (то есть количество десятичных разрядов). Кроме того, при выполнении операции, отбрасывающей разряды (например, при делении), требуется указать тип округления, которому подвергается первый разряд слева от отбрасываемых разрядов. В этом классе определено восемь констант, соответствующих различным типам округления. Поскольку в этом классе можно работать с числами произвольной точности и явно указывать точность и вид округления, его можно применять при выполнении операций над числами, представляющими денежные суммы, а также в других случаях, когда нельзя допускать ошибки при округлении.

Результат операции над объектами класса BigDecimal округляется по одному из восьми правил, определяемых следующими статическими целыми константами:

ROUND_CEILING — округление в большую сторону;
ROUND_DOWN — округление в меньшую сторону по модулю;
ROUND_UP — округление в большую сторону по модулю
ROUND_FLOOR — округление в меньшую сторону;
ROUND_HALF_DOWN — Округление вниз, если число после запятой > .5;
ROUND_HALF_EVEN — Округление половины по чётности ;
ROUND_HALF_UP — Округление вверх, если число после запятой >= .5;
ROUND_UNNECESSARY — предполагается, что результат будет целым, и округление не понадобится;

Чуть позже мы рассмотрим все эти типы округления более подробно на примерах.

Три константы — ZERO, ONE и TEN — моделируют вещественные нуль, единицу и вещественное число десять в операциях с объектами класса BigDecimal. В классе BigDecimal около двадцати конструкторов и очень много методов, поэтому все их мы описывать не будем, а коснемся лишь некоторых.

Большинство методов этого класса моделируют операции с вещественными числами. Они возвращают объект класса BigDecimal. Ниже в описании методов буква x обозначает объект класса BigDecimal, буква n — целое значение типа int, буква r — способ округления, одну из восьми перечисленных ранее констант:

abs() — абсолютное значение объекта this;
add(x) — операция сложения this + x;
divide(x, r) — операция деления this / x с округлением по способу r;
divide(x, n, r) — операция деления this / x с изменением порядка и округлением по способу r;
max(x) — наибольшее из this и x;
min(x) — наименьшее из this и x;
movePointLeft(n) — сдвиг точки влево на n разрядов;
movePointRight(n) — сдвиг точки вправо на n разрядов;
multiply(x) — операция умножения this * x;
negate() — возвращает объект с обратным знаком;
scale() — возвращает порядок числа;
setScale(n) — устанавливает новый порядок n;
setScale(n, r) — устанавливает новый порядок n и округляет число при необходимости по способу r;
signum() — знак числа, хранящегося в объекте;
subtract(x) — операция вычитания this — x;
toBigInteger() — округление числа, хранящегося в объекте;
unscaledValue() — возвращает мантиссу числа;
upl() — возвращает расстояние до следующего числа.

Как я уже говорил, здесь перечислены далеко не все методы класса BigDecimal. Остальные можно посмотреть в описании к этому классу.

Чаще всего класс BigDecimal используют в финансовых расчётах, так как вещественные примитивные типы не годятся для этой цели по причинам потери точности которые я уже описывал. Но вкратце все же напомню на следующем примере:

BD0001

Вывод у этого кода следующий:

BD0002

Как видим результат на лицо 🙂

Такие вещи, на которые способен double, в финансах ни кому не понравятся.

Денежные расчёты требуют точности в заданной степени, например, для большинства валют это два знака после запятой. Они также требуют определённого типа поведения при округлении, например, в случае налогов всегда выполнять округление в большую сторону.

Например, предположим, что у нас есть продукт, который стоит 10.00 в заданной валюте и местный налог с продаж 0.0825, или 8.25%. Если посчитать налог на бумаге, сумма будет:

10.00 * 0.0825 = 0.825

Но если мы эти числа зададим как double то в результате умножения получим число 0.8250000000000001.

Поскольку точность расчёта для данной валюты две цифры после запятой, требуется округлить число 0.825. Кроме того, поскольку это налог, обычной практикой является постоянное округление до цента в большую сторону. Таким образом, после расчёта баланса по счетам в конце дня мы никогда не получим недоплату налогов.

И таким образом клиенту выставляется общий счёт на сумму 10.83 в местной валюте, а сборщику налогов выплачивается 0.83. Обратите внимание, что если продать 1000 таких продуктов, то переплата сборщику налогов была бы:

1000 * (0.83 — 0.825) = 5.00

Другой важный вопрос: где делать округление в данном расчёте. Предположим, жидкий азот продаётся по цене 0.528361 за литр. Клиент приходит и покупает 100.00 литров, поэтому посчитаем полную цену:

100.0 * 0.528361 = 52.8361

Так как это не налог, можно округлить эту цифру вверх или вниз на своё усмотрение. Предположим, округление выполняется в соответствии со стандартными правилами округления: если следующая значащая цифра меньше 5, округляем в меньшую сторону. В противном случае округляем вверх. Это даёт для окончательной цены значение 52.84.

Теперь предположим, что мы хотим дать рекламную скидку в размере 5% от всей покупки. Делать скидку с цифры 52.8361 или 52.84? Какова разница?

Расчёт 1: 52.8361 * 0.95 = 50.194295 = 50.19
Расчёт 2: 52.84 * 0.95 = 50.198 = 50.20

Обратите внимание, что окончательная цифра округлена по стандартному правилу округления.

Видите разницу в один цент между двумя цифрами? Первый код не беспокоился о принятии во внимание округления, поэтому он всегда делал вычисления как в Расчёте 1. Но во втором коде перед расчётом скидок, налогов и всего другого сначала выполняется округление 2. Это одна из главных причин для ошибки в один цент.

Из этих примеров должно стать ясным, что необходимы две вещи:

1.Возможность задать масштаб, который представляет собой количество цифр после десятичной точки
2.Возможность задать метод округления

Класс BigDecimal принимает во внимание оба этих соображения.

Создать BigDecimal из числа типа double просто:

BigDecimal bd3 = new BigDecimal ( 0.3 ) ;

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

Поэтому более лучшей идеей является создание из строки:

bd3 = new BigDecimal ( «0.3» ) ;

Вот теперь будет порядок 🙂 и мы получим то что ожидали.

Теперь перейдем к округлению.

Чтобы задать количество цифр после запятой, используйте метод .setScale(scale). Тем не менее, хорошей практикой является одновременное указание вместе с масштабом режима округления с помощью .setScale(scale, roundingMode). Режим округления задаёт правило округления числа.

bd3 = new BigDecimal ( 0.3 ) ;
bd3 . setScale ( 1 ) ; //выдаст ошибку

Вторая строка выдаст ошибку java.lang.ArithmeticException: Rounding necessary, поскольку не известно как округлить 0.299999999999999988897769753748434595763683319091796875.

Так что всегда использовать .setScale(scale, roundingMode) — это хорошая идея. Например:

bd3 . setScale ( 1 , BigDecimal . ROUND_CEILING );

Если это значение вывести на консоль, то получим 0.3.

Ну и теперь подробно разберем все восемь типов округления класса BigDecimal.

ROUND_CEILING : В большую сторону

0.333 -> 0.34
-0.333 -> -0.33

ROUND_DOWN: Отбрасывание разряда

0.333 -> 0.33
-0.333 -> -0.33

ROUND_FLOOR: В меньшую сторону

0.333 -> 0.33
-0.333 -> -0.34

ROUND_HALF_UP: Округление вверх, если последнее число после запятой >= .5

0.335 -> 0.34
-0.335 -> -0.34

ROUND_HALF_DOWN: Округление вниз, если последнее число после запятой > .5

0.335 -> 0.33
-0.335 -> -0.33

0.336 -> 0.34
-0.336 -> -0.34

ROUND_HALF_EVEN: Округление половины по чётности округляет как обычно. Однако, когда округляемая цифра 5, округление будет идти вниз, если цифра слева от 5 чётная и вверх, если нечётная.

0.335 -> 0.34
-0.325 -> -0.32

Документация Java говорит о ROUND_HALF_EVEN так: обратите внимание, что это такой режим округления, который сводит к минимуму совокупную ошибку когда при выполнении последовательности вычислений постоянно выполняется округление .

ROUND_UNNECESSARY: Используйте ROUND_UNNECESSARY когда необходимо использовать один из методов, который требует ввода режима округления, но известно, что результат округлять не надо. Кроме того если задано количество знаков после запятой меньше чем в округляемом числе то вылетит ошибка.

При делении BigDecimals будьте осторожны и указывайте способ округления в методе .divide(). В противном случае можно получить ArithmeticException, если нет точного округлённого результирующего значения, например, 1/3. Таким образом, всегда следует делать так:

BigDecimal bd01 = new BigDecimal ( «1» ) ;
BigDecimal bd03 = new BigDecimal ( «3» ) ;
//BigDecimal bd1d3 = bd01.divide(bd03); // вызовет ошибку ArithmeticException
BigDecimal bd1d3 = bd01 . divide ( bd03 , 5 , BigDecimal . ROUND_HALF_UP ) ;

Теперь стоит пояснить более подробно что же такое immutable. Как я уже говорил это означает что созданные объект BigDecimal неизменяем. Это означает, что если создаётся новый объект BigDecimal со значением «2.00», такой объект останется «2.00» и никогда не может быть изменён. Так как же тогда выполняются математические расчёты? Методы .add(), .multiply() и другие возвращают новый объект BigDecimal, содержащий результат.

Так же стоит заметить что важно никогда не использовать для сравнения объектов BigDecimal метод .equals() . Этого нельзя делать потому, что метод equals() будет сравнивать масштабы. Если масштабы различаются, .equals() вернёт ложь, даже если они математически равны :

BigDecimal a = new BigDecimal ( «2.00» ) ;
BigDecimal b = new BigDecimal ( «2.0» ) ;
print ( «a.equals(b) 2″> + a . equals ( b )) ; // ложь

Поэтому вместо этого следует использовать методы .compareTo() и .signum().

a . compareTo ( b ) ; // возвращает (-1 если a < b), (0 если a == b), (1 если a >b)
a . signum () ; // возвращает (-1 если a < 0), (0 если a == 0), (1 если a >0)

Ну и на последок расскажу о полезном методе .stripTrailingZeros() который убирает незначащие нули в конце BigDecimal.

BigDecimal bd_1 = new BigDecimal ( «1.55» ) ;
BigDecimal bd_2 = new BigDecimal ( «3.15» ) ;
BigDecimal bd_3 = bd_1 . add ( bd_2 ) ;
println ( «bd_3 2″> + bd_3 ) ;
println ( «bd_3 2″> + bd_3 . stripTrailingZeros ()) ;

Пример работы данного когда будет приведен ниже, а пока смотрим на код, который демонстрирует все вышесказанное о BigDecimal:

Вывод данной программы:

BD0003

Подробно расписывать какие строки кода что выводят я думаю нет необходимости. Все и так понятно из кода.

Хотя эти два класса и важная тема, но она достаточно обширна, а нам надо двигаться дальше.