Класс BigDecimal

java.lang.Object

java.lang.Number

java.math.BigDecimal

Все реализуемые интерфейсы:: Serializable, Comparable<BigDecimal>

public class BigDecimal extends Number implements Comparable<BigDecimal>

Неизменяемые десятичные числа с произвольной точностью и знаком. Объект класса


 BigDecimal

состоит из целого числа произвольной точности немасштабированное значение и 32-разрядного целого числа масштаб. Если масштаб равен нулю или положителен, он представляет количество цифр справа от десятичной точки. Если масштаб отрицательный, немасштабированное значение числа умножается на десять в степени, равной отрицанию масштаба. Значение числа, представленного объектом класса BigDecimal, соответственно равно (unscaledValue × 10^-scale).

Класс BigDecimal предоставляет операции для арифметических вычислений, изменения масштаба, округления, сравнения, создания хеш-кодов и преобразования в разные форматы. Метод toString() предоставляет каноническое представление объекта класса BigDecimal.

Класс BigDecimal предоставляет пользователю полный контроль над поведением при округлениях. Если режим округления не указан, и точный результат не может быть представлен, выбрасывается ArithmeticException; в противном случае, вычисления могут быть выполнены с заданной точностью и режимом округления, передав соответствующий объект MathContext в операцию. В любом случае, доступно восемь режимов округления. Использование целочисленных полей этого класса (таких как ROUND_HALF_UP) для представления режимов округления устарело; вместо этого следует использовать перечисления RoundingMode enum (например, RoundingMode.HALF_UP).

Когда объекту класса MathContext передаётся значение точности 0 (например, MathContext.UNLIMITED), арифметические операции выполняются точно, как и арифметические методы, которые не принимают объект MathContext. Как следствие точного вычисления, режим округления объекта MathContext с точностью 0 не используется и, следовательно, не имеет значения. В случае деления точный частный результат может иметь бесконечное десятичное представление; например, 1, деленное на 3. Если частный результат имеет бесконечное десятичное представление и операция должна вернуть точный результат, выбрасывается ArithmeticException. В противном случае, возвращается точный результат деления, как и для других операций.

Когда значение точности не равно 0, правила арифметики с плавающей запятой в целом совместимы с выбранными режимами операций арифметики, определёнными в ANSI X3.274-1996 и ANSI X3.274-1996/AM 1-2000 (раздел 7.4). В отличие от этих стандартов, класс BigDecimal содержит множество режимов округления. Любые конфликты между этими стандартами ANSI и спецификацией класса BigDecimal разрешаются в пользу спецификации BigDecimal.

Поскольку одно и то же числовое значение может иметь разные представления (с разными масштабами), правила арифметики и округления должны указывать как числовой результат, так и масштаб, используемый в представлении результата. Разные представления одного и того же числового значения называются членами одного и того же когорты. Естественный порядок BigDecimal рассматривает членов одной и той же когорты как равные друг другу. В отличие от этого, метод equals требует, чтобы совпадали как числовое значение, так и представление для того, чтобы имело место равенство. Результаты методов, таких как scale и unscaledValue(), будут различаться для численных значений с одинаковым значением, но разными представлениями.

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

Для всех арифметических операторов выполнение операции происходит так, как будто сначала вычисляется точный промежуточный результат, а затем он округляется до заданного количества цифр (если необходимо) с использованием выбранного режима округления. Если точный результат не возвращается, некоторые позиции цифр точного результата отбрасываются. При округления, увеличивающем величину возвращаемого результата, может появиться новая позиция цифры из-за переноса, распространяющегося на ведущую цифру "9". Например, округление значения 999,9 до трёх цифр с округлением вверх будет численно равно одной тысячи, представленной как 100×10¹. В таких случаях новая цифра "1" является ведущей позицией цифры возвращаемого результата.

Для методов и конструкторов с параметром MathContext, если результат неточен, но режим округления равен UNNECESSARY, будет выбрасываться ArithmeticException.

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

Предпочтительные масштабы для результатов арифметических операций
Операция	Предпочтительный масштаб результата
Сложение	max(масштаб_слагаемого, масштаб_слагаемого)
Вычитание	max(масштаб_уменьшаемого, масштаб_вычитаемого)
Умножение	масштаб_множителя + масштаб_множимого
Деление	масштаб_делимого - масштаб_делителя
Квадратный корень	масштаб_подкоренного_числа/2

Эти масштабы используются методами, возвращающими точные арифметические результаты; за исключением того, что для точного деления может потребоваться больший масштаб, так как точный результат может иметь больше цифр. Например, 1/32 равно 0.03125.

Перед округлением масштаб логического точного промежуточного результата является предпочтительным масштабом для данной операции. Если точный числовой результат не может быть представлен в precision цифрах, округление выбирает набор цифр для возврата, и масштаб результата уменьшается от масштаба промежуточного результата до наименьшего масштаба, который может представить precision цифры, фактически возвращаемые. Если точный результат может быть представлен не более чем precision цифрами, возвращается представление результата со масштабом, наиболее близким к предпочтительному масштабу. В частности, точно представимый частный результат может быть представлен в меньшем количестве precision цифр путём удаления конечных нулей и уменьшения масштаба. Например, при округлении до трёх цифр с использованием режима округления floor,
19/100 = 0.19 // integer=19, scale=2
но
21/110 = 0.190 // integer=190, scale=3

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

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

Для работы со масштабом объекта класса BigDecimal предоставляются два типа операций: операции масштабирования/округления и операции перемещения десятичной точки. Операции масштабирования/округления (setScale и round) возвращают объект класса BigDecimal, значение которого приблизительно (или точно) равно значению операнда, но масштаб или точность которого являются заданными значениями; то есть, они увеличивают или уменьшают точность хранящегося числа с минимальным влиянием на его значение. Операции перемещения десятичной точки (movePointLeft и movePointRight) возвращают объект класса BigDecimal, созданный из операнда путём перемещения десятичной точки на указанное расстояние в указанном направлении.

В качестве 32-разрядного целого числа набор значений масштаба большой, но ограничен. Если масштаб результата превысит диапазон 32-разрядного целого числа, как по переполнению, так и по недополнению, операция может сгенерировать ArithmeticException.

Для краткости и ясности в описаниях методов класса BigDecimal используется псевдокод. Выражение псевдокода (i + j) обозначает «объект класса BigDecimal, значение которого равно значению BigDecimal i, прибавленному к значению BigDecimal j». Выражение псевдокода (i == j) обозначает «true тогда и только тогда, когда BigDecimal i представляет такое же значение, как и BigDecimal j». Другие выражения псевдокода интерпретируются аналогично. Квадратные скобки используются для представления пары конкретного BigInteger и масштаба, определяющих значение BigDecimal; например, [19, 2] — это BigDecimal, численно равное 0,19 и имеющее масштаб 2.

Все методы и конструкторы этого класса выбрасывают NullPointerException, когда в качестве параметра передаётся ссылка на объект null.

Примечание API:

Следует проявлять осторожность при использовании объектов BigDecimal в качестве ключей в SortedMap или элементов в SortedSet, так как естественный порядок сортировки


 BigDecimal

(естественный порядок) не согласован с equals. См. Comparable, SortedMap или SortedSet для получения дополнительной информации.

Отношение к десятичной арифметике IEEE 754

Начиная с его пересмотра 2008 года, Стандарт IEEE 754 для арифметики с плавающей точкой охватывает десятичные форматы и операции. Хотя существуют общие сходства в десятичной арифметике, определенной IEEE 754 и этим классом, существуют и заметные различия. Основное сходство, которым обладают


 BigDecimal

и десятичная арифметика IEEE 754, заключается в концептуальной операции вычисления математического значения бесконечно точного вещественного числа операции, а затем сопоставления этого вещественного числа с представимым десятичным значением с плавающей точкой в соответствии с политикой округления. Политика округления называется режимом округления для BigDecimal и называется атрибутом направления округления в IEEE 754-2019. Когда точное значение не представимо, политика округления определяет, какое из двух представимых десятичных значений, охватывающих точное значение, выбирается в качестве вычисленного результата. Понятие предпочтительного масштаба/предпочтительного показателя степени также разделяется обеими системами.

В отношении различий IEEE 754 включает несколько типов значений, не моделируемых BigDecimal, включая отрицательный ноль, знакомые бесконечности и NaN (не число). IEEE 754 определяет форматы, которые параметризуются основанием (двоичным или десятичным), числом цифр точности и диапазоном показателей степени. Формат определяет набор представимых значений. Большинство операций принимают в качестве входных данных одно или несколько значений заданного формата и производят результат в том же формате. Масштаб BigDecimal эквивалентен отрицанию показателя степени значения IEEE 754. Значения BigDecimal не имеют формата в том же смысле; все значения имеют тот же возможный диапазон масштаба/показателя степени, а ненумерованный значение имеет произвольную точность. Вместо этого для BigDecimal операций, принимающих параметр MathContext, если MathContext имеет ненулевую точность, набор возможных представимых значений результата определяется точностью параметра MathContext. Например, в BigDecimal, если ненулевое трехзначное число и ненулевое четырехзначное число перемножаются в контексте объекта MathContext с точностью в три знака, результат будет иметь три знака (при условии отсутствия переполнения или недополнения и т.д.).

Политики округления, реализованные BigDecimal операциями, указанными режимами округления, являются надмножеством атрибутов направления округления IEEE 754.

Арифметика BigDecimal наиболее похожа на десятичную арифметику IEEE 754, если MathContext, соответствующий десятичному формату IEEE 754, например, decimal64 или decimal128, используется для округления всех начальных значений и промежуточных операций. Вычисленные числовые значения могут отличаться, если диапазон показателей степени приближаемого формата IEEE 754 будет превышен, поскольку MathContext не ограничивает масштаб BigDecimal результатов. Операции, которые могли бы сгенерировать NaN или точную бесконечность, например, деление на ноль, вызывают исключение ArithmeticException в арифметике BigDecimal.

Алгоритмическая сложность

Операции со значениями BigDecimal имеют широкий диапазон алгоритмических сложностей; в общем случае эти сложности зависят как от размера ненумерованного значения, так и от размера масштаба. Например, точное умножение двух значений BigDecimal подчиняется тем же ограничениям сложности, что и умножение BigInteger ненумерованных значений. В отличие от этого, значение BigDecimal с компактным представлением, таким как new BigDecimal(1E-1000000000), имеет toPlainString() результат, содержащий более миллиарда символов.

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

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

С тех пор:

1.1

Внешние спецификации

См. также:

Краткое описание полей

Модификатор и тип	Поле	Описание
`static final BigDecimal`	`ONE`	Значение 1 со шкалой 0.
`static final int`	`ROUND_CEILING`	Устаревшее. Используйте `RoundingMode.CEILING` вместо этого.
`static final int`	`ROUND_DOWN`	Устаревшее. Используйте `RoundingMode.DOWN` вместо этого.
`static final int`	`ROUND_FLOOR`	Устаревшее. Используйте `RoundingMode.FLOOR` вместо этого.
`static final int`	`ROUND_HALF_DOWN`	Устаревшее. Используйте `RoundingMode.HALF_DOWN` вместо этого.
`static final int`	`ROUND_HALF_EVEN`	Устаревшее. Используйте `RoundingMode.HALF_EVEN` вместо этого.
`static final int`	`ROUND_HALF_UP`	Устаревшее. Используйте `RoundingMode.HALF_UP` вместо этого.
`static final int`	`ROUND_UNNECESSARY`	Устаревшее. Используйте `RoundingMode.UNNECESSARY` вместо этого.
`static final int`	`ROUND_UP`	Устаревшее. Используйте `RoundingMode.UP` вместо этого.
`static final BigDecimal`	`TEN`	Значение 10 со шкалой 0.
`static final BigDecimal`	`TWO`	Значение 2 со шкалой 0.
`static final BigDecimal`	`ZERO`	Значение 0 со шкалой 0.

Краткое описание конструкторов

Конструктор	Описание
`BigDecimal(char[] in)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`, принимая такую же последовательность символов, как и конструктор `BigDecimal(String)`.
`BigDecimal(char[] in, int offset, int len)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`, принимая такую же последовательность символов, как и конструктор `BigDecimal(String)`, но позволяя указать подмассив.
`BigDecimal(char[] in, int offset, int len, MathContext mc)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`, принимая такую же последовательность символов, как и конструктор `BigDecimal(String)`, позволяя указать подмассив и применяя округление в соответствии с настройками контекста.
`BigDecimal(char[] in, MathContext mc)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`, принимая такую же последовательность символов, как и конструктор `BigDecimal(String)`, и с округлением в соответствии с настройками контекста.
`BigDecimal(double val)`	Преобразует `double` в `BigDecimal`, представляющее собой точное десятичное представление двоичного значения с плавающей запятой `double`.
`BigDecimal(double val, MathContext mc)`	Преобразует `double` в `BigDecimal` с округлением в соответствии с настройками контекста.
`BigDecimal(int val)`	Преобразует `int` в `BigDecimal`.
`BigDecimal(int val, MathContext mc)`	Преобразует `int` в `BigDecimal` с округлением в соответствии с настройками контекста.
`BigDecimal(long val)`	Преобразует `long` в `BigDecimal`.
`BigDecimal(long val, MathContext mc)`	Преобразует `long` в `BigDecimal` с округлением в соответствии с настройками контекста.
`BigDecimal(String val)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`.
`BigDecimal(String val, MathContext mc)`	Преобразует строковое представление `BigDecimal` в `BigDecimal`, принимая те же строки, что и конструктор `BigDecimal(String)`, с округлением в соответствии с настройками контекста.
`BigDecimal(BigInteger val)`	Преобразует `BigInteger` в `BigDecimal`.
`BigDecimal(BigInteger unscaledVal, int scale)`	Преобразует значение `BigInteger` без масштаба и масштаб `int` в `BigDecimal`.
`BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)`	Преобразует значение `BigInteger` без масштаба и масштаб `int` в `BigDecimal`, с округлением в соответствии с настройками контекста.
`BigDecimal(BigInteger val, MathContext mc)`	Преобразует `BigInteger` в `BigDecimal` с округлением в соответствии с настройками контекста.

Краткое описание методов

Модификатор и тип	Метод	Описание
`BigDecimal`	`abs()`	Возвращает `BigDecimal`, значение которого является абсолютным значением этого `BigDecimal`, а масштаб — `this.scale()`.
`BigDecimal`	`abs(MathContext mc)`	Возвращает `BigDecimal`, значение которого является абсолютным значением этого `BigDecimal`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`add(BigDecimal augend)`	Возвращает `BigDecimal`, значение которого равно `(this + augend)`, а масштаб — `max(this.scale(), augend.scale())`.
`BigDecimal`	`add(BigDecimal augend, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(this + augend)`, с округлением в соответствии с настройками контекста.
`byte`	`byteValueExact()`	Преобразует этот `BigDecimal` в `byte`, проверяя на потерю информации.
`int`	`compareTo(BigDecimal val)`	Сравнивает этот `BigDecimal` численно с указанным `BigDecimal`.
`BigDecimal`	`divide(BigDecimal divisor)`	Возвращает `BigDecimal`, значение которого равно `(this / divisor)`, а предпочтительный масштаб — `(this.scale() - divisor.scale())`; если точное частное не может быть представлено (потому что оно имеет бесконечное десятичное разложение), генерируется `ArithmeticException`.
`BigDecimal`	`divide(BigDecimal divisor, int roundingMode)`	Устарело. Вместо этого устаревшего метода следует использовать метод `divide(BigDecimal, RoundingMode)`.
`BigDecimal`	`divide(BigDecimal divisor, int scale, int roundingMode)`	Устарело. Вместо этого устаревшего метода следует использовать метод `divide(BigDecimal, int, RoundingMode)`.
`BigDecimal`	`divide(BigDecimal divisor, int scale, RoundingMode roundingMode)`	Возвращает `BigDecimal`, значение которого равно `(this / divisor)`, а масштаб указан.
`BigDecimal`	`divide(BigDecimal divisor, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(this / divisor)`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`divide(BigDecimal divisor, RoundingMode roundingMode)`	Возвращает `BigDecimal`, значение которого равно `(this / divisor)`, а масштаб — `this.scale()`.
`BigDecimal[]`	`divideAndRemainder(BigDecimal divisor)`	Возвращает двухэлементный массив `BigDecimal`, содержащий результат `divideToIntegralValue`, за которым следует результат `remainder` для двух операндов.
`BigDecimal[]`	`divideAndRemainder(BigDecimal divisor, MathContext mc)`	Возвращает двухэлементный массив `BigDecimal`, содержащий результат `divideToIntegralValue`, за которым следует результат `remainder` для двух операндов, вычисленных с округлением в соответствии с настройками контекста.
`BigDecimal`	`divideToIntegralValue(BigDecimal divisor)`	Возвращает `BigDecimal`, значение которого является целой частью частного `(this / divisor)`, округленного вниз.
`BigDecimal`	`divideToIntegralValue(BigDecimal divisor, MathContext mc)`	Возвращает `BigDecimal`, значение которого является целой частью `(this / divisor)`.
`double`	`doubleValue()`	Преобразует этот `BigDecimal` в `double`.
`boolean`	`equals(Object x)`	Сравнивает этот `BigDecimal` с указанным `Object` на равенство.
`float`	`floatValue()`	Преобразует этот `BigDecimal` в `float`.
`int`	`hashCode()`	Возвращает хэш-код для этого `BigDecimal`.
`int`	`intValue()`	Преобразует этот `BigDecimal` в `int`.
`int`	`intValueExact()`	Преобразует этот `BigDecimal` в `int`, проверяя на потерю информации.
`long`	`longValue()`	Преобразует этот `BigDecimal` в `long`.
`long`	`longValueExact()`	Преобразует этот `BigDecimal` в `long`, проверяя на потерю информации.
`BigDecimal`	`max(BigDecimal val)`	Возвращает максимум из этого `BigDecimal` и `val`.
`BigDecimal`	`min(BigDecimal val)`	Возвращает минимум из этого `BigDecimal` и `val`.
`BigDecimal`	`movePointLeft(int n)`	Возвращает `BigDecimal`, эквивалентный этому с десятичной точкой, сдвинутой на `n` позиций влево.
`BigDecimal`	`movePointRight(int n)`	Возвращает `BigDecimal`, эквивалентный этому с десятичной точкой, сдвинутой на `n` позиций вправо.
`BigDecimal`	`multiply(BigDecimal multiplicand)`	Возвращает `BigDecimal`, значение которого равно `(this × multiplicand)`, а масштаб — `(this.scale() + multiplicand.scale())`.
`BigDecimal`	`multiply(BigDecimal multiplicand, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(this × multiplicand)`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`negate()`	Возвращает `BigDecimal`, значение которого равно `(-this)`, а масштаб — `this.scale()`.
`BigDecimal`	`negate(MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(-this)`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`plus()`	Возвращает `BigDecimal`, значение которого равно `(+this)`, а масштаб — `this.scale()`.
`BigDecimal`	`plus(MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(+this)`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`pow(int n)`	Возвращает `BigDecimal`, значение которого равно `(thisⁿ)`. Степень вычисляется точно, с неограниченной точностью.
`BigDecimal`	`pow(int n, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(thisⁿ)`.
`int`	`precision()`	Возвращает точность этого `BigDecimal`.
`BigDecimal`	`remainder(BigDecimal divisor)`	Возвращает `BigDecimal`, значение которого равно `(this % divisor)`.
`BigDecimal`	`remainder(BigDecimal divisor, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(this % divisor)`, с округлением в соответствии с настройками контекста.
`BigDecimal`	`round(MathContext mc)`	Возвращает `BigDecimal`, округленное в соответствии с настройками `MathContext`.
`int`	`scale()`	Возвращает масштаб этого `BigDecimal`.
`BigDecimal`	`scaleByPowerOfTen(int n)`	Возвращает BigDecimal, численное значение которого равно (`this` * 10ⁿ).
`BigDecimal`	`setScale(int newScale)`	Возвращает `BigDecimal`, масштаб которого равен указанному значению, а значение численно равно этому `BigDecimal`.
`BigDecimal`	`setScale(int newScale, int roundingMode)`	Устарело. Вместо этого устаревшего метода следует использовать метод `setScale(int, RoundingMode)`.
`BigDecimal`	`setScale(int newScale, RoundingMode roundingMode)`	Возвращает `BigDecimal`, масштаб которого равен указанному значению, а непромасштабированное значение определяется умножением или делением непромасштабированного значения этого `BigDecimal` на соответствующую степень десяти для сохранения его общего значения.
`short`	`shortValueExact()`	Преобразует этот `BigDecimal` в `short`, проверяя на потерю информации.
`int`	`signum()`	Возвращает функцию signum этого `BigDecimal`.

`BigDecimal`	`sqrt(MathContext mc)`	Возвращает приближенное значение квадратного корня из `this` с округлением в соответствии с настройками контекста.
`BigDecimal`	`stripTrailingZeros()`	Возвращает `BigDecimal`, численно равное этому, но без последующих нулей в представлении.
`BigDecimal`	`subtract(BigDecimal subtrahend)`	Возвращает `BigDecimal`, значение которого равно `(this - subtrahend)`, а масштаб — `max(this.scale(), subtrahend.scale())`.
`BigDecimal`	`subtract(BigDecimal subtrahend, MathContext mc)`	Возвращает `BigDecimal`, значение которого равно `(this - subtrahend)`, с округлением в соответствии с настройками контекста.
`BigInteger`	`toBigInteger()`	Преобразует этот `BigDecimal` в `BigInteger`.
`BigInteger`	`toBigIntegerExact()`	Преобразует этот `BigDecimal` в `BigInteger`, проверяя наличие потерь информации.
`String`	`toEngineeringString()`	Возвращает строковое представление этого `BigDecimal`, используя инженерную нотацию, если требуется экспонента.
`String`	`toPlainString()`	Возвращает строковое представление этого `BigDecimal` без поля экспоненты.
`String`	`toString()`	Возвращает строковое представление этого `BigDecimal`, используя научную нотацию, если требуется экспонента.
`BigDecimal`	`ulp()`	Возвращает размер ulp (единица в последнем разряде) этого `BigDecimal`.
`BigInteger`	`unscaledValue()`	Возвращает `BigInteger`, значение которого является неопределённым значением этого `BigDecimal`.
`static BigDecimal`	`valueOf(double val)`	Преобразует `double` в `BigDecimal`, используя каноническое строковое представление `double`, предоставленное методом `Double.toString(double)`.
`static BigDecimal`	`valueOf(long val)`	Преобразует значение `long` в `BigDecimal` с масштабом ноль.
`static BigDecimal`	`valueOf(long unscaledVal, int scale)`	Преобразует неопределённое значение `long` и масштаб `int` в `BigDecimal`.

Методы, объявленные в классе java.lang.Number

byteValue, shortValue

Методы, объявленные в классе java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Подробное описание полей

ZERO

public static final BigDecimal ZERO

Значение 0 со масштабом 0.

С момента:: 1.5

ONE

public static final BigDecimal ONE

Значение 1 со масштабом 0.

С момента:: 1.5

TWO

public static final BigDecimal TWO

Значение 2 со масштабом 0.

С момента:: 19

TEN

public static final BigDecimal TEN

Значение 10 со масштабом 0.

С момента:: 1.5

ROUND_UP

@Deprecated(since="9") public static final int ROUND_UP

Устаревшее.

Используйте RoundingMode.UP вместо этого.

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

См. также:

ROUND_DOWN

@Deprecated(since="9") public static final int ROUND_DOWN

Устаревшее.

Используйте RoundingMode.DOWN вместо этого.

Режим округления к нулю. Никогда не увеличивает цифру перед отбрасываемой дробью (т. е. усекает). Обратите внимание, что этот режим округления никогда не увеличивает значение вычисленного результата.

См. также:

ROUND_CEILING

@Deprecated(since="9") public static final int ROUND_CEILING

Устаревшее.

Используйте RoundingMode.CEILING вместо этого.

Режим округления до положительной бесконечности. Если BigDecimal положительно, ведет себя как для ROUND_UP; если отрицательно, ведет себя как для ROUND_DOWN. Обратите внимание, что этот режим округления никогда не уменьшает вычисленное значение.

См. также:

ROUND_FLOOR

@Deprecated(since="9") public static final int ROUND_FLOOR

Устаревшее.

Используйте RoundingMode.FLOOR вместо этого.

Режим округления до отрицательной бесконечности. Если BigDecimal положительно, ведет себя как для ROUND_DOWN; если отрицательно, ведет себя как для ROUND_UP. Обратите внимание, что этот режим округления никогда не увеличивает вычисленное значение.

См. также:

ROUND_HALF_UP

@Deprecated(since="9") public static final int ROUND_HALF_UP

Устаревшее.

Используйте RoundingMode.HALF_UP вместо этого.

Режим округления до ближайшего соседа, если оба соседа равноудалены, в противном случае округляет вверх. Ведёт себя как для ROUND_UP, если отбрасываемая дробь ≥ 0,5; в противном случае, ведет себя как для ROUND_DOWN. Обратите внимание, что это режим округления, который большинство из нас изучали в начальной школе.

См. также:

ROUND_HALF_DOWN

@Deprecated(since="9") public static final int ROUND_HALF_DOWN

Устаревшее.

Используйте RoundingMode.HALF_DOWN вместо этого.

Режим округления до ближайшего соседа, если оба соседа равноудалены, в противном случае округляет вниз. Ведёт себя как для ROUND_UP, если отбрасываемая дробь > 0,5; в противном случае, ведет себя как для ROUND_DOWN.

См. также:

ROUND_HALF_EVEN

@Deprecated(since="9") public static final int ROUND_HALF_EVEN

Устаревшее.

Используйте RoundingMode.HALF_EVEN вместо этого.

Режим округления до ближайшего соседа, если оба соседа равноудалены, в противном случае округляет к ближайшему четному соседу. Ведёт себя как для ROUND_HALF_UP, если цифра слева от отбрасываемой дроби нечетная; ведет себя как для ROUND_HALF_DOWN, если четная. Обратите внимание, что этот режим округления минимизирует накопленную ошибку при многократном применении в последовательности вычислений.

См. также:

ROUND_UNNECESSARY

@Deprecated(since="9") public static final int ROUND_UNNECESSARY

Устаревшее.

Используйте RoundingMode.UNNECESSARY вместо этого.

Режим округления, чтобы утвердить, что запрашиваемое действие имеет точный результат, поэтому округление не нужно. Если этот режим округления задан для операции, которая дает неточный результат, будет брошено ArithmeticException.

См. также:

Подробное описание конструкторов

BigDecimal

public BigDecimal(char[] in, int offset, int len)

Перевод текстового представления BigDecimal в BigDecimal, принимая ту же последовательность символов, что и конструктор BigDecimal(String), при этом разрешено указать подмассив.

Примечание для реализации:: Если последовательность символов уже доступна в массиве символов, использование этого конструктора быстрее, чем преобразование массива char в строку и использование конструктора BigDecimal(String).
Параметры:: in - массив char, являющийся источником символов.; offset - первый символ в массиве для проверки.; len - количество символов для рассмотрения.
Исключения:: NumberFormatException - если in не является допустимым представлением BigDecimal, или указанный подмассив не целиком входит в in.
С момента:: 1.5

BigDecimal

public BigDecimal(char[] in, int offset, int len, MathContext mc)

Примечание для реализации:: Если последовательность символов уже доступна в массиве символов, использование этого конструктора быстрее, чем преобразование массива char в строку и использование конструктора BigDecimal(String).
Параметры:: in - массив char, являющийся источником символов.; offset - первый символ в массиве для проверки.; len - количество символов для рассмотрения.; mc - контекст для использования.
Исключения:: NumberFormatException - если in не является допустимым представлением BigDecimal, или указанный подмассив не целиком входит в in.
С момента:: 1.5

BigDecimal

public BigDecimal(char[] in)

Перевод текстового представления BigDecimal в BigDecimal, принимая ту же последовательность символов, что и конструктор BigDecimal(String).

Примечание для реализации:: Если последовательность символов уже доступна в массиве символов, использование этого конструктора быстрее, чем преобразование массива char в строку и использование конструктора BigDecimal(String).
Параметры:: in - массив char, являющийся источником символов.
Исключения:: NumberFormatException - если in не является допустимым представлением BigDecimal.
С момента:: 1.5

END_OF_DOCUMENT_MARKER

BigDecimal

public BigDecimal(char[] in, MathContext mc)

Преобразует символьное представление BigDecimal в BigDecimal, принимая ту же последовательность символов, что и конструктор BigDecimal(String), с округлением в соответствии с настройками контекста.

Примечание реализации:: Если последовательность символов уже доступна в виде символьного массива, использование этого конструктора быстрее, чем преобразование символьного массива в строку и использование конструктора BigDecimal(String).
Параметры:: in - символьный массив, являющийся источником символов.; mc - контекст, который следует использовать.
Исключения:: NumberFormatException - если in не является допустимым представлением BigDecimal.
С:: 1.5

BigDecimal

public BigDecimal(String val)

Преобразует строковое представление BigDecimal в BigDecimal. Строковое представление состоит из необязательного знака, '+' ( '\u002B') или '-' ('\u002D'), за которым следует последовательность нуля или более десятичных цифр ("целая часть"), необязательно за которой следует дробная часть, необязательно за которой следует экспонента.

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

Экспонента состоит из символа 'e' ('\u0065') или 'E' ('\u0045'), за которым следуют одна или более десятичных цифр.

Более формально, строки, которые принимает этот конструктор, описываются следующей грамматикой:

BigDecimalString:

Sign_opt Significand Exponent_opt

Sign:

+
-

Significand:

IntegerPart . FractionPart_opt
. FractionPart
IntegerPart

IntegerPart:

Digits

FractionPart:

Digits

Exponent:

ExponentIndicator SignedInteger

ExponentIndicator:

e
E

SignedInteger:

Sign_opt Digits

Digits:

Digit
Digits Digit

Digit:

любой символ, для которого Character.isDigit(char) возвращает true, включая 0, 1, 2 ...

Порядок знаков возвращаемого BigDecimal будет равен количеству цифр в дробной части, или нулю, если строка не содержит десятичной точки, с корректировкой на экспоненту; если строка содержит экспоненту, показатель степени вычитается из порядка. Значение полученного порядка должно находиться в диапазоне от Integer.MIN_VALUE до Integer.MAX_VALUE включительно.

Сопоставление символов с цифрами обеспечивается Character.digit(char, int) установленным для преобразования в основание 10. Строка не должна содержать никаких дополнительных символов (например, пробелов).

Примеры:
Значение возвращаемого BigDecimal равно мантисса × 10^{экспонента}. Для каждой строки слева показано соответствующее представление [BigInteger, scale] справа.

 "0"            [0,0]
 "0.00"         [0,2]
 "123"          [123,0]
 "-123"         [-123,0]
 "1.23E3"       [123,-1]
 "1.23E+3"      [123,-1]
 "12.3E+7"      [123,-6]
 "12.0"         [120,1]
 "12.3"         [123,1]
 "0.00123"      [123,5]
 "-1.23E-12"    [-123,14]
 "1234.5E-4"    [12345,5]
 "0E+7"         [0,-7]
 "-0"           [0,0]

Примечание API:: Для значений, отличных от float и double NaN и ±Infinity, этот конструктор совместим со значениями, возвращаемыми Float.toString(float) и Double.toString(double). Это обычно предпочтительный способ преобразования float или double в BigDecimal, так как он не страдает от непредсказуемости конструктора BigDecimal(double).
Параметры:: val - строковое представление BigDecimal.
Исключения:: NumberFormatException - если val не является допустимым представлением BigDecimal.

BigDecimal

public BigDecimal(String val, MathContext mc)

Преобразует строковое представление BigDecimal в BigDecimal, принимая те же строки, что и конструктор BigDecimal(String), с округлением в соответствии с настройками контекста.

Параметры:: val - строковое представление BigDecimal.; mc - контекст для использования.
Исключения:: NumberFormatException - если val не является допустимым представлением BigDecimal.
С:: 1.5

BigDecimal

public BigDecimal(double val)

Преобразует значение типа double в BigDecimal, которое является точным десятичным представлением двоичного значения с плавающей точкой double. Порядок возвращаемого BigDecimal - наименьшее значение, при котором (10^scale × val) является целым числом.

Примечания:

Результаты этого конструктора могут быть несколько непредсказуемыми. Можно предположить, что запись new BigDecimal(0.1) в Java создает BigDecimal, который точно равен 0,1 (безмасштабное значение 1, с порядком 1), но на самом деле он равен 0.1000000000000000055511151231257827021181583404541015625. Это связано с тем, что 0,1 не может быть точно представлен как double (или, вообще, как двоичная дробь конечной длины). Таким образом, значение, которое передаётся в конструктор, не точно равно 0,1, несмотря на внешние данные.
Конструктор String, с другой стороны, полностью предсказуем: запись new BigDecimal("0.1") создаёт BigDecimal, который точно равен 0,1, как и ожидалось. Поэтому рекомендуется использовать конструктор строки вместо этого.
При необходимости использования значения double в качестве источника для BigDecimal, обратите внимание, что этот конструктор обеспечивает точное преобразование; он не даёт тот же результат, что и преобразование double в String с помощью метода Double.toString(double) и последующим использованием конструктора BigDecimal(String). Чтобы получить этот результат, используйте метод static valueOf(double).

Параметры:: val - значение типа double, которое должно быть преобразовано в BigDecimal.
Исключения:: NumberFormatException - если val является бесконечным или NaN.

BigDecimal

public BigDecimal(double val, MathContext mc)

Преобразует значение типа double в BigDecimal с округлением в соответствии с настройками контекста. Порядок BigDecimal - наименьшее значение, при котором (10^scale × val) является целым числом.

Результаты этого конструктора могут быть несколько непредсказуемыми, и его использование обычно не рекомендуется; см. примечания к конструктору BigDecimal(double).

Параметры:: val - значение типа double, которое должно быть преобразовано в BigDecimal.; mc - контекст для использования.
Исключения:: NumberFormatException - если val является бесконечным или NaN.
С:: 1.5

BigDecimal

public BigDecimal(BigInteger val)

Преобразует BigInteger в BigDecimal. Порядок BigDecimal равен нулю.

Параметры:: val - значение типа BigInteger, которое должно быть преобразовано в BigDecimal.

BigDecimal

public BigDecimal(BigInteger val, MathContext mc)

Преобразует BigInteger в BigDecimal с округлением в соответствии с настройками контекста. Порядок BigDecimal равен нулю.

Параметры:: val - значение типа BigInteger, которое должно быть преобразовано в BigDecimal.; mc - контекст для использования.
С:: 1.5

BigDecimal

public BigDecimal(BigInteger unscaledVal, int scale)

Преобразует BigInteger без масштаба и int порядок в BigDecimal. Значение BigDecimal равно (unscaledVal × 10^-scale).

Параметры:: unscaledVal - без масштаба BigDecimal.; scale - порядок BigDecimal.

BigDecimal

public BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)

Преобразует BigInteger неозначенное значение и int масштаб в BigDecimal, с округлением в соответствии с настройками контекста. Значение BigDecimal равно

(unscaledVal ×
 10^-scale)

, округлено в соответствии с настройками precision и режима округления.

Параметры:: unscaledVal - неозначенное значение BigDecimal.; scale - масштаб BigDecimal.; mc - используемый контекст.
С:: 1.5

BigDecimal

public BigDecimal(int val)

Преобразует int в BigDecimal. Масштаб BigDecimal равен нулю.

Параметры:: val - значение int, которое необходимо преобразовать в BigDecimal.
С:: 1.5

BigDecimal

public BigDecimal(int val, MathContext mc)

Преобразует int в BigDecimal, с округлением в соответствии с настройками контекста. Масштаб BigDecimal до любого округления равен нулю.

Параметры:: val - значение int, которое необходимо преобразовать в BigDecimal.; mc - используемый контекст.
С:: 1.5

BigDecimal

public BigDecimal(long val)

Преобразует long в BigDecimal. Масштаб BigDecimal равен нулю.

Параметры:: val - значение long, которое необходимо преобразовать в BigDecimal.
С:: 1.5

BigDecimal

public BigDecimal(long val, MathContext mc)

Преобразует long в BigDecimal, с округлением в соответствии с настройками контекста. Масштаб BigDecimal до любого округления равен нулю.

Параметры:: val - значение long, которое необходимо преобразовать в BigDecimal.; mc - используемый контекст.
С:: 1.5

Подробное описание методов

valueOf

public static BigDecimal valueOf(long unscaledVal, int scale)

Преобразует long неозначенное значение и int масштаб в BigDecimal.

Примечание API:: Этот статический фабричный метод предоставляется вместо конструктора (long, int), потому что он позволяет повторно использовать часто используемые значения BigDecimal.
Параметры:: unscaledVal - неозначенное значение BigDecimal.; scale - масштаб BigDecimal.
Возвращает:: BigDecimal, значение которого равно (unscaledVal × 10^-scale).

valueOf

public static BigDecimal valueOf(long val)

Преобразует значение long в BigDecimal с масштабом ноль.

Примечание API:: Этот статический фабричный метод предоставляется вместо конструктора (long), потому что он позволяет повторно использовать часто используемые значения BigDecimal.
Параметры:: val - значение BigDecimal.
Возвращает:: BigDecimal, значение которого равно val.

valueOf

public static BigDecimal valueOf(double val)

Преобразует double в BigDecimal, используя каноническое строковое представление double, предоставленное методом Double.toString(double).

Примечание API:: Это, как правило, предпочтительный способ преобразования double (или float) в BigDecimal, так как возвращаемое значение равно значению, полученному при создании BigDecimal из результата применения Double.toString(double).
Параметры:: val - double для преобразования в BigDecimal.
Возвращает:: BigDecimal, значение которого равно или приблизительно равно значению val.
Исключения:: NumberFormatException - если val бесконечен или NaN.
С:: 1.5

add

public BigDecimal add(BigDecimal augend)

Возвращает BigDecimal, значение которого равно

(this +
 augend)

, а масштаб равен

max(this.scale(),
 augend.scale())

Параметры:: augend - значение, которое нужно добавить к этому BigDecimal.
Возвращает:: this + augend

add

public BigDecimal add(BigDecimal augend, MathContext mc)

Возвращает BigDecimal, значение которого равно (this + augend) с округлением в соответствии с настройками контекста. Если одно из чисел равно нулю, и настройка точности отлична от нуля, то другое число, округлённое при необходимости, используется в качестве результата.

Параметры:: augend - значение, которое нужно добавить к этому BigDecimal.; mc - используемый контекст.
Возвращает:: this + augend, округлённое при необходимости.
С:: 1.5

subtract

public BigDecimal subtract(BigDecimal subtrahend)

Возвращает BigDecimal, значение которого равно

(this -
 subtrahend)

, а масштаб равен

max(this.scale(),
 subtrahend.scale())

Параметры:: subtrahend - значение, которое нужно вычесть из этого BigDecimal.
Возвращает:: this - subtrahend

subtract

public BigDecimal subtract(BigDecimal subtrahend, MathContext mc)

Возвращает BigDecimal, значение которого равно (this - subtrahend) с округлением в соответствии с настройками контекста. Если subtrahend равно нулю, то используется это значение, округлённое при необходимости, как результат. Если это значение равно нулю, то результатом является subtrahend.negate(mc).

Параметры:: subtrahend - значение, которое нужно вычесть из этого BigDecimal.; mc - используемый контекст.
Возвращает:: this - subtrahend, округлённое при необходимости.
С:: 1.5

multiply

public BigDecimal multiply(BigDecimal multiplicand)

Возвращает BigDecimal, значение которого равно

(this ×
 multiplicand)

, а масштаб равен

(this.scale() +
 multiplicand.scale())

Параметры:: multiplicand - значение, на которое нужно умножить этот BigDecimal.
Возвращает:: this * multiplicand

multiply

public BigDecimal multiply(BigDecimal multiplicand, MathContext mc)

Возвращает BigDecimal, значение которого равно

(this ×
 multiplicand)

с округлением в соответствии с настройками контекста.

Параметры:: multiplicand - значение, на которое нужно умножить этот BigDecimal.; mc - используемый контекст.
Возвращает:: this * multiplicand, округлённое при необходимости.
С:: 1.5

divide

@Deprecated(since="9") public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

Устарело.

Метод divide(BigDecimal, int, RoundingMode) следует использовать вместо этого устаревшего метода.

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

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

Параметры:

divisor - значение, на которое нужно разделить этот BigDecimal.

scale - масштаб возвращаемого частного BigDecimal.

roundingMode - режим округления, который нужно применить.

Возвращает:

this / divisor

Исключения:

ArithmeticException - если divisor равно нулю, roundingMode==ROUND_UNNECESSARY, и заданного масштаба недостаточно для точного представления результата деления.

IllegalArgumentException - если roundingMode не представляет действительный режим округления.

См. также:

divide

public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

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

Параметры:: divisor - значение, на которое делится этот BigDecimal.; scale - масштаб возвращаемого BigDecimal частного.; roundingMode - режим округления для применения.
Возвращает:: this / divisor
Исключения:: ArithmeticException - если divisor равно нулю, roundingMode==RoundingMode.UNNECESSARY и заданный масштаб недостаточен для точного представления результата деления.
С:: 1.5

divide

@Deprecated(since="9") public BigDecimal divide(BigDecimal divisor, int roundingMode)

Устарело.

Метод divide(BigDecimal, RoundingMode) следует использовать вместо этого устаревшего метода.

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

, а масштаб которого равен this.scale(). Если для генерации результата с заданным масштабом необходимо выполнить округление, применяется указанный режим округления.

Параметры:

divisor - значение, на которое делится этот BigDecimal.

roundingMode - режим округления для применения.

Возвращает:

this / divisor

Исключения:

ArithmeticException - если divisor==0 или roundingMode==ROUND_UNNECESSARY и this.scale() недостаточно для точного представления результата деления.

IllegalArgumentException - если roundingMode не представляет собой допустимый режим округления.

См. также:

divide

public BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode)

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

Параметры:: divisor - значение, на которое делится этот BigDecimal.; roundingMode - режим округления для применения.
Возвращает:: this / divisor
Исключения:: ArithmeticException - если divisor==0, или roundingMode==RoundingMode.UNNECESSARY и this.scale() недостаточно для точного представления результата деления.
С:: 1.5

divide

public BigDecimal divide(BigDecimal divisor)

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

, а предпочтительный масштаб которого равен

(this.scale() -
 divisor.scale())

; если точное частное не может быть представлено (потому что оно имеет непериодическое десятичное разложение), выбрасывается исключение ArithmeticException.

Параметры:: divisor - значение, на которое делится этот BigDecimal.
Возвращает:: this / divisor
Исключения:: ArithmeticException - если точное частное не имеет конечного десятичного разложения, включая деление на ноль
С:: 1.5

divide

public BigDecimal divide(BigDecimal divisor, MathContext mc)

Возвращает BigDecimal, значение которого равно

(this /
 divisor)

, с округлением в соответствии с параметрами контекста.

Параметры:: divisor - значение, на которое делится этот BigDecimal.; mc - контекст для использования.
Возвращает:: this / divisor, округлённый по необходимости.
Исключения:: ArithmeticException - если результат неточен, но режим округления равен UNNECESSARY или mc.precision == 0 и частное имеет непериодическое десятичное разложение, включая деление на ноль
С:: 1.5

divideToIntegralValue

public BigDecimal divideToIntegralValue(BigDecimal divisor)

Возвращает BigDecimal, значение которого равно целой части частного (this / divisor), округленной вниз. Предпочтительный масштаб результата равен

(this.scale() -
 divisor.scale())

Параметры:: divisor - значение, на которое делится этот BigDecimal.
Возвращает:: Целая часть this / divisor.
Исключения:: ArithmeticException - если divisor==0
С:: 1.5

divideToIntegralValue

public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc)

Возвращает BigDecimal, значение которого равно целой части (this / divisor). Поскольку целая часть точного частного не зависит от режима округления, режим округления не влияет на значения, возвращаемые этим методом. Предпочтительный масштаб результата равен (this.scale() - divisor.scale()). Исключение ArithmeticException выбрасывается, если целая часть точного частного требует более mc.precision цифр.

Параметры:: divisor - значение, на которое делится этот BigDecimal.; mc - контекст для использования.
Возвращает:: Целая часть this / divisor.
Исключения:: ArithmeticException - если divisor==0; ArithmeticException - если mc.precision > 0 и результат требует точности более чем mc.precision цифр.
С:: 1.5

remainder

public BigDecimal remainder(BigDecimal divisor)

Возвращает BigDecimal, значение которого равно (this % divisor).

Остаток вычисляется как this.subtract(this.divideToIntegralValue(divisor).multiply(divisor)). Обратите внимание, что это не операция modulo (результат может быть отрицательным).

Параметры:: divisor - значение, на которое делится этот BigDecimal.
Возвращает:: this % divisor.
Исключения:: ArithmeticException - если divisor==0
С:: 1.5

remainder

public BigDecimal remainder(BigDecimal divisor, MathContext mc)

Возвращает BigDecimal, значение которого равно

(this %
 divisor)

с округлением в соответствии с настройками контекста. Настройки MathContext контекста влияют на неявное деление, используемое для вычисления остатка. Вычисление остатка по определению является точным. Поэтому остаток может содержать более чем mc.getPrecision() цифр.

Остаток вычисляется как this.subtract(this.divideToIntegralValue(divisor, mc).multiply(divisor)). Обратите внимание, что это не операция modulo (результат может быть отрицательным).

Параметры:

divisor - значение, на которое делится этот BigDecimal.

mc - контекст для использования.

Возвращает:

this % divisor, округлённый по необходимости.

Исключения:

ArithmeticException - если divisor==0

ArithmeticException - если результат неточен, но режим округления равен UNNECESSARY или mc.precision > 0 и результат this.divideToIntegralValue(divisor) требует точности более чем mc.precision цифр.

С:

1.5

См. также:

divideAndRemainder

public BigDecimal[] divideAndRemainder(BigDecimal divisor)

Возвращает двухелементный массив BigDecimal, содержащий результат divideToIntegralValue, после чего результат remainder для двух операндов.

Обратите внимание, что если необходимы как целая часть частного, так и остаток, этот метод быстрее, чем использование методов divideToIntegralValue и remainder по отдельности, потому что деление требуется выполнить только один раз.

Параметры:

divisor - значение, на которое делится этот BigDecimal, и остаток вычисляется.

Возвращает:

двухелементный массив BigDecimal: частное (результат divideToIntegralValue) — начальный элемент, а остаток — конечный элемент.

Исключения:

ArithmeticException - если divisor==0

С:

1.5

См. также:

divideAndRemainder

public BigDecimal[] divideAndRemainder(BigDecimal divisor, MathContext mc)

Возвращает массив из двух элементов BigDecimal, содержащий результат операции divideToIntegralValue, за которым следует результат операции remainder над двумя операндами, вычисленные с округлением в соответствии с настройками контекста.

Обратите внимание, что если необходимы как целая часть частного, так и остаток, этот метод быстрее, чем использование методов divideToIntegralValue и remainder по отдельности, поскольку деление выполняется только один раз.

Parameters:

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

mc - контекст, который следует использовать.

Returns:

массив из двух элементов BigDecimal: частное (результат операции divideToIntegralValue) — начальный элемент, а остаток — конечный элемент.

Throws:

ArithmeticException - если divisor==0

ArithmeticException - если результат неточен, но режим округления — UNNECESSARY, или mc.precision > 0, и результат операции this.divideToIntegralValue(divisor) потребовал бы точности более чем mc.precision цифр.

Since:

1.5

See Also:

sqrt

public BigDecimal sqrt(MathContext mc)

Возвращает приближение к корню квадратному из this с округлением в соответствии с настройками контекста.

Предпочтительная разрядность возвращаемого результата равна this.scale()/2. Значение возвращаемого результата всегда находится в пределах одной единицы в последнем разряде (ulp) от точного десятичного значения для заданной точности. Если режим округления — HALF_UP, HALF_DOWN или HALF_EVEN, результат находится в пределах половины ulp от точного десятичного значения.

Особые случаи:

Квадратный корень из числа, численно равного ZERO, численно равен ZERO с предпочтительной разрядностью в соответствии с общим правилом выше. В частности, для ZERO, ZERO.sqrt(mc).equals(ZERO) является истинным для любого MathContext в качестве аргумента.

Parameters:

mc - контекст, который следует использовать.

Returns:

корень квадратный из this.

Throws:

ArithmeticException - если this меньше нуля.

ArithmeticException - если запрашивается точный результат (mc.getPrecision()==0), и нет конечного десятичного представления точного результата.

ArithmeticException - если (mc.getRoundingMode()==RoundingMode.UNNECESSARY) и точный результат не может поместиться в mc.getPrecision() цифрах.

Since:

See Also:

pow

public BigDecimal pow(int n)

Возвращает BigDecimal, значение которого равно (thisⁿ). Степень вычисляется точно, с неограниченной точностью.

Параметр n должен находиться в диапазоне от 0 до 999999999 включительно. ZERO.pow(0) возвращает ONE. Обратите внимание, что в будущих версиях может быть расширен диапазон допустимых показателей степени для этого метода.

Parameters:: n - показатель степени, к которому следует возвести это BigDecimal.
Returns:: thisⁿ
Throws:: ArithmeticException - если n выходит за пределы диапазона.
Since:: 1.5

pow

public BigDecimal pow(int n, MathContext mc)

Возвращает BigDecimal, значение которого равно (thisⁿ). Текущая реализация использует основной алгоритм, определенный в стандарте ANSI X3.274-1996, с округлением в соответствии с настройками контекста. В общем случае, возвращаемое числовое значение находится в пределах двух единиц в последнем разряде (ulp) от точного числового значения для выбранной точности. Обратите внимание, что в будущих версиях может быть использован другой алгоритм с уменьшенной допустимой погрешностью и расширенным диапазоном допустимых показателей степени.

Алгоритм X3.274-1996:

Исключение ArithmeticException выбрасывается, если
- abs(n) > 999999999
- mc.precision == 0 и n < 0
- mc.precision > 0 и n имеет более чем mc.precision десятичных цифр
если n равно нулю, ONE возвращается даже если this равно нулю, в противном случае
- если n положительно, результат вычисляется с помощью техники возведения в степень по основанию 2 в единственном накопителе. Отдельные умножения с накопителем используют те же настройки контекста математики, что и в mc, за исключением увеличенной точности до mc.precision + elength + 1, где elength — количество десятичных цифр в n.
- если n отрицательно, результат вычисляется так, как если бы n было положительным; это значение затем делится на единицу с использованием указанной выше рабочей точности.
- Конечное значение из любого из случаев (положительного или отрицательного) затем округляется до целевой точности.

Parameters:: n - показатель степени, к которому следует возвести это BigDecimal.; mc - контекст, который следует использовать.
Returns:: thisⁿ с использованием алгоритма ANSI стандарта X3.274-1996
Throws:: ArithmeticException - если результат неточен, но режим округления — UNNECESSARY, или n выходит за пределы диапазона.
Since:: 1.5

abs

public BigDecimal abs()

Возвращает BigDecimal, значение которого равно модулю этого BigDecimal, и чья разрядность равна this.scale().

Returns:: abs(this)

abs

public BigDecimal abs(MathContext mc)

Возвращает BigDecimal, значение которого равно модулю этого BigDecimal, с округлением в соответствии с настройками контекста.

Parameters:: mc - контекст, который следует использовать.
Returns:: abs(this), округлённый по мере необходимости.
Since:: 1.5

negate

public BigDecimal negate()

Возвращает BigDecimal, значение которого равно (-this), и чья разрядность равна this.scale().

Returns:: -this.

negate

public BigDecimal negate(MathContext mc)

Возвращает BigDecimal, значение которого равно (-this), с округлением в соответствии с настройками контекста.

Parameters:: mc - контекст, который следует использовать.
Returns:: -this, округлённый по мере необходимости.
Since:: 1.5

plus

public BigDecimal plus()

Возвращает BigDecimal, значение которого равно (+this), и чья разрядность равна this.scale().

Этот метод, который просто возвращает это BigDecimal, включён для симметрии с методом унарного минуса negate().

Returns:

this.

Since:

1.5

See Also:

plus

public BigDecimal plus(MathContext mc)

Возвращает BigDecimal, значение которого равно (+this), с округлением в соответствии с настройками контекста.

Эффект этого метода идентичен эффекту метода round(MathContext).

Parameters:

mc - контекст, который следует использовать.

Returns:

this, округлённый по мере необходимости. Результат нуля будет иметь разрядность 0.

Since:

1.5

See Also:

signum

public int signum()

Возвращает функцию знака этого BigDecimal.

Returns:: -1, 0 или 1, в зависимости от того, отрицательно, нулю или положительно значение этого BigDecimal.

scale

public int scale()

Возвращает разрядность этого BigDecimal. Если нулевая или положительная, разрядность — это количество цифр справа от десятичной точки. Если отрицательная, то неопределённое значение числа умножается на десять в степени, равной отрицанию разрядности. Например, разрядность -3 означает, что неопределённое значение числа умножается на 1000.

Returns:: разрядность этого BigDecimal.

precision

public int precision()

Возвращает точность этого BigDecimal. (Точность — это количество цифр в неопределённом значении.)

Точность нулевого значения равна 1.

Returns:: точность этого BigDecimal.
Since:: 1.5

unscaledValue

public BigInteger unscaledValue()

Возвращает BigInteger, значение которого равно немасштабированному значению этого BigDecimal. (Вычисляет

(this *
 10^this.scale())

Возвращает:: немасштабированное значение этого BigDecimal.
С:: 1.2

round

public BigDecimal round(MathContext mc)

Возвращает BigDecimal, округлённое в соответствии с настройками MathContext. Если значение точности равно 0, округление не выполняется.

Результат действия этого метода идентичен результату действия метода plus(MathContext).

Параметры:

mc - контекст, который необходимо использовать.

Возвращает:

BigDecimal, округлённое в соответствии с настройками MathContext.

С:

1.5

См. также:

setScale

public BigDecimal setScale(int newScale, RoundingMode roundingMode)

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

Примечание API:

Поскольку объекты BigDecimal неизменяемы, вызовы этого метода не приводят к изменению исходного объекта, в отличие от обычной соглашения, что методы, имеющие имя setX, изменяют поле X. Вместо этого setScale возвращает объект с соответствующим масштабом; возвращаемый объект может быть или не быть вновь выделенным.

Параметры:

newScale - масштаб значения BigDecimal, которое нужно вернуть.

roundingMode - режим округления для применения.

Возвращает:

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

Исключения:

ArithmeticException - если roundingMode==UNNECESSARY и указанная операция масштабирования потребовали бы округления.

С:

1.5

См. также:

setScale

@Deprecated(since="9") public BigDecimal setScale(int newScale, int roundingMode)

Устарело.

Следует использовать метод setScale(int, RoundingMode) вместо этого устаревшего метода.

Примечание API:

Параметры:

newScale - масштаб значения BigDecimal, которое нужно вернуть.

roundingMode - режим округления для применения.

Возвращает:

Исключения:

ArithmeticException - если roundingMode==ROUND_UNNECESSARY и указанная операция масштабирования потребовали бы округления.

IllegalArgumentException - если roundingMode не представляет действительный режим округления.

См. также:

setScale

public BigDecimal setScale(int newScale)

Возвращает BigDecimal, масштаб которого имеет указанное значение, а значение численно равно значению этого BigDecimal. Бросает исключение ArithmeticException, если это невозможно.

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

Этот метод возвращает тот же результат, что и двухаргументные версии setScale, но избавляет вызывающий метод от необходимости указывать режим округления в тех случаях, когда это не имеет значения.

Примечание API:

Поскольку объекты BigDecimal неизменяемы, вызовы этого метода не приводят к изменению исходного объекта, в отличие от обычной соглашения, что методы, имеющие имя setX, изменяют поле X. Вместо этого setScale возвращает объект с соответствующим масштабом; возвращаемый объект может быть или не быть вновь выделенным.

Параметры:

newScale - масштаб значения BigDecimal, которое нужно вернуть.

Возвращает:

Исключения:

ArithmeticException - если указанная операция масштабирования потребовала бы округления.

См. также:

movePointLeft

public BigDecimal movePointLeft(int n)

Возвращает BigDecimal, который эквивалентен данному, с десятичной точкой смещённой на n позиций влево. Если n неотрицательно, вызов просто добавляет n к масштабу. Если n отрицательно, вызов эквивалентен movePointRight(-n). BigDecimal, возвращаемый этим вызовом, имеет значение

(this ×
 10^-n)

и масштаб

max(this.scale()+n,
 0)

Параметры:: n - количество позиций для смещения десятичной точки влево.
Возвращает:: BigDecimal, который эквивалентен данному, с десятичной точкой смещённой на n позиций влево.
Исключения:: ArithmeticException - если масштаб переполнен.

movePointRight

public BigDecimal movePointRight(int n)

Возвращает BigDecimal, который эквивалентен данному, с десятичной точкой смещённой на n позиций вправо. Если n неотрицательно, вызов просто вычитает n из масштаба. Если n отрицательно, вызов эквивалентен movePointLeft(-n). BigDecimal, возвращаемый этим вызовом, имеет значение

(this
 × 10ⁿ)

и масштаб

max(this.scale()-n,
 0)

Параметры:: n - количество позиций для смещения десятичной точки вправо.
Возвращает:: BigDecimal, который эквивалентен данному, с десятичной точкой смещённой на n позиций вправо.
Исключения:: ArithmeticException - если масштаб переполнен.

scaleByPowerOfTen

public BigDecimal scaleByPowerOfTen(int n)

Возвращает BigDecimal, численное значение которого равно (this * 10ⁿ). Масштаб результата равен (this.scale() - n).

Параметры:: n - показатель степени десяти для масштабирования
Возвращает:: BigDecimal, численное значение которого равно (this * 10ⁿ)
Исключения:: ArithmeticException - если масштаб будет находиться вне диапазона 32-битного целого числа.
С:: 1.5

stripTrailingZeros

public BigDecimal stripTrailingZeros()

Возвращает BigDecimal, численно равный этому, но с удалёнными всеми последующими нулями из представления. Например, удаление последующих нулей из значения BigDecimal 600.0, которое имеет компоненты [BigInteger, scale], равные [6000, 1], даёт 6E2 с компонентами [BigInteger, scale] равными [6, -2]. Если этот BigDecimal численно равен нулю, то возвращается BigDecimal.ZERO.

Возвращает:: численно равный BigDecimal с удалёнными всеми последующими нулями.
Исключения:: ArithmeticException - если масштаб переполнен.
С:: 1.5

compareTo

public int compareTo(BigDecimal val)

Сравнивает это BigDecimal численно со значением, заданным в BigDecimal. Два BigDecimal объекта, равные по значению, но с разным масштабом (например, 2.0 и 2.00), считаются равными этим методом. Такие значения находятся в одной группе. Данный метод предпочтительнее отдельных методов для каждого из шести булевых операторов сравнения (<, ==, >, >=, !=, <=). Предлагаемый подход для выполнения этих сравнений:


 (x.compareTo(y)

<op> 0), где <op> — один из шести операторов сравнения.

Specified by:: compareTo в интерфейсе Comparable<BigDecimal>
API Note:: Примечание: у этого класса есть естественный порядок, несовместимый с equals. Поведение сравнения результата этого метода на равенство 0 аналогично проверке численного равенства значений double.
Parameters:: val - BigDecimal, с которым необходимо сравнить это BigDecimal.
Returns:: -1, 0 или 1, в зависимости от того, является ли это BigDecimal численно меньше, равно или больше val.

equals

public boolean equals(Object x)

Сравнивает это BigDecimal со значением, заданным в


 Object

, на предмет равенства. В отличие от compareTo, этот метод считает два BigDecimal объекта равными только в том случае, если они равны по значению и масштабу. Таким образом, 2.0 не равно 2.00 при сравнении этим методом, поскольку в первом случае компоненты [BigInteger, scale] равны [20, 1], а во втором — [200, 2].

Overrides:

equals в классе Object

API Note:

Один пример, показывающий, как 2.0 и 2.00 не являются взаимозаменяемыми при некоторых арифметических операциях, — это два выражения:

new BigDecimal("2.0" ).divide(BigDecimal.valueOf(3),
 HALF_UP)

, значение которого равно 0.7, и

new BigDecimal("2.00").divide(BigDecimal.valueOf(3),
 HALF_UP)

, значение которого равно 0.67. Поведение этого метода аналогично проверке равенства представлений значений double.

Parameters:

x - Object, с которым необходимо сравнить это BigDecimal.

Returns:

true тогда и только тогда, когда указанный Object является BigDecimal, значение и масштаб которого равны масштабу этого BigDecimal.

See Also:

min

public BigDecimal min(BigDecimal val)

Возвращает минимальное значение этого BigDecimal и val.

Parameters:

val - значение, с которым необходимо вычислить минимум.

Returns:

BigDecimal, значение которого является меньшим из этого BigDecimal и val. Если они равны, как определено методом compareTo, возвращается this.

See Also:

max

public BigDecimal max(BigDecimal val)

Возвращает максимальное значение этого BigDecimal и val.

Parameters:

val - значение, с которым необходимо вычислить максимум.

Returns:

BigDecimal, значение которого является большим из этого BigDecimal и val. Если они равны, как определено методом compareTo, возвращается this.

See Also:

hashCode

public int hashCode()

Возвращает хэш-код для этого BigDecimal. Хэш-код вычисляется как функция от немасштабированного значения и масштаба этого BigDecimal.

Overrides:

hashCode в классе Object

API Note:

Два BigDecimal объекта, которые численно равны, но различаются по масштабу (например, 2.0 и 2.00), как правило, не имеют одинаковый хэш-код.

Returns:

хэш-код для этого BigDecimal.

See Also:

toString

public String toString()

Возвращает строковое представление этого BigDecimal, используя научную запись, если нужен экспоненциальный вид.

Создается стандартная каноническая строковая форма BigDecimal, как будто выполняется следующая последовательность шагов: сначала абсолютное значение немасштабированного значения BigDecimal преобразуется в строку в десятичной системе счисления, используя символы '0' по '9' без ведущих нулей (за исключением случая, когда его значение равно нулю, в этом случае используется один символ '0').

Далее вычисляется скорректированный показатель степени; это отрицательный масштаб плюс число символов в преобразованном немасштабированном значении минус один. То есть, -scale+(ulength-1), где ulength — длина абсолютного значения немасштабированного значения в десятичных цифрах (его точность).

Если масштаб неотрицателен, а скорректированный показатель степени не меньше -6, число будет преобразовано в строковую форму без использования экспоненциальной записи. В этом случае, если масштаб равен нулю, десятичная точка не добавляется, а если масштаб положителен, десятичная точка будет вставлена с масштабом, определяющим количество символов справа от десятичной точки. '0' символов добавляются слева от преобразованного немасштабированного значения при необходимости. Если после этой вставки слева от десятичной точки нет символов, то префиксным символом будет стандартная '0'.

В противном случае (то есть если масштаб отрицателен или скорректированный показатель степени меньше -6), число будет преобразовано в строковую форму с использованием экспоненциальной записи. В этом случае, если преобразованное BigInteger имеет более одной цифры, десятичная точка вставляется после первой цифры. Затем к преобразованному немасштабированному значению (возможно, с вставленной десятичной точкой) добавляется показатель степени в строковой форме; он состоит из буквы 'E', за которой сразу следует показатель степени, преобразованный в строковую форму. Последний записан в десятичной системе счисления, используя символы '0' по '9' без ведущих нулей, и всегда префиксруется знаком '-' ('\u002D'), если показатель степени отрицателен, '+' ('\u002B') в противном случае.

Наконец, вся строка префиксруется знаком минус '-' ('\u002D'), если немасштабированное значение меньше нуля. Если немасштабированное значение равно нулю или положительно, знак не префиксруется.

Примеры:

Для каждого представления [немасштабированное значение, масштаб] слева показана полученная строка справа.

 [123,0]      "123"
 [-123,0]     "-123"
 [123,-1]     "1.23E+3"
 [123,-3]     "1.23E+5"
 [123,1]      "12.3"
 [123,5]      "0.00123"
 [123,10]     "1.23E-8"
 [-123,12]    "-1.23E-10"

Примечания:

Существует взаимно однозначное соответствие между различимыми BigDecimal значениями и результатом этого преобразования. То есть, каждое различимое BigDecimal значение (немасштабированное значение и масштаб) имеет уникальное строковое представление в результате использования toString. Если это строковое представление преобразовать обратно в BigDecimal, используя конструктор BigDecimal(String), то исходное значение будет восстановлено.
Строка, созданная для заданного числа, всегда одинакова; она не зависит от локали. Это означает, что она может использоваться в качестве канонического строкового представления для обмена десятичными данными или в качестве ключа для Hashtable и т. д. Локализованный формат и разбор чисел обрабатывается классом NumberFormat и его подклассами.
Метод toEngineeringString() может использоваться для представления чисел с экспонентой в инженерной нотации, а метод setScale может использоваться для округления BigDecimal до известного числа цифр после десятичной точки.
Используется отображение цифр в символы, предоставляемое Character.forDigit.

Overrides:

toString в классе Object

Returns:

строковое представление этого BigDecimal.

See Also:

toEngineeringString

public String toEngineeringString()

Возвращает строковое представление этого BigDecimal, используя инженерную нотацию, если нужен показатель степени.

Возвращает строку, которая представляет BigDecimal, как описано в методе toString(), за исключением того, что при использовании экспоненциальной нотации показатель степени корректируется для кратности трём (инженерная нотация) таким образом, что целая часть ненулевых значений будет в диапазоне от 1 до 999. При использовании экспоненциальной нотации для нулевых значений используется десятичная точка и одна или две дробные нулевые цифры, чтобы сохранить масштаб нулевого значения. Обратите внимание, что в отличие от вывода метода toString(), вывод этого метода не гарантирует восстановления той же пары [целое число, масштаб] этого BigDecimal, если строка вывода преобразуется обратно в BigDecimal с использованием конструктора строки . Результат этого метода удовлетворяет более слабому ограничению, всегда генерируя численно равный результат при применении конструктора строки к результату метода.

Возвращает:: строковое представление этого BigDecimal, используя инженерную нотацию, если нужен показатель степени.
С:: 1.5

toPlainString

public String toPlainString()

Возвращает строковое представление этого BigDecimal без поля экспоненты. Для значений с положительным масштабом количество цифр справа от десятичной точки используется для указания масштаба. Для значений с нулевым или отрицательным масштабом результирующая строка генерируется так, как если бы значение было преобразовано в численно эквивалентное значение с нулевым масштабом и как если бы все хвостовые нули нулевого масштабного значения были присутствовать в результате. Вся строка предваряется символом минус '-' ('\u002D'), если неотмасштабированное значение меньше нуля. Символ знака не предваряется, если неотмасштабированное значение равно нулю или положительно. Обратите внимание, что если результат этого метода передаётся в конструктор строки , то только числовое значение этого BigDecimal обязательно восстанавливается; представление нового BigDecimal может иметь другой масштаб. В частности, если у этого BigDecimal отрицательный масштаб, строка, полученная в результате этого метода, будет иметь масштаб, равный нулю, при обработке конструктором строки. (Этот метод аналогично ведёт себя как метод toString в версиях 1.4 и более ранних).

Возвращает:

строковое представление этого BigDecimal без поля экспоненты.

С:

1.5

См. также:

toBigInteger

public BigInteger toBigInteger()

Преобразует этот BigDecimal в BigInteger. Это преобразование аналогично преобразованию примитивного типа сужения из double в long, как определено в Спецификации языка Java: любая дробная часть этого BigDecimal будет отброшена. Обратите внимание, что при этом преобразовании может быть потеряна информация о точности значения BigDecimal.

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

Возвращает:: этот BigDecimal, преобразованный в BigInteger.
См. Спецификацию языка Java:: 5.1.3 Преобразование примитивного типа сужения

toBigIntegerExact

public BigInteger toBigIntegerExact()

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

Возвращает:: этот BigDecimal, преобразованный в BigInteger.
Бросает:: ArithmeticException - если у this есть ненулевая дробная часть.
С:: 1.5

longValue

public long longValue()

Преобразует этот BigDecimal в long. Это преобразование аналогично преобразованию примитивного типа сужения из double в short, как определено в Спецификации языка Java: любая дробная часть этого BigDecimal будет отброшена, а если полученное "BigInteger" слишком велико для помещения в long, возвращаются только младшие 64 бита. Обратите внимание, что при этом преобразовании может быть потеряна информация об общем порядке величины и точности этого значения BigDecimal, а также возвращён результат с противоположным знаком.

Указано в:: longValue в классе Number
Возвращает:: этот BigDecimal, преобразованный в long.
См. Спецификацию языка Java:: 5.1.3 Преобразование примитивного типа сужения

longValueExact

public long longValueExact()

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

Возвращает:: этот BigDecimal, преобразованный в long.
Бросает:: ArithmeticException - если у this есть ненулевая дробная часть или он не помещается в long.
С:: 1.5

intValue

public int intValue()

Преобразует этот BigDecimal в int. Это преобразование аналогично преобразованию примитивного типа сужения из double в short, как определено в Спецификации языка Java: любая дробная часть этого BigDecimal будет отброшена, а если полученное "BigInteger" слишком велико для помещения в int, возвращаются только младшие 32 бита. Обратите внимание, что при этом преобразовании может быть потеряна информация об общем порядке величины и точности этого значения BigDecimal, а также возвращён результат с противоположным знаком.

Указано в:: intValue в классе Number
Возвращает:: этот BigDecimal, преобразованный в int.
См. Спецификацию языка Java:: 5.1.3 Преобразование примитивного типа сужения

intValueExact

public int intValueExact()

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

Возвращает:: этот BigDecimal, преобразованный в int.
Бросает:: ArithmeticException - если у this есть ненулевая дробная часть или он не помещается в int.
С:: 1.5

shortValueExact

public short shortValueExact()

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

Возвращает:: этот BigDecimal, преобразованный в short.
Бросает:: ArithmeticException - если у this есть ненулевая дробная часть или он не помещается в short.
С:: 1.5

byteValueExact

public byte byteValueExact()

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

Возвращает:: этот BigDecimal, преобразованный в byte.
Бросает:: ArithmeticException - если у this есть ненулевая дробная часть или он не помещается в byte.
С:: 1.5

floatValue

public float floatValue()

Преобразует это BigDecimal в float. Это преобразование аналогично преобразованию примитивных типов сужения из double в float, как определено в Спецификации языка Java: если у этого BigDecimal слишком большая величина для представления в виде float, он будет преобразован в Float.NEGATIVE_INFINITY или Float.POSITIVE_INFINITY соответственно. Обратите внимание, что даже когда возвращаемое значение конечно, это преобразование может потерять информацию о точности значения BigDecimal.

Определено в:: floatValue в классе Number
Возвращает:: это BigDecimal, преобразованное в float.
См. Спецификацию языка Java:: 5.1.3 Преобразование примитивных типов сужения

doubleValue

public double doubleValue()

Преобразует это BigDecimal в double. Это преобразование аналогично преобразованию примитивных типов сужения из double в float, как определено в Спецификации языка Java: если у этого BigDecimal слишком большая величина для представления в виде double, он будет преобразован в Double.NEGATIVE_INFINITY или Double.POSITIVE_INFINITY соответственно. Обратите внимание, что даже когда возвращаемое значение конечно, это преобразование может потерять информацию о точности значения BigDecimal.

Определено в:: doubleValue в классе Number
Возвращает:: это BigDecimal, преобразованное в double.
См. Спецификацию языка Java:: 5.1.3 Преобразование примитивных типов сужения

ulp

public BigDecimal ulp()

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

[1,
 this.scale()]

Возвращает:: размер ulp для this
С:: 1.5

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://download.java.net/java/early_access/jdk24/docs/api/java.base/java/math/BigDecimal.html