Учебники. Программирование для начинающих.
купить осетинские пироги в ставрополе Центр – 150 руб. Другие районы города – 250 руб. Возможна доставка в ближайшие пригороды Ставрополя.
Programm.ws — это сайт, на котором вы можете почитать литературу по языкам программирования , а так-же посмотреть примеры работающих программ на С++, ассемблере, паскале и много другого..
Программирование — в обычном понимании, это процесс создания компьютерных программ.
В узком смысле (так называемое кодирование) под программированием понимается написание инструкций — программ — на конкретном языке программирования (часто по уже имеющемуся алгоритму — плану, методу решения поставленной задачи). Соответственно, люди, которые этим занимаются, называются программистами (на профессиональном жаргоне — кодерами), а те, кто разрабатывает алгоритмы — алгоритмистами, специалистами предметной области, математиками.
В более широком смысле под программированием понимают весь спектр деятельности, связанный с созданием и поддержанием в рабочем состоянии программ — программного обеспечения ЭВМ. Более точен современный термин — «программная инженерия» (также иначе «инженерия ПО»). Сюда входят анализ и постановка задачи, проектирование программы, построение алгоритмов, разработка структур данных, написание текстов программ, отладка и тестирование программы (испытания программы), документирование, настройка (конфигурирование), доработка и сопровождение.
Cамоучитель по Java
Глава 4. Классы-оболочки
Класс Big Decimal
Класс BigDecimal расположен В пакете java.math .
Каждый объект этого класса хранит два целочисленных значения: мантиссу вещественного числа в виде объекта класса Biglnteger , и неотрицательный десятичный порядок числа типа int .
Например, для числа 76.34862 будет храниться мантисса 7 634 862 в объекте класса Biglnteger , и порядок 5 как целое число типа int . Таким образом, мантисса может содержать любое количество цифр, а порядок ограничен значением константы integer.MAX_VALUE . Результат операции над объектами класса BigDecimal округляется по одному из восьми правил, определяемых следующими статическими целыми константами:
- ROUND_CEILING — округление в сторону большего целого;
- ROUND_DOWN — округление к нулю, к меньшему по модулю целому значению;
- ROUND_FLOOR — округление к меньшему целому;
- ROUND_HALF_DOWN — округление к ближайшему целому, среднее значение округляется к меньшему целому;
- ROUND_HALF_EVEN — округление к ближайшему целому, среднее значение округляется к четному числу;
- ROOND_HALF_UP — округление к ближайшему целому, среднее значение округляется к большему целому;
- ROUND_UNNECESSARY — предполагается, что результат будет целым, и округление не понадобится;
- ROUND_UP — округление от нуля, к большему по модулю целому значению.
В классе BigDecimal четыре конструктора:
- BigDecimal (Biglnteger bi) — объект будет хранить большое целое bi, порядок равен нулю;
- BigDecimal (Biglnteger mantissa, int scale) — задается мантиса mantissa и неотрицательный порядок scale объекта; если порядок scale отрицателен, возникает исключительная ситуация;
- BigDecimal (double d) — объект будет содержать вещественное число удвоенной точности d ; если значение d бесконечно или NaN , то возникает исключительная ситуация;
- BigDecimal (String val)— число задается строкой символов val , которая должна содержать запись числа по правилам языка Java.
При использовании третьего из перечисленных конструкторов возникает неприятная особенность, отмеченная в документации. Поскольку вещественное число при переводе в двоичную форму представляется, как правило, бесконечной двоичной дробью, то при создании объекта, например, BigDecimal(0.1) , мантисса, хранящаяся в объекте, окажется очень большой. Она показана на рис. 4.5. Но при создании такого же объекта четвертым конструктором, BigDecimal («0.1») , мантисса будет равна просто 1.
В Классе переопределены методы doubleValue(), floatValue(), intValue(), longValue() .
Большинство методов этого класса моделируют операции с вещественными числами. Они возвращают объект класса BigDecimal . Здесь буква х обозначает объект класса BigDecimal , буква n — целое значение типа int , буква r — способ округления, одну из восьми перечисленных выше констант:
abs() — абсолютное значение объекта this ;
add(x) — операция this + х ;
divide(х, r) — операция this / х с округлением по способу r ;
divide(х, n, r) — операция this / х с изменением порядка и округлением по способу r ;
mах(х) — наибольшее из this и х ;
min(x) — наименьшее из this и х ;
movePointLeft(n) — сдвиг влево на n разрядов;
movePointRight(n) — сдвиг вправо на n разрядов;
multiply(х) — операция this * х ;
negate() — возврзщает объект с обратным знаком;
scale() — возвращает порядок числз;
setscaie(n) — устзнавливает новый порядок n ;
setscaie(n, r) — устанавливает новый порядок п и округляет число при необходимости по способу r ;
signumo — знак числа, хранящегося в объекте;
subtract(х) — операция this — х ;
toBiginteger() — округление числа, хранящегося в объекте;
unscaiedvalue() —возвращает мантиссу числа.
Листинг 4.4 показывает примеры использования этих методов, а рис. 4.5 — вывод результатов.
Рис. 4.5. Методы класса BigDecimal в программе BigDecimalTest
Листинг 4.4. Методы класса BigDecimal В программе BigDecimalTest
public static void main,( String [] args)
BigDecimal x = new BigDecimal(«-12345.67890123456789»);
BigDecimal у = new BigDecimal(«345.7896e-4»);
BigDecimal z = new BigDecimal(new Biglnteger(«123456789»),8);
System.out.println(«|x| x + у x / у х / у max(x, y) min(x, y) x « 3 x » 3 x * у -x scale of x increase scale of x to 20 decrease scale of x to 10 sign(x) x — у round x mantissa of x mantissa of 0.1 =\n center»>Листинг 4.5. Простейший калькулятор
public static void main(String[] args)
BigDecimal и BigInteger
Класс java.math.BigDecimal предпочтительнее для работы с финансами вместо double, так как более гибок в настройках. Мне не приходилось использовать класс на практике. Но при создании бухгалтерского софта на него стоит обратить внимание.
Создать BigDecimal из числа типа double просто:
BigDecimal bigDecimal = new BigDecimal(1.5);
Можно создать из строки:
BigDecimal bigDecimal = new BigDecimal("1.5");
Чтобы задать количество цифр после запятой, используйте метод setScale(). Хорошей практикой является одновременное указание вместе с масштабом режима округления с помощью setScale(scale, roundingMode). Режим округления задаёт правило округления числа.
bigDecimal.setScale(2);
Есть восемь вариантов режима округления, которые задаются константами:
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.5 -> 1.0 0.4 -> 0.0
ROUND_HALF_DOWN: Округление вверх, если число после запятой > .5
0.5 -> 0.0 0.6 -> 1.0
ROUND_HALF_EVEN: Округление половины по чётности округляет как обычно. Однако, когда округляемая цифра 5, округление будет идти вниз, если цифра слева от 5 чётная и вверх, если нечётная. Это лучше всего иллюстрируется примером:
BigDecimal a = new BigDecimal("2.5"); // цифра слева от 5 чётная, поэтому округление вниз BigDecimal b = new BigDecimal("1.5"); // цифра слева от 5 нечётная, поэтому округление вверх Log.i(TAG, a.setScale(0, BigDecimal.ROUND_HALF_EVEN).toString());// => 2 Log.i(TAG, b.setScale(0, BigDecimal.ROUND_HALF_EVEN).toString());// => 2
ROUND_UNNECESSARY: Используйте ROUND_UNNECESSARY когда необходимо использовать один из методов, который требует ввода режима округления, но известно, что результат округлять не надо.
При делении будьте осторожны и указывайте способ округления в методе divide(). В противном случае можно получить ArithmeticException.
Числа BigDecimal являются неизменными (как String). Это означает, что если создаётся новый объект BigDecimal со значением «2.00», такой объект останется «2.00» и никогда не может быть изменён.
Поэтому методы add(), multiply(), subtract(), divide(), mod() возвращают новый объект BigDecimal, содержащий результат.
Не используйте для сравнения метод equals(), потому что метод будет сравнивать масштабы. Если масштабы различаются. Вместо этого следует использовать методы compareTo() и signum().
Аналогично работайте с классом BigInteger.
BigInteger
Найти наибольшее число из двух при помощи метода max().
BigInteger firstNumber, secondNumber, maxNumber; firstNumber = new BigInteger("900"); secondNumber = new BigInteger("102"); maxNumber = firstNumber.max(secondNumber); System.out.println("The maximum value between " + firstNumber + " and " + secondNumber + " is " + maxNumber);
Bigdecimal что это
JavaRush — это интерактивный онлайн-курс по изучению Java-программирования c нуля. Он содержит 1200 практических задач с проверкой решения в один клик, необходимый минимум теории по основам Java и мотивирующие фишки, которые помогут пройти курс до конца: игры, опросы, интересные проекты и статьи об эффективном обучении и карьере Java‑девелопера.
Подписывайтесь
Язык интерфейса
«Программистами не рождаются» © 2023 JavaRush
Скачивайте наши приложения
«Программистами не рождаются» © 2023 JavaRush
Этот веб-сайт использует данные cookie, чтобы настроить персонально под вас работу сервиса. Используя веб-сайт, вы даете согласие на применение данных cookie. Больше подробностей — в нашем Пользовательском соглашении.
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 в своей программе его необходимо импортировать командой
после чего его можно использовать.
И далее вывод данной программы:
Класс 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. Кроме того, поскольку это налог, обычной практикой является постоянное округление до цента в большую сторону. Таким образом, после расчёта баланса по счетам в конце дня мы никогда не получим недоплату налогов.
И таким образом клиенту выставляется общий счёт на сумму 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:
Вывод данной программы:
Подробно расписывать какие строки кода что выводят я думаю нет необходимости. Все и так понятно из кода.
Хотя эти два класса и важная тема, но она достаточно обширна, а нам надо двигаться дальше.