# Class MutableDouble

java.lang.Object
java.lang.Number
org.apache.commons.lang3.mutable.MutableDouble

All Implemented Interfaces:
  `Serializable, Comparable<MutableDouble>, Supplier<Number>, Mutable<Number>`

public class MutableDouble extends Number implements Comparable<MutableDouble>, Mutable<Number>
A mutable `double` wrapper.

This class was created before the introduction of the the `java.util.concurrent.atomic` package and the `DoubleAccumulator` class.

Note that as MutableDouble does not extend Double, it is not treated by String.format as a Double parameter.

Since:
  2.1
See Also:
  - `Double`
  - `DoubleAccumulator`
  - `DoubleAdder`
  - Serialized Form

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `MutableDouble()`
  Constructs a new MutableDouble with the default value of zero.
  `MutableDouble(double value)`
  Constructs a new MutableDouble with the specified value.
  `MutableDouble(Number value)`
  Constructs a new MutableDouble with the specified value.
  `MutableDouble(String value)`
  Constructs a new MutableDouble parsing the given string.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(double operand)`
  Adds a value to the value of this instance.
  `void`
  `add(Number operand)`
  Adds a value to the value of this instance.
  `double`
  `addAndGet(double operand)`
  Increments this instance's value by `operand`; this method returns the value associated with the instance immediately after the addition operation.
  `double`
  `addAndGet(Number operand)`
  Increments this instance's value by `operand`; this method returns the value associated with the instance immediately after the addition operation.
  `int`
  `compareTo(MutableDouble other)`
  Compares this mutable to another in ascending order.
  `void`
  `decrement()`
  Decrements the value.
  `double`
  `decrementAndGet()`
  Decrements this instance's value by 1; this method returns the value associated with the instance immediately after the decrement operation.
  `double`
  `doubleValue()`
  Returns the value of this MutableDouble as a double.
  `boolean`
  `equals(Object obj)`
  Compares this object against the specified object.
  `float`
  `floatValue()`
  Returns the value of this MutableDouble as a float.
  `double`
  `getAndAdd(double operand)`
  Increments this instance's value by `operand`; this method returns the value associated with the instance immediately prior to the addition operation.
  `double`
  `getAndAdd(Number operand)`
  Increments this instance's value by `operand`; this method returns the value associated with the instance immediately prior to the addition operation.
  `double`
  `getAndDecrement()`
  Decrements this instance's value by 1; this method returns the value associated with the instance immediately prior to the decrement operation.
  `double`
  `getAndIncrement()`
  Increments this instance's value by 1; this method returns the value associated with the instance immediately prior to the increment operation.
  `Double`
  `getValue()`
  Deprecated.
  Use `Mutable.get()`.
  `int`
  `hashCode()`
  Returns a suitable hash code for this mutable.
  `void`
  `increment()`
  Increments the value.
  `double`
  `incrementAndGet()`
  Increments this instance's value by 1; this method returns the value associated with the instance immediately after the increment operation.
  `int`
  `intValue()`
  Returns the value of this MutableDouble as an int.
  `boolean`
  `isInfinite()`
  Checks whether the double value is infinite.
  `boolean`
  `isNaN()`
  Checks whether the double value is the special NaN value.
  `long`
  `longValue()`
  Returns the value of this MutableDouble as a long.
  `void`
  `setValue(double value)`
  Sets the value.
  `void`
  `setValue(Number value)`
  Sets the value from any Number instance.
  `void`
  `subtract(double operand)`
  Subtracts a value from the value of this instance.
  `void`
  `subtract(Number operand)`
  Subtracts a value from the value of this instance.
  `Double`
  `toDouble()`
  Gets this mutable as an instance of Double.
  `String`
  `toString()`
  Returns the String value of this mutable.

  ### Methods inherited from class Number

  `byteValue, shortValue`

  ### Methods inherited from class Object

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

  ### Methods inherited from interface Mutable

  `get`

- ## Constructor Details

  - ### MutableDouble

    public MutableDouble()
    Constructs a new MutableDouble with the default value of zero.

  - ### MutableDouble

    public MutableDouble(double value)
    Constructs a new MutableDouble with the specified value.
    Parameters:
      `value` - the initial value to store.

  - ### MutableDouble

    public MutableDouble(Number value)
    Constructs a new MutableDouble with the specified value.
    Parameters:
      `value` - the initial value to store, not null.
    Throws:
      `NullPointerException` - if the object is null.

  - ### MutableDouble

    public MutableDouble(String value)
    Constructs a new MutableDouble parsing the given string.
    Parameters:
      `value` - the string to parse, not null.
    Throws:
      `NumberFormatException` - if the string cannot be parsed into a double, see `Double.parseDouble(String)`.
    Since:
      2.5

- ## Method Details

  - ### add

    public void add(double operand)
    Adds a value to the value of this instance.
    Parameters:
      `operand` - the value to add.
    Since:
      2.2

  - ### add

    public void add(Number operand)
    Adds a value to the value of this instance.
    Parameters:
      `operand` - the value to add, not null.
    Throws:
      `NullPointerException` - if the object is null.
    Since:
      2.2

  - ### addAndGet

    public double addAndGet(double operand)
    Increments this instance's value by `operand`; this method returns the value associated with the instance immediately after the addition operation. This method is not thread safe.
    Parameters:
      `operand` - the quantity to add, not null.
    Returns:
      the value associated with this instance after adding the operand.
    Since:
      3.5

  - ### addAndGet

    public double addAndGet(Number operand)
    Increments this instance's value by `operand`; this method returns the value associated with the instance immediately after the addition operation. This method is not thread safe.
    Parameters:
      `operand` - the quantity to add, not null.
    Returns:
      the value associated with this instance after adding the operand.
    Throws:
      `NullPointerException` - if `operand` is null.
    Since:
      3.5

  - ### compareTo

    public int compareTo(MutableDouble other)
    Compares this mutable to another in ascending order.
    Specified by:
      `compareTo` in interface `Comparable<MutableDouble>`
    Parameters:
      `other` - the other mutable to compare to, not null.
    Returns:
      negative if this is less, zero if equal, positive if greater.

  - ### decrement

    public void decrement()
    Decrements the value.
    Since:
      2.2

  - ### decrementAndGet

    public double decrementAndGet()
    Decrements this instance's value by 1; this method returns the value associated with the instance immediately after the decrement operation. This method is not thread safe.
    Returns:
      the value associated with the instance after it is decremented.
    Since:
      3.5

  - ### doubleValue

    public double doubleValue()
    Returns the value of this MutableDouble as a double.
    Specified by:
      `doubleValue` in class `Number`
    Returns:
      the numeric value represented by this object after conversion to type double.

  - ### equals

    public boolean equals(Object obj)
    Compares this object against the specified object. The result is `true` if and only if the argument is not `null` and is a `Double` object that represents a double that has the identical bit pattern to the bit pattern of the double represented by this object. For this purpose, two `double` values are considered to be the same if and only if the method `Double.doubleToLongBits(double)`returns the same long value when applied to each.

    Note that in most cases, for two instances of class `Double`,`d1` and `d2`, the value of `d1.equals(d2)` is `true` if and only if:

        d1.doubleValue() == d2.doubleValue()

    also has the value `true`. However, there are two exceptions:

    - If `d1` and `d2` both represent `Double.NaN`, then the `equals` method returns `true`, even though `Double.NaN == Double.NaN` has the value `false`.
    - If `d1` represents `+0.0` while `d2` represents `-0.0`, or vice versa, the `equal` test has the value `false`, even though `+0.0 == -0.0` has the value `true`. This allows hashtables to operate properly.
    Overrides:
      `equals` in class `Object`
    Parameters:
      `obj` - the object to compare with, null returns false.
    Returns:
      `true` if the objects are the same; `false` otherwise.

  - ### floatValue

    public float floatValue()
    Returns the value of this MutableDouble as a float.
    Specified by:
      `floatValue` in class `Number`
    Returns:
      the numeric value represented by this object after conversion to type float.

  - ### getAndAdd

    public double getAndAdd(double operand)
    Increments this instance's value by `operand`; this method returns the value associated with the instance immediately prior to the addition operation. This method is not thread safe.
    Parameters:
      `operand` - the quantity to add, not null.
    Returns:
      the value associated with this instance immediately before the operand was added.
    Since:
      3.5

  - ### getAndAdd

    public double getAndAdd(Number operand)
    Increments this instance's value by `operand`; this method returns the value associated with the instance immediately prior to the addition operation. This method is not thread safe.
    Parameters:
      `operand` - the quantity to add, not null.
    Returns:
      the value associated with this instance immediately before the operand was added.
    Throws:
      `NullPointerException` - if `operand` is null.
    Since:
      3.5

  - ### getAndDecrement

    public double getAndDecrement()
    Decrements this instance's value by 1; this method returns the value associated with the instance immediately prior to the decrement operation. This method is not thread safe.
    Returns:
      the value associated with the instance before it was decremented.
    Since:
      3.5

  - ### getAndIncrement

    public double getAndIncrement()
    Increments this instance's value by 1; this method returns the value associated with the instance immediately prior to the increment operation. This method is not thread safe.
    Returns:
      the value associated with the instance before it was incremented.
    Since:
      3.5

  - ### getValue

    @Deprecated public Double getValue()
    Deprecated.
    Use `Mutable.get()`.
    Gets the value as a Double instance.
    Specified by:
      `getValue` in interface `Mutable<Number>`
    Returns:
      the value as a Double, never null.

  - ### hashCode

    public int hashCode()
    Returns a suitable hash code for this mutable.
    Overrides:
      `hashCode` in class `Object`
    Returns:
      a suitable hash code.

  - ### increment

    public void increment()
    Increments the value.
    Since:
      2.2

  - ### incrementAndGet

    public double incrementAndGet()
    Increments this instance's value by 1; this method returns the value associated with the instance immediately after the increment operation. This method is not thread safe.
    Returns:
      the value associated with the instance after it is incremented.
    Since:
      3.5

  - ### intValue

    public int intValue()
    Returns the value of this MutableDouble as an int.
    Specified by:
      `intValue` in class `Number`
    Returns:
      the numeric value represented by this object after conversion to type int.

  - ### isInfinite

    public boolean isInfinite()
    Checks whether the double value is infinite.
    Returns:
      true if infinite.

  - ### isNaN

    public boolean isNaN()
    Checks whether the double value is the special NaN value.
    Returns:
      true if NaN.

  - ### longValue

    public long longValue()
    Returns the value of this MutableDouble as a long.
    Specified by:
      `longValue` in class `Number`
    Returns:
      the numeric value represented by this object after conversion to type long.

  - ### setValue

    public void setValue(double value)
    Sets the value.
    Parameters:
      `value` - the value to set.

  - ### setValue

    public void setValue(Number value)
    Sets the value from any Number instance.
    Specified by:
      `setValue` in interface `Mutable<Number>`
    Parameters:
      `value` - the value to set, not null.
    Throws:
      `NullPointerException` - if the object is null.

  - ### subtract

    public void subtract(double operand)
    Subtracts a value from the value of this instance.
    Parameters:
      `operand` - the value to subtract, not null.
    Since:
      2.2

  - ### subtract

    public void subtract(Number operand)
    Subtracts a value from the value of this instance.
    Parameters:
      `operand` - the value to subtract, not null.
    Throws:
      `NullPointerException` - if the object is null.
    Since:
      2.2

  - ### toDouble

    public Double toDouble()
    Gets this mutable as an instance of Double.
    Returns:
      a Double instance containing the value from this mutable, never null.

  - ### toString

    public String toString()
    Returns the String value of this mutable.
    Overrides:
      `toString` in class `Object`
    Returns:
      the mutable value as a string.