Most visited

Recently visited

Results for

Added in API level 24

BigDecimal

public class BigDecimal
extends Number implements Serializable, Comparable<BigDecimal>

java.lang.Object
↳	java.lang.Number
	↳	android.icu.math.BigDecimal

The BigDecimal class implements immutable arbitrary-precision decimal numbers. The methods of the BigDecimal class provide operations for fixed and floating point arithmetic, comparison, format conversions, and hashing.

As the numbers are decimal, there is an exact correspondence between an instance of a BigDecimal object and its String representation; the BigDecimal class provides direct conversions to and from String and character array (char[]) objects, as well as conversions to and from the Java primitive types (which may not be exact) and BigInteger.

In the descriptions of constructors and methods in this documentation, the value of a BigDecimal number object is shown as the result of invoking the toString() method on the object. The internal representation of a decimal number is neither defined nor exposed, and is not permitted to affect the result of any operation.

The floating point arithmetic provided by this class is defined by the ANSI X3.274-1996 standard, and is also documented at http://www2.hursley.ibm.com/decimal
[This URL will change.]

Operator methods

Operations on BigDecimal numbers are controlled by a MathContext object, which provides the context (precision and other information) for the operation. Methods that can take a MathContext parameter implement the standard arithmetic operators for BigDecimal objects and are known as operator methods. The default settings provided by the constant DEFAULT (digits=9, form=SCIENTIFIC, lostDigits=false, roundingMode=ROUND_HALF_UP) perform general-purpose floating point arithmetic to nine digits of precision. The MathContext parameter must not be null.

Each operator method also has a version provided which does not take a MathContext parameter. For this version of each method, the context settings used are digits=0, form=PLAIN, lostDigits=false, roundingMode=ROUND_HALF_UP; these settings perform fixed point arithmetic with unlimited precision, as defined for the original BigDecimal class in Java 1.1 and Java 1.2.

For monadic operators, only the optional MathContext parameter is present; the operation acts upon the current object.

For dyadic operators, a BigDecimal parameter is always present; it must not be null. The operation acts with the current object being the left-hand operand and the BigDecimal parameter being the right-hand operand.

For example, adding two BigDecimal objects referred to by the names award and extra could be written as any of:

award.add(extra) award.add(extra, MathContext.DEFAULT) award.add(extra, acontext)

(where acontext is a MathContext object), which would return a BigDecimal object whose value is the result of adding award and extra under the appropriate context settings.

When a BigDecimal operator method is used, a set of rules define what the result will be (and, by implication, how the result would be represented as a character string). These rules are defined in the BigDecimal arithmetic documentation (see the URL above), but in summary:

Results are normally calculated with up to some maximum number of significant digits. For example, if the MathContext parameter for an operation were MathContext.DEFAULT then the result would be rounded to 9 digits; the division of 2 by 3 would then result in 0.666666667.
You can change the default of 9 significant digits by providing the method with a suitable MathContext object. This lets you calculate using as many digits as you need -- thousands, if necessary. Fixed point (scaled) arithmetic is indicated by using a digits setting of 0 (or omitting the MathContext parameter).
Similarly, you can change the algorithm used for rounding from the default "classic" algorithm.
In standard arithmetic (that is, when the form setting is not PLAIN), a zero result is always expressed as the single digit '0' (that is, with no sign, decimal point, or exponent part).
Except for the division and power operators in standard arithmetic, trailing zeros are preserved (this is in contrast to binary floating point operations and most electronic calculators, which lose the information about trailing zeros in the fractional part of results).
So, for example:
new BigDecimal("2.40").add( new BigDecimal("2")) => "4.40" new BigDecimal("2.40").subtract(new BigDecimal("2")) => "0.40" new BigDecimal("2.40").multiply(new BigDecimal("2")) => "4.80" new BigDecimal("2.40").divide( new BigDecimal("2"), def) => "1.2"
where the value on the right of the => would be the result of the operation, expressed as a String, and def (in this and following examples) refers to MathContext.DEFAULT ). This preservation of trailing zeros is desirable for most calculations (including financial calculations). If necessary, trailing zeros may be easily removed using division by 1.
In standard arithmetic, exponential form is used for a result depending on its value and the current setting of digits (the default is 9 digits). If the number of places needed before the decimal point exceeds the digits setting, or the absolute value of the number is less than 0.000001, then the number will be expressed in exponential notation; thus
new BigDecimal("1e+6").multiply(new BigDecimal("1e+6"), def)
results in 1E+12 instead of 1000000000000, and
new BigDecimal("1").divide(new BigDecimal("3E+10"), def)
results in 3.33333333E-11 instead of 0.0000000000333333333.
The form of the exponential notation (scientific or engineering) is determined by the form setting.

The names of methods in this class follow the conventions established by java.lang.Number, java.math.BigInteger, and java.math.BigDecimal in Java 1.1 and Java 1.2.

See also:

MathContext

Summary

Constants
`int`	`ROUND_CEILING` Rounding mode to round to a more positive number.
`int`	`ROUND_DOWN` Rounding mode to round towards zero.
`int`	`ROUND_FLOOR` Rounding mode to round to a more negative number.
`int`	`ROUND_HALF_DOWN` Rounding mode to round to nearest neighbor, where an equidistant value is rounded down.
`int`	`ROUND_HALF_EVEN` Rounding mode to round to nearest neighbor, where an equidistant value is rounded to the nearest even neighbor.
`int`	`ROUND_HALF_UP` Rounding mode to round to nearest neighbor, where an equidistant value is rounded up.
`int`	`ROUND_UNNECESSARY` Rounding mode to assert that no rounding is necessary.
`int`	`ROUND_UP` Rounding mode to round away from zero.

Fields
`public static final BigDecimal`	`ONE` The `BigDecimal` constant "1".
`public static final BigDecimal`	`TEN` The `BigDecimal` constant "10".
`public static final BigDecimal`	`ZERO` The `BigDecimal` constant "0".

Public constructors
`BigDecimal(BigDecimal bd)` Constructs a `BigDecimal` object from a `java.math.BigDecimal`.
`BigDecimal(BigInteger bi)` Constructs a `BigDecimal` object from a `BigInteger`, with scale 0.
`BigDecimal(BigInteger bi, int scale)` Constructs a `BigDecimal` object from a `BigInteger` and a scale.
`BigDecimal(char[] inchars)` Constructs a `BigDecimal` object from an array of characters.
`BigDecimal(char[] inchars, int offset, int length)` Constructs a `BigDecimal` object from an array of characters.
`BigDecimal(double num)` Constructs a `BigDecimal` object directly from a `double`.
`BigDecimal(int num)` Constructs a `BigDecimal` object directly from a `int`.
`BigDecimal(long num)` Constructs a `BigDecimal` object directly from a `long`.
`BigDecimal(String string)` Constructs a `BigDecimal` object from a `String`.

Public methods
`BigDecimal`	`abs(MathContext set)` Returns a `BigDecimal` whose value is the absolute value of this `BigDecimal`.
`BigDecimal`	`abs()` Returns a plain `BigDecimal` whose value is the absolute value of this `BigDecimal`.
`BigDecimal`	`add(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is `this+rhs`, using fixed point arithmetic.
`BigDecimal`	`add(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is `this+rhs`.
`byte`	`byteValueExact()` Converts this `BigDecimal` to a `byte`.
`int`	`compareTo(BigDecimal rhs)` Compares this `BigDecimal` to another, using unlimited precision.
`int`	`compareTo(BigDecimal rhs, MathContext set)` Compares this `BigDecimal` to another.
`BigDecimal`	`divide(BigDecimal rhs, int round)` Returns a plain `BigDecimal` whose value is `this/rhs`, using fixed point arithmetic and a rounding mode.
`BigDecimal`	`divide(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is `this/rhs`.
`BigDecimal`	`divide(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is `this/rhs`, using fixed point arithmetic.
`BigDecimal`	`divide(BigDecimal rhs, int scale, int round)` Returns a plain `BigDecimal` whose value is `this/rhs`, using fixed point arithmetic and a given scale and rounding mode.
`BigDecimal`	`divideInteger(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is the integer part of `this/rhs`.
`BigDecimal`	`divideInteger(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is the integer part of `this/rhs`.
`double`	`doubleValue()` Converts this `BigDecimal` to a `double`.
`boolean`	`equals(Object obj)` Compares this `BigDecimal` with `rhs` for equality.
`float`	`floatValue()` Converts this `BigDecimal` to a `float`.
`String`	`format(int before, int after)` Returns the `String` representation of this `BigDecimal`, modified by layout parameters.
`String`	`format(int before, int after, int explaces, int exdigits, int exformint, int exround)` Returns the `String` representation of this `BigDecimal`, modified by layout parameters and allowing exponential notation.
`int`	`hashCode()` Returns the hashcode for this `BigDecimal`.
`int`	`intValue()` Converts this `BigDecimal` to an `int`.
`int`	`intValueExact()` Converts this `BigDecimal` to an `int`.
`long`	`longValue()` Converts this `BigDecimal` to a `long`.
`long`	`longValueExact()` Converts this `BigDecimal` to a `long`.
`BigDecimal`	`max(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is the maximum of `this` and `rhs`.
`BigDecimal`	`max(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is the maximum of `this` and `rhs`.
`BigDecimal`	`min(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is the minimum of `this` and `rhs`.
`BigDecimal`	`min(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is the minimum of `this` and `rhs`.
`BigDecimal`	`movePointLeft(int n)` Returns a plain `BigDecimal` whose decimal point has been moved to the left by a specified number of positions.
`BigDecimal`	`movePointRight(int n)` Returns a plain `BigDecimal` whose decimal point has been moved to the right by a specified number of positions.
`BigDecimal`	`multiply(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is `this*rhs`, using fixed point arithmetic.
`BigDecimal`	`multiply(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is `this*rhs`.
`BigDecimal`	`negate()` Returns a plain `BigDecimal` whose value is `-this`.
`BigDecimal`	`negate(MathContext set)` Returns a `BigDecimal` whose value is `-this`.
`BigDecimal`	`plus(MathContext set)` Returns a `BigDecimal` whose value is `+this`.
`BigDecimal`	`plus()` Returns a plain `BigDecimal` whose value is `+this`.
`BigDecimal`	`pow(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is `this**rhs`.
`BigDecimal`	`pow(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is `this**rhs`, using fixed point arithmetic.
`BigDecimal`	`remainder(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is the remainder of `this/rhs`, using fixed point arithmetic.
`BigDecimal`	`remainder(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is the remainder of `this/rhs`.
`int`	`scale()` Returns the scale of this `BigDecimal`.
`BigDecimal`	`setScale(int scale, int round)` Returns a plain `BigDecimal` with a given scale.
`BigDecimal`	`setScale(int scale)` Returns a plain `BigDecimal` with a given scale.
`short`	`shortValueExact()` Converts this `BigDecimal` to a `short`.
`int`	`signum()` Returns the sign of this `BigDecimal`, as an `int`.
`BigDecimal`	`subtract(BigDecimal rhs, MathContext set)` Returns a `BigDecimal` whose value is `this-rhs`.
`BigDecimal`	`subtract(BigDecimal rhs)` Returns a plain `BigDecimal` whose value is `this-rhs`, using fixed point arithmetic.
`BigDecimal`	`toBigDecimal()` Converts this `BigDecimal` to a `java.math.BigDecimal`.
`BigInteger`	`toBigInteger()` Converts this `BigDecimal` to a `java.math.BigInteger`.
`BigInteger`	`toBigIntegerExact()` Converts this `BigDecimal` to a `java.math.BigInteger`.
`char[]`	`toCharArray()` Returns the `BigDecimal` as a character array.
`String`	`toString()` Returns the `BigDecimal` as a `String`.
`BigInteger`	`unscaledValue()` Returns the number as a `BigInteger` after removing the scale.
`static BigDecimal`	`valueOf(double dub)` Translates a `double` to a `BigDecimal`.
`static BigDecimal`	`valueOf(long lint)` Translates a `long` to a `BigDecimal`.
`static BigDecimal`	`valueOf(long lint, int scale)` Translates a `long` to a `BigDecimal` with a given scale.

Inherited methods

From class


  
    java.lang.Number

From class


  
    java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long millis, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void`	`wait(long millis)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void`	`wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.

From interface


  
    java.lang.Comparable

Constants

ROUND_CEILING

Added in API level 24

int ROUND_CEILING

Rounding mode to round to a more positive number.

See also:

ROUND_CEILING

Constant Value: 2 (0x00000002)

ROUND_DOWN

Added in API level 24

int ROUND_DOWN

Rounding mode to round towards zero.

See also:

ROUND_DOWN

Constant Value: 1 (0x00000001)

ROUND_FLOOR

Added in API level 24

int ROUND_FLOOR

Rounding mode to round to a more negative number.

See also:

ROUND_FLOOR

Constant Value: 3 (0x00000003)

ROUND_HALF_DOWN

Added in API level 24

int ROUND_HALF_DOWN

Rounding mode to round to nearest neighbor, where an equidistant value is rounded down.

See also:

ROUND_HALF_DOWN

Constant Value: 5 (0x00000005)

ROUND_HALF_EVEN

Added in API level 24

int ROUND_HALF_EVEN

Rounding mode to round to nearest neighbor, where an equidistant value is rounded to the nearest even neighbor.

See also:

ROUND_HALF_EVEN

Constant Value: 6 (0x00000006)

ROUND_HALF_UP

Added in API level 24

int ROUND_HALF_UP

Rounding mode to round to nearest neighbor, where an equidistant value is rounded up.

See also:

ROUND_HALF_UP

Constant Value: 4 (0x00000004)

ROUND_UNNECESSARY

Added in API level 24

int ROUND_UNNECESSARY

Rounding mode to assert that no rounding is necessary.

See also:

ROUND_UNNECESSARY

Constant Value: 7 (0x00000007)

ROUND_UP

Added in API level 24

int ROUND_UP

Rounding mode to round away from zero.

See also:

ROUND_UP

Constant Value: 0 (0x00000000)

Fields

ONE

Added in API level 24

BigDecimal ONE

The BigDecimal constant "1".

See also:

TEN
ZERO

TEN

Added in API level 24

BigDecimal TEN

The BigDecimal constant "10".

See also:

ONE
ZERO

ZERO

Added in API level 24

BigDecimal ZERO

The BigDecimal constant "0".

See also:

Parameters
`bi`	`BigInteger`: The `BigInteger` to be converted.
`scale`	`int`: The `int` specifying the scale.

Parameters
`inchars`	`char`: The `char[]` array containing the number to be converted.
`offset`	`int`: The `int` offset into the array of the start of the number to be converted.
`length`	`int`: The `int` length of the number.

Parameters
`rhs`	`BigDecimal`: The `BigDecimal` for the right hand side of the addition.
`set`	`MathContext`: The `MathContext` arithmetic settings.

-1	if the current object is less than the first parameter
0	if the current object is equal to the first parameter
1	if the current object is greater than the first parameter.

Parameters
`rhs`	`BigDecimal`: The `BigDecimal` for the right hand side of the division.
`round`	`int`: The `int` rounding mode to be used for the division (see the `MathContext` class).

Throws
`IllegalArgumentException`	if `round` is not a valid rounding mode.
`ArithmeticException`	if `rhs` is zero.
`ArithmeticException`	if `round` is `ROUND_UNNECESSARY` and `this.scale()` is insufficient to represent the result exactly.

Parameters
`before`	`int`: The `int` specifying the number of places before the decimal point. Use -1 for 'as many as are needed'.
`after`	`int`: The `int` specifying the number of places after the decimal point. Use -1 for 'as many as are needed'.

Throws
`ArithmeticException`	if the number cannot be laid out as requested.
`IllegalArgumentException`	if a parameter is out of range.

Parameters
`scale`	`int`: The `int` specifying the scale of the resulting `BigDecimal`.
`round`	`int`: The `int` rounding mode to be used for the division (see the `MathContext` class).

Throws
`ArithmeticException`	if `scale` is negative.
`ArithmeticException`	if reducing scale would discard non-zero digits.

Parameters
`lint`	`long`: The `long` to be translated.
`scale`	`int`: The `int` scale to be applied.

Most visited

Recently visited

Results for

BigDecimal

Operator methods

Summary

Constants

Fields

Public constructors

Public methods

Inherited methods

Constants

ROUND_CEILING

ROUND_DOWN

ROUND_FLOOR

ROUND_HALF_DOWN

ROUND_HALF_EVEN

ROUND_HALF_UP

ROUND_UNNECESSARY

ROUND_UP

Fields

ONE

TEN

ZERO

Public constructors

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

Public methods

abs

abs

add

add

byteValueExact

compareTo

compareTo

divide

divide

divide

divide

divideInteger

divideInteger

doubleValue

equals

floatValue

format

format

hashCode

intValue

intValueExact

longValue

longValueExact

max

max

min

min

movePointLeft

movePointRight

multiply

multiply

negate

negate

plus

plus

pow

pow

remainder

remainder

scale

setScale

setScale

shortValueExact

signum

subtract