All Implemented Interfaces:

Serializable, Comparable<Decimal128>
```
public final class Decimal128
extends Number
implements Comparable<Decimal128>
```
A binary integer decimal representation of a 128-bit decimal value, supporting 34 decimal digits of significand and an exponent range of -6143 to +6144.

Since:

3.4

See Also:

BSON Decimal128 specification, binary integer decimal, decimal128 floating-point format, 754-2008 - IEEE Standard for Floating-Point Arithmetic, Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`static Decimal128`	`NaN`	A constant holding a Not-a-Number (NaN) value of type `Decimal128`.
`static Decimal128`	`NEGATIVE_INFINITY`	A constant holding the negative infinity of type `Decimal128`.
`static Decimal128`	`NEGATIVE_NaN`	A constant holding a negative Not-a-Number (-NaN) value of type `Decimal128`.
`static Decimal128`	`NEGATIVE_ZERO`	A constant holding a negative zero value of type `Decimal128`.
`static Decimal128`	`POSITIVE_INFINITY`	A constant holding the positive infinity of type `Decimal128`.
`static Decimal128`	`POSITIVE_ZERO`	A constant holding a postive zero value of type `Decimal128`.

Constructor Summary

Constructors
Constructor	Description
`Decimal128(long value)`	Constructs a Decimal128 value representing the given long.
`Decimal128(BigDecimal value)`	Constructs a Decimal128 value representing the given BigDecimal.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`BigDecimal`	`bigDecimalValue()`	Gets a BigDecimal that is equivalent to this Decimal128.
`int`	`compareTo(Decimal128 o)`
`double`	`doubleValue()`	Converts this `Decimal128` to a `double`.
`boolean`	`equals(Object o)`	Returns true if the encoded representation of this instance is the same as the encoded representation of `o`.
`float`	`floatValue()`	Converts this `Decimal128` to a `float`.
`static Decimal128`	`fromIEEE754BIDEncoding(long high, long low)`	Create an instance with the given high and low order bits representing this Decimal128 as an IEEE 754-2008 128-bit decimal floating point using the BID encoding scheme.
`long`	`getHigh()`	Gets the high-order 64 bits of the IEEE 754-2008 128-bit decimal floating point encoding for this Decimal128, using the BID encoding scheme.
`long`	`getLow()`	Gets the low-order 64 bits of the IEEE 754-2008 128-bit decimal floating point encoding for this Decimal128, using the BID encoding scheme.
`int`	`hashCode()`
`int`	`intValue()`	Converts this `Decimal128` to a `int`.
`boolean`	`isFinite()`	Returns true if this Decimal128 is finite.
`boolean`	`isInfinite()`	Returns true if this Decimal128 is infinite.
`boolean`	`isNaN()`	Returns true if this Decimal128 is Not-A-Number (NaN).
`boolean`	`isNegative()`	Returns true if this Decimal128 is negative.
`long`	`longValue()`	Converts this `Decimal128` to a `long`.
`static Decimal128`	`parse(String value)`	Returns a Decimal128 value representing the given String.
`String`	`toString()`	Returns the String representation of the Decimal128 value.

Methods inherited from class java.lang.Number
byteValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - POSITIVE_INFINITY
```
public static final Decimal128 POSITIVE_INFINITY
```
    A constant holding the positive infinity of type Decimal128. It is equal to the value return by Decimal128.valueOf("Infinity").
  - NEGATIVE_INFINITY
```
public static final Decimal128 NEGATIVE_INFINITY
```
    A constant holding the negative infinity of type Decimal128. It is equal to the value return by Decimal128.valueOf("-Infinity").
  - NEGATIVE_NaN
```
public static final Decimal128 NEGATIVE_NaN
```
    A constant holding a negative Not-a-Number (-NaN) value of type Decimal128. It is equal to the value return by Decimal128.valueOf("-NaN").
  - NaN
```
public static final Decimal128 NaN
```
    A constant holding a Not-a-Number (NaN) value of type Decimal128. It is equal to the value return by Decimal128.valueOf("NaN").
  - POSITIVE_ZERO
```
public static final Decimal128 POSITIVE_ZERO
```
    A constant holding a postive zero value of type Decimal128. It is equal to the value return by Decimal128.valueOf("0").
  - NEGATIVE_ZERO
```
public static final Decimal128 NEGATIVE_ZERO
```
    A constant holding a negative zero value of type Decimal128. It is equal to the value return by Decimal128.valueOf("-0").
- Constructor Detail
  - Decimal128
```
public Decimal128(long value)
```
    Constructs a Decimal128 value representing the given long.
    
    Parameters:
    
    value - the Decimal128 value represented as a long
  - Decimal128
```
public Decimal128(BigDecimal value)
```
    Constructs a Decimal128 value representing the given BigDecimal.
    
    Parameters:
    
    value - the Decimal128 value represented as a BigDecimal
    
    Throws:
    
    NumberFormatException - if the value is out of the Decimal128 range
- Method Detail
  - parse
```
public static Decimal128 parse(String value)
```
    Returns a Decimal128 value representing the given String.
    
    Parameters:
    
    value - the Decimal128 value represented as a String
    
    Returns:
    
    the Decimal128 value representing the given String
    
    Throws:
    
    NumberFormatException - if the value is out of the Decimal128 range
    
    See Also:
    
    From-String Specification
  - fromIEEE754BIDEncoding
```
public static Decimal128 fromIEEE754BIDEncoding(long high,
                                                long low)
```
    Create an instance with the given high and low order bits representing this Decimal128 as an IEEE 754-2008 128-bit decimal floating point using the BID encoding scheme.
    
    Parameters:
    
    high - the high-order 64 bits
    
    low - the low-order 64 bits
    
    Returns:
    
    the Decimal128 value representing the given high and low order bits
  - getHigh
```
public long getHigh()
```
    Gets the high-order 64 bits of the IEEE 754-2008 128-bit decimal floating point encoding for this Decimal128, using the BID encoding scheme.
    
    Returns:
    
    the high-order 64 bits of this Decimal128
  - getLow
```
public long getLow()
```
    Gets the low-order 64 bits of the IEEE 754-2008 128-bit decimal floating point encoding for this Decimal128, using the BID encoding scheme.
    
    Returns:
    
    the low-order 64 bits of this Decimal128
  - bigDecimalValue
```
public BigDecimal bigDecimalValue()
```
    Gets a BigDecimal that is equivalent to this Decimal128.
    
    Returns:
    
    a BigDecimal that is equivalent to this Decimal128
    
    Throws:
    
    ArithmeticException - if the Decimal128 value is NaN, Infinity, -Infinity, or -0, none of which can be represented as a BigDecimal
  - isNegative
```
public boolean isNegative()
```
    Returns true if this Decimal128 is negative.
    
    Returns:
    
    true if this Decimal128 is negative
  - isInfinite
```
public boolean isInfinite()
```
    Returns true if this Decimal128 is infinite.
    
    Returns:
    
    true if this Decimal128 is infinite
  - isFinite
```
public boolean isFinite()
```
    Returns true if this Decimal128 is finite.
    
    Returns:
    
    true if this Decimal128 is finite
  - isNaN
```
public boolean isNaN()
```
    Returns true if this Decimal128 is Not-A-Number (NaN).
    
    Returns:
    
    true if this Decimal128 is Not-A-Number
  - compareTo
```
public int compareTo(Decimal128 o)
```
    Specified by:
    
    compareTo in interface Comparable<Decimal128>
  - intValue
```
public int intValue()
```
    Converts this Decimal128 to a int. This conversion is analogous to the narrowing primitive conversion from double to int as defined in The Java™ Language Specification: any fractional part of this Decimal128 will be discarded, and if the resulting integral value is too big to fit in a int, only the low-order 32 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal128 value as well as return a result with the opposite sign. Note that #NEGATIVE_ZERO is converted to 0.
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    
    this Decimal128 converted to a int.
    
    Since:
    
    3.10
  - longValue
```
public long longValue()
```
    Converts this Decimal128 to a long. This conversion is analogous to the narrowing primitive conversion from double to long as defined in The Java™ Language Specification: any fractional part of this Decimal128 will be discarded, and if the resulting integral value is too big to fit in a long, only the low-order 64 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal128 value as well as return a result with the opposite sign. Note that #NEGATIVE_ZERO is converted to 0L.
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    
    this Decimal128 converted to a long.
    
    Since:
    
    3.10
  - floatValue
```
public float floatValue()
```
    Converts this Decimal128 to a float. This conversion is similar to the narrowing primitive conversion from double to float as defined in The Java™ Language Specification: if this Decimal128 has too great a magnitude to represent as a float, it will be converted to Float.NEGATIVE_INFINITY or Float.POSITIVE_INFINITY as appropriate. Note that even when the return value is finite, this conversion can lose information about the precision of the Decimal128 value. Note that #NEGATIVE_ZERO is converted to 0.0f.
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    
    this Decimal128 converted to a float.
    
    Since:
    
    3.10
  - doubleValue
```
public double doubleValue()
```
    Converts this Decimal128 to a double. This conversion is similar to the narrowing primitive conversion from double to float as defined in The Java™ Language Specification: if this Decimal128 has too great a magnitude to represent as a double, it will be converted to Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY as appropriate. Note that even when the return value is finite, this conversion can lose information about the precision of the Decimal128 value. Note that #NEGATIVE_ZERO is converted to 0.0d.
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    
    this Decimal128 converted to a double.
    
    Since:
    
    3.10
  - equals
```
public boolean equals(Object o)
```
    Returns true if the encoded representation of this instance is the same as the encoded representation of o.
    One consequence is that, whereas Double.NaN != Double.NaN, new Decimal128("NaN").equals(new Decimal128("NaN") returns true.
    
    Another consequence is that, as with BigDecimal, new Decimal128("1.0").equals(new Decimal128("1.00") returns false, because the precision is not the same and therefore the representation is not the same.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - the object to compare for equality
    
    Returns:
    
    true if the instances are equal
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Returns the String representation of the Decimal128 value.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the String representation
    
    See Also:
    
    To-String Sprecification

Class Decimal128

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Field Detail

POSITIVE_INFINITY

NEGATIVE_INFINITY

NEGATIVE_NaN

NaN

POSITIVE_ZERO

NEGATIVE_ZERO

Constructor Detail

Decimal128

Decimal128

Method Detail

parse

fromIEEE754BIDEncoding

getHigh

getLow

bigDecimalValue

isNegative

isInfinite

isFinite

isNaN

compareTo

intValue

longValue

floatValue

doubleValue

equals

hashCode

toString