NumberUtils (Apache Commons Lang 3.4 API)

java.lang.Object
- org.apache.commons.lang3.math.NumberUtils

```
public class NumberUtils
extends Object
```
Provides extra functionality for Java Number classes.

Since:

2.0

Version:

$Id: NumberUtils.java 1663129 2015-03-01 16:48:22Z britter $

Field Summary

Fields
Modifier and Type	Field and Description
`static Byte`	`BYTE_MINUS_ONE` Reusable Byte constant for minus one.
`static Byte`	`BYTE_ONE` Reusable Byte constant for one.
`static Byte`	`BYTE_ZERO` Reusable Byte constant for zero.
`static Double`	`DOUBLE_MINUS_ONE` Reusable Double constant for minus one.
`static Double`	`DOUBLE_ONE` Reusable Double constant for one.
`static Double`	`DOUBLE_ZERO` Reusable Double constant for zero.
`static Float`	`FLOAT_MINUS_ONE` Reusable Float constant for minus one.
`static Float`	`FLOAT_ONE` Reusable Float constant for one.
`static Float`	`FLOAT_ZERO` Reusable Float constant for zero.
`static Integer`	`INTEGER_MINUS_ONE` Reusable Integer constant for minus one.
`static Integer`	`INTEGER_ONE` Reusable Integer constant for one.
`static Integer`	`INTEGER_ZERO` Reusable Integer constant for zero.
`static Long`	`LONG_MINUS_ONE` Reusable Long constant for minus one.
`static Long`	`LONG_ONE` Reusable Long constant for one.
`static Long`	`LONG_ZERO` Reusable Long constant for zero.
`static Short`	`SHORT_MINUS_ONE` Reusable Short constant for minus one.
`static Short`	`SHORT_ONE` Reusable Short constant for one.
`static Short`	`SHORT_ZERO` Reusable Short constant for zero.

Constructor Summary

Constructors
Constructor and Description

NumberUtils()
NumberUtils instances should NOT be constructed in standard programming.

Constructors
Constructor and Description
`NumberUtils()` `NumberUtils` instances should NOT be constructed in standard programming.

Method Summary

Methods
Modifier and Type	Method and Description
`static int`	`compare(byte x, byte y)` Compares two `byte` values numerically.
`static int`	`compare(int x, int y)` Compares two `int` values numerically.
`static int`	`compare(long x, long y)` Compares to `long` values numerically.
`static int`	`compare(short x, short y)` Compares to `short` values numerically.
`static BigDecimal`	`createBigDecimal(String str)` Convert a `String` to a `BigDecimal`.
`static BigInteger`	`createBigInteger(String str)` Convert a `String` to a `BigInteger`; since 3.2 it handles hex (0x or #) and octal (0) notations.
`static Double`	`createDouble(String str)` Convert a `String` to a `Double`.
`static Float`	`createFloat(String str)` Convert a `String` to a `Float`.
`static Integer`	`createInteger(String str)` Convert a `String` to a `Integer`, handling hex (0xhhhh) and octal (0dddd) notations.
`static Long`	`createLong(String str)` Convert a `String` to a `Long`; since 3.1 it handles hex (0Xhhhh) and octal (0ddd) notations.
`static Number`	`createNumber(String str)` Turns a string value into a java.lang.Number.
`static boolean`	`isDigits(String str)` Checks whether the `String` contains only digit characters.
`static boolean`	`isNumber(String str)` Checks whether the String a valid Java number.
`static boolean`	`isParsable(String str)` Checks whether the given String is a parsable number.
`static byte`	`max(byte... array)` Returns the maximum value in an array.
`static byte`	`max(byte a, byte b, byte c)` Gets the maximum of three `byte` values.
`static double`	`max(double... array)` Returns the maximum value in an array.
`static double`	`max(double a, double b, double c)` Gets the maximum of three `double` values.
`static float`	`max(float... array)` Returns the maximum value in an array.
`static float`	`max(float a, float b, float c)` Gets the maximum of three `float` values.
`static int`	`max(int... array)` Returns the maximum value in an array.
`static int`	`max(int a, int b, int c)` Gets the maximum of three `int` values.
`static long`	`max(long... array)` Returns the maximum value in an array.
`static long`	`max(long a, long b, long c)` Gets the maximum of three `long` values.
`static short`	`max(short... array)` Returns the maximum value in an array.
`static short`	`max(short a, short b, short c)` Gets the maximum of three `short` values.
`static byte`	`min(byte... array)` Returns the minimum value in an array.
`static byte`	`min(byte a, byte b, byte c)` Gets the minimum of three `byte` values.
`static double`	`min(double... array)` Returns the minimum value in an array.
`static double`	`min(double a, double b, double c)` Gets the minimum of three `double` values.
`static float`	`min(float... array)` Returns the minimum value in an array.
`static float`	`min(float a, float b, float c)` Gets the minimum of three `float` values.
`static int`	`min(int... array)` Returns the minimum value in an array.
`static int`	`min(int a, int b, int c)` Gets the minimum of three `int` values.
`static long`	`min(long... array)` Returns the minimum value in an array.
`static long`	`min(long a, long b, long c)` Gets the minimum of three `long` values.
`static short`	`min(short... array)` Returns the minimum value in an array.
`static short`	`min(short a, short b, short c)` Gets the minimum of three `short` values.
`static byte`	`toByte(String str)` Convert a `String` to a `byte`, returning `zero` if the conversion fails.
`static byte`	`toByte(String str, byte defaultValue)` Convert a `String` to a `byte`, returning a default value if the conversion fails.
`static double`	`toDouble(String str)` Convert a `String` to a `double`, returning `0.0d` if the conversion fails.
`static double`	`toDouble(String str, double defaultValue)` Convert a `String` to a `double`, returning a default value if the conversion fails.
`static float`	`toFloat(String str)` Convert a `String` to a `float`, returning `0.0f` if the conversion fails.
`static float`	`toFloat(String str, float defaultValue)` Convert a `String` to a `float`, returning a default value if the conversion fails.
`static int`	`toInt(String str)` Convert a `String` to an `int`, returning `zero` if the conversion fails.
`static int`	`toInt(String str, int defaultValue)` Convert a `String` to an `int`, returning a default value if the conversion fails.
`static long`	`toLong(String str)` Convert a `String` to a `long`, returning `zero` if the conversion fails.
`static long`	`toLong(String str, long defaultValue)` Convert a `String` to a `long`, returning a default value if the conversion fails.
`static short`	`toShort(String str)` Convert a `String` to a `short`, returning `zero` if the conversion fails.
`static short`	`toShort(String str, short defaultValue)` Convert a `String` to an `short`, returning a default value if the conversion fails.

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

- Field Detail
  - LONG_ZERO
```
public static final Long LONG_ZERO
```
    Reusable Long constant for zero.
  - LONG_ONE
```
public static final Long LONG_ONE
```
    Reusable Long constant for one.
  - LONG_MINUS_ONE
```
public static final Long LONG_MINUS_ONE
```
    Reusable Long constant for minus one.
  - INTEGER_ZERO
```
public static final Integer INTEGER_ZERO
```
    Reusable Integer constant for zero.
  - INTEGER_ONE
```
public static final Integer INTEGER_ONE
```
    Reusable Integer constant for one.
  - INTEGER_MINUS_ONE
```
public static final Integer INTEGER_MINUS_ONE
```
    Reusable Integer constant for minus one.
  - SHORT_ZERO
```
public static final Short SHORT_ZERO
```
    Reusable Short constant for zero.
  - SHORT_ONE
```
public static final Short SHORT_ONE
```
    Reusable Short constant for one.
  - SHORT_MINUS_ONE
```
public static final Short SHORT_MINUS_ONE
```
    Reusable Short constant for minus one.
  - BYTE_ZERO
```
public static final Byte BYTE_ZERO
```
    Reusable Byte constant for zero.
  - BYTE_ONE
```
public static final Byte BYTE_ONE
```
    Reusable Byte constant for one.
  - BYTE_MINUS_ONE
```
public static final Byte BYTE_MINUS_ONE
```
    Reusable Byte constant for minus one.
  - DOUBLE_ZERO
```
public static final Double DOUBLE_ZERO
```
    Reusable Double constant for zero.
  - DOUBLE_ONE
```
public static final Double DOUBLE_ONE
```
    Reusable Double constant for one.
  - DOUBLE_MINUS_ONE
```
public static final Double DOUBLE_MINUS_ONE
```
    Reusable Double constant for minus one.
  - FLOAT_ZERO
```
public static final Float FLOAT_ZERO
```
    Reusable Float constant for zero.
  - FLOAT_ONE
```
public static final Float FLOAT_ONE
```
    Reusable Float constant for one.
  - FLOAT_MINUS_ONE
```
public static final Float FLOAT_MINUS_ONE
```
    Reusable Float constant for minus one.
- Constructor Detail
  - NumberUtils
```
public NumberUtils()
```
    NumberUtils instances should NOT be constructed in standard programming. Instead, the class should be used as NumberUtils.toInt("6");.
    
    This constructor is public to permit tools that require a JavaBean instance to operate.
- Method Detail
  - toInt
```
public static int toInt(String str)
```
    Convert a String to an int, returning zero if the conversion fails.
    
    If the string is null, zero is returned.
```
   NumberUtils.toInt(null) = 0
   NumberUtils.toInt("")   = 0
   NumberUtils.toInt("1")  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the int represented by the string, or zero if conversion fails
    Since:
    
    2.1
  - toInt
```
public static int toInt(String str,
        int defaultValue)
```
    Convert a String to an int, returning a default value if the conversion fails.
    
    If the string is null, the default value is returned.
```
   NumberUtils.toInt(null, 1) = 1
   NumberUtils.toInt("", 1)   = 1
   NumberUtils.toInt("1", 0)  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the int represented by the string, or the default if conversion fails
    Since:
    
    2.1
  - toLong
```
public static long toLong(String str)
```
    Convert a String to a long, returning zero if the conversion fails.
    
    If the string is null, zero is returned.
```
   NumberUtils.toLong(null) = 0L
   NumberUtils.toLong("")   = 0L
   NumberUtils.toLong("1")  = 1L
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the long represented by the string, or 0 if conversion fails
    Since:
    
    2.1
  - toLong
```
public static long toLong(String str,
          long defaultValue)
```
    Convert a String to a long, returning a default value if the conversion fails.
    
    If the string is null, the default value is returned.
```
   NumberUtils.toLong(null, 1L) = 1L
   NumberUtils.toLong("", 1L)   = 1L
   NumberUtils.toLong("1", 0L)  = 1L
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the long represented by the string, or the default if conversion fails
    Since:
    
    2.1
  - toFloat
```
public static float toFloat(String str)
```
    Convert a String to a float, returning 0.0f if the conversion fails.
    
    If the string str is null, 0.0f is returned.
```
   NumberUtils.toFloat(null)   = 0.0f
   NumberUtils.toFloat("")     = 0.0f
   NumberUtils.toFloat("1.5")  = 1.5f
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the float represented by the string, or 0.0f if conversion fails
    Since:
    
    2.1
  - toFloat
```
public static float toFloat(String str,
            float defaultValue)
```
    Convert a String to a float, returning a default value if the conversion fails.
    
    If the string str is null, the default value is returned.
```
   NumberUtils.toFloat(null, 1.1f)   = 1.0f
   NumberUtils.toFloat("", 1.1f)     = 1.1f
   NumberUtils.toFloat("1.5", 0.0f)  = 1.5f
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the float represented by the string, or defaultValue if conversion fails
    Since:
    
    2.1
  - toDouble
```
public static double toDouble(String str)
```
    Convert a String to a double, returning 0.0d if the conversion fails.
    
    If the string str is null, 0.0d is returned.
```
   NumberUtils.toDouble(null)   = 0.0d
   NumberUtils.toDouble("")     = 0.0d
   NumberUtils.toDouble("1.5")  = 1.5d
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the double represented by the string, or 0.0d if conversion fails
    Since:
    
    2.1
  - toDouble
```
public static double toDouble(String str,
              double defaultValue)
```
    Convert a String to a double, returning a default value if the conversion fails.
    
    If the string str is null, the default value is returned.
```
   NumberUtils.toDouble(null, 1.1d)   = 1.1d
   NumberUtils.toDouble("", 1.1d)     = 1.1d
   NumberUtils.toDouble("1.5", 0.0d)  = 1.5d
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the double represented by the string, or defaultValue if conversion fails
    Since:
    
    2.1
  - toByte
```
public static byte toByte(String str)
```
    Convert a String to a byte, returning zero if the conversion fails.
    
    If the string is null, zero is returned.
```
   NumberUtils.toByte(null) = 0
   NumberUtils.toByte("")   = 0
   NumberUtils.toByte("1")  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the byte represented by the string, or zero if conversion fails
    Since:
    
    2.5
  - toByte
```
public static byte toByte(String str,
          byte defaultValue)
```
    Convert a String to a byte, returning a default value if the conversion fails.
    
    If the string is null, the default value is returned.
```
   NumberUtils.toByte(null, 1) = 1
   NumberUtils.toByte("", 1)   = 1
   NumberUtils.toByte("1", 0)  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the byte represented by the string, or the default if conversion fails
    Since:
    
    2.5
  - toShort
```
public static short toShort(String str)
```
    Convert a String to a short, returning zero if the conversion fails.
    
    If the string is null, zero is returned.
```
   NumberUtils.toShort(null) = 0
   NumberUtils.toShort("")   = 0
   NumberUtils.toShort("1")  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    
    Returns:
    the short represented by the string, or zero if conversion fails
    Since:
    
    2.5
  - toShort
```
public static short toShort(String str,
            short defaultValue)
```
    Convert a String to an short, returning a default value if the conversion fails.
    
    If the string is null, the default value is returned.
```
   NumberUtils.toShort(null, 1) = 1
   NumberUtils.toShort("", 1)   = 1
   NumberUtils.toShort("1", 0)  = 1
 
```
    Parameters:
    str - the string to convert, may be null
    defaultValue - the default value
    
    Returns:
    the short represented by the string, or the default if conversion fails
    Since:
    
    2.5
  - createNumber
```
public static Number createNumber(String str)
                           throws NumberFormatException
```
    Turns a string value into a java.lang.Number.
    
    If the string starts with 0x or -0x (lower or upper case) or # or -#, it will be interpreted as a hexadecimal Integer - or Long, if the number of digits after the prefix is more than 8 - or BigInteger if there are more than 16 digits.
    
    Then, the value is examined for a type qualifier on the end, i.e. one of 'f','F','d','D','l','L'. If it is found, it starts trying to create successively larger types from the type specified until one is found that can represent the value.
    
    If a type specifier is not found, it will check for a decimal point and then try successively larger types from Integer to BigInteger and from Float to BigDecimal.
    
    Integral values with a leading 0 will be interpreted as octal; the returned number will be Integer, Long or BigDecimal as appropriate.
    
    Returns null if the string is null.
    
    This method does not trim the input string, i.e., strings with leading or trailing spaces will generate NumberFormatExceptions.
    
    Parameters:
    str - String containing a number, may be null
    
    Returns:
    Number created from the string (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createFloat
```
public static Float createFloat(String str)
```
    Convert a String to a Float.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted Float (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createDouble
```
public static Double createDouble(String str)
```
    Convert a String to a Double.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted Double (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createInteger
```
public static Integer createInteger(String str)
```
    Convert a String to a Integer, handling hex (0xhhhh) and octal (0dddd) notations. N.B. a leading zero means octal; spaces are not trimmed.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted Integer (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createLong
```
public static Long createLong(String str)
```
    Convert a String to a Long; since 3.1 it handles hex (0Xhhhh) and octal (0ddd) notations. N.B. a leading zero means octal; spaces are not trimmed.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted Long (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createBigInteger
```
public static BigInteger createBigInteger(String str)
```
    Convert a String to a BigInteger; since 3.2 it handles hex (0x or #) and octal (0) notations.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted BigInteger (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - createBigDecimal
```
public static BigDecimal createBigDecimal(String str)
```
    Convert a String to a BigDecimal.
    
    Returns null if the string is null.
    
    Parameters:
    str - a String to convert, may be null
    
    Returns:
    converted BigDecimal (or null if the input is null)
    
    Throws:
    
    NumberFormatException - if the value cannot be converted
  - min
```
public static long min(long... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(long[]) to min(long...)
  - min
```
public static int min(int... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(int[]) to min(int...)
  - min
```
public static short min(short... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(short[]) to min(short...)
  - min
```
public static byte min(byte... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(byte[]) to min(byte...)
  - min
```
public static double min(double... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(double[]) to min(double...)
    
    See Also:
    IEEE754rUtils for a version of this method that handles NaN differently
  - min
```
public static float min(float... array)
```
    Returns the minimum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the minimum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from min(float[]) to min(float...)
    
    See Also:
    IEEE754rUtils for a version of this method that handles NaN differently
  - max
```
public static long max(long... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(long[]) to max(long...)
  - max
```
public static int max(int... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(int[]) to max(int...)
  - max
```
public static short max(short... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(short[]) to max(short...)
  - max
```
public static byte max(byte... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(byte[]) to max(byte...)
  - max
```
public static double max(double... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(double[]) to max(double...)
    
    See Also:
    IEEE754rUtils for a version of this method that handles NaN differently
  - max
```
public static float max(float... array)
```
    Returns the maximum value in an array.
    
    Parameters:
    array - an array, must not be null or empty
    
    Returns:
    the maximum value in the array
    
    Throws:
    
    IllegalArgumentException - if array is null
    
    IllegalArgumentException - if array is empty
    Since:
    
    3.4 Changed signature from max(float[]) to max(float...)
    
    See Also:
    IEEE754rUtils for a version of this method that handles NaN differently
  - min
```
public static long min(long a,
       long b,
       long c)
```
    Gets the minimum of three long values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
  - min
```
public static int min(int a,
      int b,
      int c)
```
    Gets the minimum of three int values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
  - min
```
public static short min(short a,
        short b,
        short c)
```
    Gets the minimum of three short values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
  - min
```
public static byte min(byte a,
       byte b,
       byte c)
```
    Gets the minimum of three byte values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
  - min
```
public static double min(double a,
         double b,
         double c)
```
    Gets the minimum of three double values.
    
    If any value is NaN, NaN is returned. Infinity is handled.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
    See Also:
    for a version of this method that handles NaN differently
  - min
```
public static float min(float a,
        float b,
        float c)
```
    Gets the minimum of three float values.
    
    If any value is NaN, NaN is returned. Infinity is handled.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the smallest of the values
    See Also:
    for a version of this method that handles NaN differently
  - max
```
public static long max(long a,
       long b,
       long c)
```
    Gets the maximum of three long values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
  - max
```
public static int max(int a,
      int b,
      int c)
```
    Gets the maximum of three int values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
  - max
```
public static short max(short a,
        short b,
        short c)
```
    Gets the maximum of three short values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
  - max
```
public static byte max(byte a,
       byte b,
       byte c)
```
    Gets the maximum of three byte values.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
  - max
```
public static double max(double a,
         double b,
         double c)
```
    Gets the maximum of three double values.
    
    If any value is NaN, NaN is returned. Infinity is handled.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
    See Also:
    for a version of this method that handles NaN differently
  - max
```
public static float max(float a,
        float b,
        float c)
```
    Gets the maximum of three float values.
    
    If any value is NaN, NaN is returned. Infinity is handled.
    
    Parameters:
    a - value 1
    b - value 2
    c - value 3
    
    Returns:
    the largest of the values
    See Also:
    for a version of this method that handles NaN differently
  - isDigits
```
public static boolean isDigits(String str)
```
    Checks whether the String contains only digit characters.
    
    Null and empty String will return false.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if str contains only Unicode numeric
  - isNumber
```
public static boolean isNumber(String str)
```
    Checks whether the String a valid Java number.
    
    Valid numbers include hexadecimal marked with the 0x or 0X qualifier, octal numbers, scientific notation and numbers marked with a type qualifier (e.g. 123L).
    
    Non-hexadecimal strings beginning with a leading zero are treated as octal values. Thus the string 09 will return false, since 9 is not a valid octal value. However, numbers beginning with 0. are treated as decimal.
    
    null and empty/blank String will return false.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if the string is a correctly formatted number
    Since:
    
    3.3 the code supports hex 0Xhhh and octal 0ddd validation
  - isParsable
```
public static boolean isParsable(String str)
```
    Checks whether the given String is a parsable number.
    
    Parsable numbers include those Strings understood by Integer.parseInt(String), Long.parseLong(String), Float.parseFloat(String) or Double.parseDouble(String). This method can be used instead of catching ParseException when calling one of those methods.
    
    Hexadecimal and scientific notations are not considered parsable. See isNumber(String) on those cases.
    
    Null and empty String will return false.
    
    Parameters:
    str - the String to check.
    
    Returns:
    true if the string is a parsable number.
    Since:
    
    3.4
  - compare
```
public static int compare(int x,
          int y)
```
    Compares two int values numerically. This is the same functionality as provided in Java 7.
    
    Parameters:
    x - the first int to compare
    y - the second int to compare
    
    Returns:
    the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y
    Since:
    
    3.4
  - compare
```
public static int compare(long x,
          long y)
```
    Compares to long values numerically. This is the same functionality as provided in Java 7.
    
    Parameters:
    x - the first long to compare
    y - the second long to compare
    
    Returns:
    the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y
    Since:
    
    3.4
  - compare
```
public static int compare(short x,
          short y)
```
    Compares to short values numerically. This is the same functionality as provided in Java 7.
    
    Parameters:
    x - the first short to compare
    y - the second short to compare
    
    Returns:
    the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y
    Since:
    
    3.4
  - compare
```
public static int compare(byte x,
          byte y)
```
    Compares two byte values numerically. This is the same functionality as provided in Java 7.
    
    Parameters:
    x - the first byte to compare
    y - the second byte to compare
    
    Returns:
    the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y
    Since:
    
    3.4

Class NumberUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LONG_ZERO

LONG_ONE

LONG_MINUS_ONE

INTEGER_ZERO

INTEGER_ONE

INTEGER_MINUS_ONE

SHORT_ZERO

SHORT_ONE

SHORT_MINUS_ONE

BYTE_ZERO

BYTE_ONE

BYTE_MINUS_ONE

DOUBLE_ZERO

DOUBLE_ONE

DOUBLE_MINUS_ONE

FLOAT_ZERO

FLOAT_ONE

FLOAT_MINUS_ONE

Constructor Detail

NumberUtils

Method Detail

toInt

toInt

toLong

toLong

toFloat

toFloat

toDouble

toDouble

toByte

toByte

toShort

toShort

createNumber

createFloat

createDouble

createInteger

createLong

createBigInteger

createBigDecimal

min

min

min

min

min

min

max

max

max

max

max

max

min

min

min

min

min

min

max

max

max

max

max

max

isDigits

isNumber

isParsable

compare

compare

compare

compare