Класс BigDecimal

public static final BigDecimal ZERO

Значение 0 со шкалой 0.

public static final BigDecimal ONE

Значение 1 со шкалой 0.

public static final BigDecimal TWO

Значение 2 со шкалой 0.

public static final BigDecimal TEN

Значение 10 со шкалой 0.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public BigDecimal(char[] in)

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

public BigDecimal(char[] in, MathContext mc)

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

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]
 

public BigDecimal(String val, MathContext mc)

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

public BigDecimal(double val)

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

Примечания:

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

public BigDecimal(double val, MathContext mc)

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

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

public BigDecimal(BigInteger val)

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

public BigDecimal(BigInteger val, MathContext mc)

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

public BigDecimal(BigInteger unscaledVal, int scale)

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

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

Преобразует BigInteger безмасштабное значение и int масштаб в BigDecimal, с округлением в соответствии с настройками контекста. Значение BigDecimal равно (unscaledVal × 10-scale), округлено в соответствии с настройками precision и режима округления.

public BigDecimal(int val)

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

public BigDecimal(int val, MathContext mc)

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

public BigDecimal(long val)

Преобразует длинное целое число в BigDecimal. Масштаб BigDecimal равен нулю.

public BigDecimal(long val, MathContext mc)

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

public static BigDecimal valueOf(long unscaledVal, int scale)

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

public static BigDecimal valueOf(long val)

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

public static BigDecimal valueOf(double val)

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

public BigDecimal add(BigDecimal augend)

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

public BigDecimal add(BigDecimal augend, MathContext mc)

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

public BigDecimal subtract(BigDecimal subtrahend)

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

public BigDecimal subtract(BigDecimal subtrahend, MathContext mc)

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

public BigDecimal multiply(BigDecimal multiplicand)

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

public BigDecimal multiply(BigDecimal multiplicand, MathContext mc)

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

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

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

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

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

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

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

public BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode)

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

public BigDecimal divide(BigDecimal divisor)

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

public BigDecimal divide(BigDecimal divisor, MathContext mc)

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

public BigDecimal divideToIntegralValue(BigDecimal divisor)

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

public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc)

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

public BigDecimal remainder(BigDecimal divisor)

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

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

public BigDecimal remainder(BigDecimal divisor, MathContext mc)

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

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

public BigDecimal[] divideAndRemainder(BigDecimal divisor)

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

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

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

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

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

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 в качестве аргумента.

public BigDecimal pow(int n)

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

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

public BigDecimal pow(int n, MathContext mc)

Возвращает BigDecimal значение которого равно (thisn). Текущая реализация использует основной алгоритм, определённый в 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 положительно, результат вычисляется с помощью техники возведения в степень с помощью повторяющегося возведения в квадрат в единственный накопитель. Отдельные умножения с накопителем используют те же настройки контекста математики, что и в mc, за исключением увеличенной точности до mc.precision + elength + 1, где elength — число десятичных знаков в n.
  • если n отрицательно, результат вычисляется так, как если бы n было положительным; затем это значение делится на единицу с использованием указанной выше рабочей точности.
  • Конечное значение из положительного или отрицательного случая затем округляется до целевой точности.

public BigDecimal abs()

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

public BigDecimal abs(MathContext mc)

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

public BigDecimal negate()

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

public BigDecimal negate(MathContext mc)

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

public BigDecimal plus()

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

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

public BigDecimal plus(MathContext mc)

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

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

public int signum()

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

public int scale()

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

public int precision()

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

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

public BigInteger unscaledValue()

Возвращает BigInteger с значением, равным неупрощённому значению этого BigDecimal. (Вычисляет (this * 10this.scale()).)

public BigDecimal round(MathContext mc)

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

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

public BigDecimal setScale(int newScale, RoundingMode roundingMode)

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

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

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

public BigDecimal setScale(int newScale)

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

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

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

public BigDecimal movePointLeft(int n)

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

public BigDecimal movePointRight(int n)

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

public BigDecimal scaleByPowerOfTen(int n)

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

public BigDecimal stripTrailingZeros()

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

public int compareTo(BigDecimal val)

Числовое сравнение этого BigDecimal с указанным BigDecimal. Два объекта BigDecimal , равные по значению, но имеющие разные масштабы (например, 2,0 и 2,00), считаются равными этим методом. Такие значения находятся в одном и том же когорте. Этот метод предлагается вместо отдельных методов для каждого из шести булевых операторов сравнения (<, ==, >, >=, !=, <=). Предлагаемый идиома для выполнения этих сравнений: (x.compareTo(y) <op> 0), где <op> - один из шести операторов сравнения.

public boolean equals(Object x)

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

public BigDecimal min(BigDecimal val)

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

public BigDecimal max(BigDecimal val)

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

public int hashCode()

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

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"
 

Примечания:

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

public String toEngineeringString()

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

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

public String toPlainString()

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

public BigInteger toBigInteger()

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

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

public BigInteger toBigIntegerExact()

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

public long longValue()

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

public long longValueExact()

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

public int intValue()

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

public int intValueExact()

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

public short shortValueExact()

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

public byte byteValueExact()

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

public float floatValue()

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

public double doubleValue()

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

public BigDecimal ulp()

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