Package org.apache.commons.lang3.mutable

# Class MutableFloat

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

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

public class MutableFloat extends Number implements Comparable<MutableFloat>, Mutable<Number>
A mutable `float` wrapper.

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

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

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

- ## Constructor Summary

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

- ## Method Summary

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

  ### Methods inherited from class java.lang.Number

  `byteValue, shortValue`

  ### Methods inherited from class java.lang.Object

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

  ### Methods inherited from interface org.apache.commons.lang3.mutable.Mutable

  `get`

- ## Constructor Details

  - ### MutableFloat

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

  - ### MutableFloat

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

  - ### MutableFloat

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

  - ### MutableFloat

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

- ## Method Details

  - ### add

    public void add(float operand)
    Adds a value to the value of this instance.
    Parameters:
      `operand` - the value to add, not null.
    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 float addAndGet(float 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 float 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(MutableFloat other)
    Compares this mutable to another in ascending order.
    Specified by:
      `compareTo` in interface `Comparable<MutableFloat>`
    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 float 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 MutableFloat 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 some other object. The result is `true` if and only if the argument is not `null` and is a `Float` object that represents a `float` that has the identical bit pattern to the bit pattern of the `float` represented by this object. For this purpose, two float values are considered to be the same if and only if the method `Float.floatToIntBits(float)`returns the same int value when applied to each.

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

         f1.floatValue() == f2.floatValue()

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

    - If `f1` and `f2` both represent `Float.NaN`, then the `equals` method returns `true`, even though `Float.NaN == Float.NaN` has the value `false`.
    - If `f1` represents `+0.0f` while `f2` represents `-0.0f`, or vice versa, the `equal` test has the value `false`, even though `0.0f == -0.0f` has the value `true`.

    This definition 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.
    See Also:
      - `Float.floatToIntBits(float)`

  - ### floatValue

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

  - ### getAndAdd

    public float getAndAdd(float 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 float 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 float 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 float 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 Float getValue()
    Deprecated.
    Use `Mutable.get()`.
    Gets the value as a Float instance.
    Specified by:
      `getValue` in interface `Mutable<Number>`
    Returns:
      the value as a Float, 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 float 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 MutableFloat 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 float value is infinite.
    Returns:
      true if infinite

  - ### isNaN

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

  - ### longValue

    public long longValue()
    Returns the value of this MutableFloat 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(float 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(float operand)
    Subtracts a value from the value of this instance.
    Parameters:
      `operand` - the value to subtract.
    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

  - ### toFloat

    public Float toFloat()
    Gets this mutable as an instance of Float.
    Returns:
      a Float 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.