Классы BigInteger и BigDecimal

Примитивные типы 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 << n;
• shiftRight(n) — операция арифметического сдвига вправо this >> n;
• signum() — функция sign(x);
• subtract(x) — операция вычитания this — x;
• xor(x) — операция "исключающее ИЛИ" this ^ x.

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

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

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

import java.math.BigInteger;

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

	import static pro.java.util.Print.println;
	import java.math.BigInteger;
	import java.util.Random;
	public class BigIntegerClass {
	public static void main(String[] args) {
	// Примеры работы с BigInteger
	// создали BigInteger из строки представляющей число
	BigInteger bi1 = new BigInteger("987654321");
	println("bi1 = " + bi1);
	BigInteger bi2 = new BigInteger("-123456789");
	println("bi2 = " + bi2);
	// создали BigInteger из строки представляющей двоичное число
	BigInteger bi3 = new BigInteger("101", 2);
	println("bi3 = " + bi3);
	// Отрицательное значение заданное массивом byte
	byte[] bytes = new byte[] { (byte) 0xFF, 0x00, 0x00 }; // -65536
	BigInteger bi4 = new BigInteger(bytes);
	println("bi4 = " + bi4);
	// Положительное значение заданное массивом byte
	bytes = new byte[] { 0x1, 0x00, 0x00 }; // 65536
	BigInteger bi5 = new BigInteger(bytes);
	println("bi5 = " + bi5);
	// Задаем знак для BigInteger создаваемого из массива byte
	byte[] barSign = { 5, 7 }; // 1287
	BigInteger bi6 = new BigInteger(barSign);
	println("bi6 = " + bi6);
	println("BigInteger(-1,barSign) = " + new BigInteger(-1, barSign));
	// Генерируем случайное число BitInteger
	int bitLength = 8; // 8 bits (диапазон от 0 до 255)
	Random rnd = new Random();
	int certainty = 5; // 1 - 1/2(5) certainty
	BigInteger birnd1 = new BigInteger(bitLength, certainty, rnd);
	BigInteger birnd2 = new BigInteger(bitLength, rnd);
	println("birnd1 = " + birnd1);
	println("birnd2 = " + birnd2);
	// Создаем BigInteger из целочисленного литерала
	BigInteger bi7 = BigInteger.valueOf(42);
	println("bi7 = " + bi7);
	println("BigInteger.ONE = " + BigInteger.ONE);
	println("BigInteger.TEN = " + BigInteger.TEN);
	println("BigInteger.ZERO = " + BigInteger.ZERO);
	// Примеры арифметических операций с BigInteger
	println("bi1+bi2 = " + (bi1.add(bi2))); // +
	println("bi1 = " + bi1 + " bi2 = " + bi2);
	BigInteger bi8 = bi5.subtract(bi3); // -
	println("bi8 = " + bi8);
	println("bi3*bi7 = " + (bi3.multiply(bi7))); // *
	println("bi5/10 = " + (bi5.divide(BigInteger.TEN))); // /
	}
	}

view rawBigIntegerClass.java hosted with ❤ by GitHub

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

Класс 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 используют в финансовых расчётах, так как вещественные примитивные типы не годятся для этой цели по причинам потери точности которые я уже описывал. Но вкратце все же напомню на следующем примере:

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

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

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

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

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

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

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

0.825 -> 0.83

И таким образом клиенту выставляется общий счёт на сумму 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 = 0.299999999999999988897769753748434595763683319091796875

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

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

0.333  ->   0.33
-0.333  ->  -0.33

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

-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)= " + 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 = " + bd_3);
println("bd_3 = " + bd_3.stripTrailingZeros());

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

	import java.math.BigDecimal;
	import static pro.java.util.Print.*;
	public class BigDecimalClass {
	public static void main(String[] args) {
	// Примеры работы с BigDecimal
	// пример сути проблемы с точностью представления double
	double d1 = 2;
	double d2 = 1.1;
	println("d1 = " + d1 + " d2 = " + d2);
	println("d1-d2 = " + (d1 - d2));
	// как это решается с использованием BigDecimal
	BigDecimal bd1 = BigDecimal.valueOf(2);
	BigDecimal bd2 = BigDecimal.valueOf(1.1);
	println("bd1 = " + bd1 + " bd2 = " + bd2);
	println("bd1-bd2 = " + (bd1.subtract(bd2)));
	double d3 = 10;
	double d4 = 0.0825;
	println("d3*d4 = " + (d3 * d4));
	// лучше создавать объекты BigDecimal из строки
	// или при помощи метда valueOf()
	BigDecimal bd3 = new BigDecimal(0.3);
	println("bd3 = " + bd3);
	bd3 = new BigDecimal("0.3");
	println("bd3 = " + bd3);
	bd3 = BigDecimal.valueOf(0.3);
	println("bd3 = " + bd3);
	// примеры округления
	bd3 = new BigDecimal(0.3);
	// bd3.setScale(1); //выдаст ошибку
	println("ROUND_CEILING bd3 = " + bd3.setScale(1, BigDecimal.ROUND_CEILING));
	// ROUND_CEILING: В большую сторону
	println();
	println("ROUND_CEILING: В большую сторону");
	BigDecimal bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_CEILING bdr = " + bdr.setScale(2, BigDecimal.ROUND_CEILING));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_CEILING bdr = " + bdr.setScale(2, BigDecimal.ROUND_CEILING));
	// ROUND_DOWN: Округление в меньшую сторону по модулю
	println();
	println("ROUND_DOWN: Округление в меньшую сторону по модулю");
	bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_DOWN));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_DOWN));
	// ROUND_UP: Округление в большую сторону по модулю
	println();
	println("ROUND_UP: Округление в большую сторону по модулю");
	bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_UP));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_UP));
	// ROUND_FLOOR: В меньшую сторону
	println();
	println("ROUND_FLOOR: В меньшую сторону");
	bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_FLOOR bdr = " + bdr.setScale(2, BigDecimal.ROUND_FLOOR));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_FLOOR bdr = " + bdr.setScale(2, BigDecimal.ROUND_FLOOR));
	// ROUND_HALF_UP: Округление вверх, если число после запятой >= .5
	println();
	println("ROUND_HALF_UP: Округление вверх, если число после запятой >= .5");
	bdr = new BigDecimal("0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_UP));
	bdr = new BigDecimal("-0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_UP));
	bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_HALF_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_UP));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_HALF_UP bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_UP));
	// ROUND_HALF_DOWN: Округление вверх, если число после запятой > .5
	println();
	println("ROUND_HALF_DOWN: Округление вверх, если число после запятой > .5");
	bdr = new BigDecimal("0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_DOWN));
	bdr = new BigDecimal("-0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_DOWN));
	bdr = new BigDecimal("0.336");
	print("bdr = " + bdr);
	println(" ROUND_HALF_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_DOWN));
	bdr = new BigDecimal("-0.336");
	print("bdr = " + bdr);
	println(" ROUND_HALF_DOWN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_DOWN));
	// ROUND_HALF_EVEN: Округление по четности
	println();
	println("ROUND_HALF_EVEN: Округление по четности");
	bdr = new BigDecimal("0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_EVEN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_EVEN));
	bdr = new BigDecimal("0.325");
	print("bdr = " + bdr);
	println(" ROUND_HALF_EVEN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_EVEN));
	bdr = new BigDecimal("-0.335");
	print("bdr = " + bdr);
	println(" ROUND_HALF_EVEN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_EVEN));
	bdr = new BigDecimal("-0.325");
	print("bdr = " + bdr);
	println(" ROUND_HALF_EVEN bdr = " + bdr.setScale(2, BigDecimal.ROUND_HALF_EVEN));
	// ROUND_UNNECESSARY: без округления
	println();
	println("ROUND_UNNECESSARY: без округления");
	bdr = new BigDecimal("0.333");
	print("bdr = " + bdr);
	println(" ROUND_UNNECESSARY bdr = " + bdr.setScale(3, BigDecimal.ROUND_UNNECESSARY));
	bdr = new BigDecimal("-0.333");
	print("bdr = " + bdr);
	println(" ROUND_UNNECESSARY bdr = " + bdr.setScale(3, BigDecimal.ROUND_UNNECESSARY));
	println("\nПример деления с округленим");
	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);
	println("bd1d3 = " + bd1d3);
	println("\nПримеры сравнения");
	BigDecimal a = new BigDecimal("2.00");
	BigDecimal b = new BigDecimal("2.0");
	println("a = " + a + " b = " + b);
	println("a.equals(b) = " + a.equals(b)); // ложь
	// возвращает (-1 если a < b), (0 если a == b), (1 если a > b)
	println("a.compareTo(b) = " + a.compareTo(b));
	// возвращает (-1 если a < 0), (0 если a == 0), (1 если a > 0)
	println("a.signum() = " + a.signum());
	// убираем незначащие нули в конце BigDecimal
	println("\nУбираем незначащие нули в конце 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 = " + bd_3);
	println("bd_3 = " + bd_3.stripTrailingZeros());
	}
	}

view rawBigDecimalClass.java hosted with ❤ by GitHub

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

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

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