Numbers (polaris-toolkit 3.3.6 API)

java.lang.Object
- io.polaris.core.lang.Numbers

```
public class Numbers
extends Object
```
作者:

Qt

构造器概要

构造器
构造器和说明

Numbers()

构造器
构造器和说明
`Numbers()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static BigDecimal`	`add(BigDecimal... values)` 提供精确的加法运算如果传入多个值为null或者空，则返回0
`static double`	`add(double v1, double v2)` 提供精确的加法运算
`static double`	`add(Double v1, Double v2)` 提供精确的加法运算
`static double`	`add(double v1, float v2)` 提供精确的加法运算
`static double`	`add(float v1, double v2)` 提供精确的加法运算
`static double`	`add(float v1, float v2)` 提供精确的加法运算
`static BigDecimal`	`add(Number... values)` 提供精确的加法运算如果传入多个值为null或者空，则返回0 需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数也就是说，在这些国家地区，1.20表示120，而非1.2。
`static BigDecimal`	`add(Number v1, Number v2)` 提供精确的加法运算如果传入多个值为null或者空，则返回0 需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数也就是说，在这些国家地区，1.20表示120，而非1.2。
`static BigDecimal`	`add(String... values)` 提供精确的加法运算如果传入多个值为null或者空，则返回0
`static Collection<Integer>`	`appendRange(int start, int stop, Collection<Integer> values)` 将给定范围内的整数添加到已有集合中，步进为1
`static Collection<Integer>`	`appendRange(int start, int stop, int step, Collection<Integer> values)` 将给定范围内的整数添加到已有集合中
`static double`	`calculate(String expression)` 计算数学表达式的值，只支持加减乘除和取余如： calculate("(01--3)-5/-4-(3(-2.13))") -》 10.64
`static int`	`ceilDiv(int x, int y)` 补充Math.ceilDiv() JDK8中添加了和Math.floorDiv()但却没有ceilDiv()
`static long`	`ceilDiv(long x, long y)`
`static int`	`compare(byte x, byte y)` 比较两个值的大小
`static int`	`compare(char x, char y)` 比较两个值的大小
`static int`	`compare(double x, double y)` 比较两个值的大小
`static int`	`compare(int x, int y)` 比较两个值的大小
`static int`	`compare(long x, long y)` 比较两个值的大小
`static int`	`compare(short x, short y)` 比较两个值的大小
`static String`	`decimalFormat(String pattern, double value)` 格式化double 对 `DecimalFormat` 做封装
`static String`	`decimalFormat(String pattern, long value)` 格式化double 对 `DecimalFormat` 做封装
`static String`	`decimalFormat(String pattern, Object value)` 格式化double 对 `DecimalFormat` 做封装
`static String`	`decimalFormat(String pattern, Object value, RoundingMode roundingMode)` 格式化double 对 `DecimalFormat` 做封装
`static String`	`decimalFormatMoney(double value)` 格式化金额输出，每三位用逗号分隔
`static BigDecimal`	`div(BigDecimal v1, BigDecimal v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static double`	`div(double v1, double v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static double`	`div(Double v1, Double v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static double`	`div(double v1, double v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static double`	`div(Double v1, Double v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static double`	`div(double v1, double v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static double`	`div(Double v1, Double v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static double`	`div(double v1, float v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static double`	`div(double v1, float v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static double`	`div(double v1, float v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static double`	`div(float v1, double v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static double`	`div(float v1, double v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static double`	`div(float v1, double v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static double`	`div(float v1, float v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static double`	`div(float v1, float v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static double`	`div(float v1, float v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static BigDecimal`	`div(Number v1, Number v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static BigDecimal`	`div(Number v1, Number v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static BigDecimal`	`div(Number v1, Number v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static BigDecimal`	`div(String v1, String v2)` 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
`static BigDecimal`	`div(String v1, String v2, int scale)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
`static BigDecimal`	`div(String v1, String v2, int scale, RoundingMode roundingMode)` 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
`static int`	`divisor(int m, int n)` 最大公约数
`static boolean`	`equals(BigDecimal bigNum1, BigDecimal bigNum2)` 比较大小，值相等返回true 此方法通过调用`BigDecimal.compareTo(BigDecimal)`方法来判断是否相等此方法判断值相等时忽略精度的，即0.00 == 0
`static boolean`	`equals(char c1, char c2, boolean ignoreCase)` 比较两个字符是否相同
`static boolean`	`equals(double num1, double num2)` 比较大小，值相等返回true 此方法通过调用`Double.doubleToLongBits(double)`方法来判断是否相等此方法判断值相等时忽略精度的，即0.00 == 0
`static boolean`	`equals(float num1, float num2)` 比较大小，值相等返回true 此方法通过调用`Float.floatToIntBits(float)`方法来判断是否相等此方法判断值相等时忽略精度的，即0.00 == 0
`static boolean`	`equals(long num1, long num2)` 比较大小，值相等返回true 此方法修复传入long型数据由于没有本类型重载方法,导致数据精度丢失
`static boolean`	`equals(Number number1, Number number2)` 比较数字值是否相等，相等返回`true` 需要注意的是`BigDecimal`需要特殊处理 BigDecimal使用compareTo方式判断，因为使用equals方法也判断小数位数，如2.0和2.00就不相等，此方法判断值相等时忽略精度的，即0.00 == 0 如果用户提供两个Number都是`BigDecimal`，则通过调用`BigDecimal.compareTo(BigDecimal)`方法来判断是否相等其他情况调用`Object.equals(Object)`比较
`static BigInteger`	`factorial(BigInteger n)` 计算阶乘 n!
`static BigInteger`	`factorial(BigInteger start, BigInteger end)` 计算范围阶乘 factorial(start, end) = start * (start - 1) * ... * (end + 1)
`static long`	`factorial(long n)` 计算阶乘 n!
`static long`	`factorial(long start, long end)` 计算范围阶乘 factorial(start, end) = start * (start - 1) * ... * (end + 1)
`static int`	`floorDiv(int x, int y)`
`static long`	`floorDiv(long x, long y)`
`static String`	`formatPercent(double number, int scale)` 格式化百分比，小数采用四舍五入方式
`static BigInteger`	`fromUnsignedByteArray(byte[] buf)`
`static BigInteger`	`fromUnsignedByteArray(byte[] buf, int off, int length)`
`static Integer[]`	`generateBySet(int begin, int end, int size)` 生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
`static int[]`	`generateRandomNumber(int begin, int end, int size)` 生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
`static int[]`	`generateRandomNumber(int begin, int end, int size, int[] seed)` 生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
`static boolean`	`isBeside(int number1, int number2)` 判断两个数字是否相邻，例如1和2相邻，1和3不相邻判断方法为做差取绝对值判断是否为1
`static boolean`	`isBeside(long number1, long number2)` 判断两个数字是否相邻，例如1和2相邻，1和3不相邻判断方法为做差取绝对值判断是否为1
`static boolean`	`isDouble(String s)` 判断字符串是否是浮点数
`static boolean`	`isEven(int num)` 检查是否为偶数
`static boolean`	`isGreater(BigDecimal bigNum1, BigDecimal bigNum2)` 比较大小，参数1 > 参数2 返回true
`static boolean`	`isGreaterOrEqual(BigDecimal bigNum1, BigDecimal bigNum2)` 比较大小，参数1 >= 参数2 返回true
`static boolean`	`isIn(BigDecimal value, BigDecimal minInclude, BigDecimal maxInclude)` 检查值是否在指定范围内
`static boolean`	`isInteger(String s)` 判断String是否是整数支持10进制
`static boolean`	`isLess(BigDecimal bigNum1, BigDecimal bigNum2)` 比较大小，参数1 < 参数2 返回true
`static boolean`	`isLessOrEqual(BigDecimal bigNum1, BigDecimal bigNum2)` 比较大小，参数1<=参数2 返回true
`static boolean`	`isLong(String s)` 判断字符串是否是Long类型支持10进制
`static boolean`	`isNumber(CharSequence str)` 是否为数字，支持包括： 1、10进制 2、16进制数字（0x开头） 3、科学计数法形式（1234E3） 4、类型标识形式（123D） 5、正负数标识形式（+123、-234）
`static boolean`	`isOdd(int num)` 检查是否为奇数
`static boolean`	`isPowerOfTwo(long n)` 判断一个整数是否是2的幂
`static boolean`	`isPrime(int n)` 是否是质数（素数）质数表的质数又称素数。
`static boolean`	`isValid(double number)` 检查是否为有效的数字检查double否为无限大，或者Not a Number（NaN）
`static boolean`	`isValid(float number)` 检查是否为有效的数字检查double否为无限大，或者Not a Number（NaN）
`static boolean`	`isValidNumber(Number number)` 检查是否为有效的数字检查Double和Float是否为无限大，或者Not a Number 非数字类型和Null将返回true
`static BigDecimal`	`max(BigDecimal... numberArray)` 取最大值
`static double`	`max(double... numberArray)` 取最大值
`static float`	`max(float... numberArray)` 取最大值
`static int`	`max(int... numberArray)` 取最大值
`static long`	`max(long... numberArray)` 取最大值
`static short`	`max(short... numberArray)` 取最大值
`static <T extends Comparable<? super T>> T`	`max(T[] numberArray)` 取最大值
`static BigDecimal`	`min(BigDecimal... numberArray)` 取最小值
`static double`	`min(double... numberArray)` 取最小值
`static float`	`min(float... numberArray)` 取最小值
`static int`	`min(int... numberArray)` 取最小值
`static long`	`min(long... numberArray)` 取最小值
`static short`	`min(short... numberArray)` 取最小值
`static <T extends Comparable<? super T>> T`	`min(T[] numberArray)` 取最小值
`static BigDecimal`	`mul(BigDecimal... values)` 提供精确的乘法运算如果传入多个值为null或者空，则返回0
`static double`	`mul(double v1, double v2)` 提供精确的乘法运算
`static double`	`mul(Double v1, Double v2)` 提供精确的乘法运算如果传入多个值为null或者空，则返回0
`static double`	`mul(double v1, float v2)` 提供精确的乘法运算
`static double`	`mul(float v1, double v2)` 提供精确的乘法运算
`static double`	`mul(float v1, float v2)` 提供精确的乘法运算
`static BigDecimal`	`mul(Number... values)` 提供精确的乘法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`mul(Number v1, Number v2)` 提供精确的乘法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`mul(String... values)` 提供精确的乘法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`mul(String v1, String v2)` 提供精确的乘法运算
`static int`	`multiple(int m, int n)` 最小公倍数
`static BigInteger`	`newBigInteger(String str)`
`static double`	`parseDouble(String number)` 解析转换数字字符串为long型数字，规则如下： 1、0开头的忽略开头的0 2、空串返回0 3、其它情况按照10进制转换 4、.123形式返回0.123（按照小于0的小数对待）
`static Double`	`parseDouble(String numberStr, Double defaultValue)` 解析转换数字字符串为 `Double` 规则如下： 1、0开头的忽略开头的0 2、空串返回0 3、其它情况按照10进制转换 4、.123形式返回0.123（按照小于0的小数对待）
`static float`	`parseFloat(String number)` 解析转换数字字符串为long型数字，规则如下： 1、0开头的忽略开头的0 2、空串返回0 3、其它情况按照10进制转换 4、.123形式返回0.123（按照小于0的小数对待）
`static Float`	`parseFloat(String numberStr, Float defaultValue)` 解析转换数字字符串为 `Float` 规则如下： 1、0开头的忽略开头的0 2、空串返回0 3、其它情况按照10进制转换 4、.123形式返回0.123（按照小于0的小数对待）
`static int`	`parseInt(String number)` 解析转换数字字符串为int型数字，规则如下： 1、0x开头的视为16进制数字 2、0开头的忽略开头的0 3、其它情况按照10进制转换 4、空串返回0 5、.123形式返回0（按照小于0的小数对待） 6、123.56截取小数点之前的数字，忽略小数部分
`static Integer`	`parseInt(String numberStr, Integer defaultValue)` 解析转换数字字符串为 `Integer` 规则如下： 1、0x开头的视为16进制数字 2、0开头的忽略开头的0 3、其它情况按照10进制转换 4、空串返回0 5、.123形式返回0（按照小于0的小数对待） 6、123.56截取小数点之前的数字，忽略小数部分 7、解析失败返回默认值
`static long`	`parseLong(String number)` 解析转换数字字符串为long型数字，规则如下： 1、0x开头的视为16进制数字 2、0开头的忽略开头的0 3、空串返回0 4、其它情况按照10进制转换 5、.123形式返回0（按照小于0的小数对待） 6、123.56截取小数点之前的数字，忽略小数部分
`static Long`	`parseLong(String numberStr, Long defaultValue)` 解析转换数字字符串为 `Long` 规则如下： 1、0x开头的视为16进制数字 2、0开头的忽略开头的0 3、其它情况按照10进制转换 4、空串返回0 5、.123形式返回0（按照小于0的小数对待） 6、123.56截取小数点之前的数字，忽略小数部分 7、解析失败返回默认值
`static Number`	`parseNumber(String numberStr)` 将指定字符串转换为`Number` 对象此方法不支持科学计数法需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数也就是说，在这些国家地区，1.20表示120，而非1.2。
`static Number`	`parseNumber(String numberStr, Number defaultValue)` 将指定字符串转换为`Number` 此方法不支持科学计数法
`static int`	`partValue(int total, int partCount)` 把给定的总数平均分成N份，返回每份的个数当除以分数有余数时每份+1
`static int`	`partValue(int total, int partCount, boolean isPlusOneWhenHasRem)` 把给定的总数平均分成N份，返回每份的个数如果isPlusOneWhenHasRem为true，则当除以分数有余数时每份+1，否则丢弃余数部分
`static BigDecimal`	`pow(BigDecimal number, int n)` 提供精确的幂运算
`static BigDecimal`	`pow(Number number, int n)` 提供精确的幂运算
`static int`	`processMultiple(int selectNum, int minNum)` 可以用于计算双色球、大乐透注数的方法比如大乐透35选5可以这样调用processMultiple(7,5); 就是数学中的：C75=76/21
`static int[]`	`range(int stop)` 从0开始给定范围内的整数列表，步进为1
`static int[]`	`range(int start, int stop)` 给定范围内的整数列表，步进为1
`static int[]`	`range(int start, int stop, int step)` 给定范围内的整数列表
`static BigDecimal`	`round(BigDecimal number, int scale)`
`static BigDecimal`	`round(BigDecimal number, int scale, RoundingMode roundingMode)`
`static BigDecimal`	`round(double v, int scale)` 保留固定位数小数采用四舍五入策略 `RoundingMode.HALF_UP` 例如保留2位小数：123.456789 =》 123.46
`static BigDecimal`	`round(double v, int scale, RoundingMode roundingMode)` 保留固定位数小数例如保留四位小数：123.456789 =》 123.4567
`static BigDecimal`	`round(String numberStr, int scale)`
`static BigDecimal`	`round(String numberStr, int scale, RoundingMode roundingMode)`
`static BigDecimal`	`roundDown(BigDecimal value, int scale)`
`static BigDecimal`	`roundDown(Number number, int scale)`
`static BigDecimal`	`roundHalfEven(BigDecimal value, int scale)`
`static BigDecimal`	`roundHalfEven(Number number, int scale)`
`static String`	`roundStr(double v, int scale)` 保留固定位数小数采用四舍五入策略 `RoundingMode.HALF_UP` 例如保留2位小数：123.456789 =》 123.46
`static String`	`roundStr(double v, int scale, RoundingMode roundingMode)` 保留固定位数小数例如保留四位小数：123.456789 =》 123.4567
`static long`	`sqrt(long x)` 平方根算法推荐使用 `Math.sqrt(double)`
`static BigDecimal`	`sub(BigDecimal... values)` 提供精确的减法运算如果传入多个值为null或者空，则返回0
`static double`	`sub(double v1, double v2)` 提供精确的减法运算
`static double`	`sub(Double v1, Double v2)` 提供精确的减法运算
`static double`	`sub(double v1, float v2)` 提供精确的减法运算
`static double`	`sub(float v1, double v2)` 提供精确的减法运算
`static double`	`sub(float v1, float v2)` 提供精确的减法运算
`static BigDecimal`	`sub(Number... values)` 提供精确的减法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`sub(Number v1, Number v2)` 提供精确的减法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`sub(String... values)` 提供精确的减法运算如果传入多个值为null或者空，则返回0
`static BigDecimal`	`toBigDecimal(Number number)`
`static BigDecimal`	`toBigDecimal(String numberStr)`
`static BigInteger`	`toBigInteger(Number number)`
`static BigInteger`	`toBigInteger(String number)`
`static String`	`toBinaryString(Number number)` 获得数字对应的二进制字符串
`static byte[]`	`toBytes(int value)`
`static double`	`toDouble(Number value)` Number值转换为double float强制转换存在精度问题，此方法避免精度丢失
`static int`	`toInt(byte[] bytes)`
`static String`	`toString(BigDecimal bigDecimal)`
`static String`	`toString(BigDecimal bigDecimal, boolean isStripTrailingZeros)`
`static String`	`toString(Number number)` 数字转字符串调用`Object.toString()`或 `BigDecimal.toPlainString()`，并去除尾小数点儿后多余的0
`static String`	`toString(Number number, boolean isStripTrailingZeros)` 数字转字符串调用`Object.toString()`或 `BigDecimal.toPlainString()`，并去除尾小数点儿后多余的0
`static String`	`toString(Number number, String defaultValue)` 数字转字符串调用`Object.toString()`，并去除尾小数点儿后多余的0
`static byte[]`	`toUnsignedByteArray(BigInteger value)`
`static byte[]`	`toUnsignedByteArray(int length, BigInteger value)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - Numbers
```
public Numbers()
```
- 方法详细资料
  - calculate
```
@Experimental
public static double calculate(String expression)
```
    计算数学表达式的值，只支持加减乘除和取余
    如：
```
   calculate("(0*1--3)-5/-4-(3*(-2.13))") -》 10.64
 
```
    参数:
    
    expression - 数学表达式
    
    返回:
    
    结果
  - floorDiv
```
public static long floorDiv(long x,
                            long y)
```
    另请参阅:
    
    Math.floorDiv(long, long)
  - floorDiv
```
public static int floorDiv(int x,
                           int y)
```
    另请参阅:
    
    Math.floorDiv(int, int)
  - ceilDiv
```
public static long ceilDiv(long x,
                           long y)
```
  - ceilDiv
```
public static int ceilDiv(int x,
                          int y)
```
    补充Math.ceilDiv() JDK8中添加了和Math.floorDiv()但却没有ceilDiv()
    
    参数:
    
    x - 被除数
    
    y - 除数
    
    返回:
    
    两个参数的商
    
    另请参阅:
    
    Math.floorDiv(int, int)
  - pow
```
public static BigDecimal pow(Number number,
                             int n)
```
    提供精确的幂运算
    
    参数:
    
    number - 底数
    
    n - 指数
    
    返回:
    
    幂的积
  - pow
```
public static BigDecimal pow(BigDecimal number,
                             int n)
```
    提供精确的幂运算
    
    参数:
    
    number - 底数
    
    n - 指数
    
    返回:
    
    幂的积
  - add
```
public static double add(float v1,
                         float v2)
```
    提供精确的加法运算
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static double add(float v1,
                         double v2)
```
    提供精确的加法运算
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static double add(double v1,
                         float v2)
```
    提供精确的加法运算
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static double add(double v1,
                         double v2)
```
    提供精确的加法运算
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static double add(Double v1,
                         Double v2)
```
    提供精确的加法运算
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static BigDecimal add(Number v1,
                             Number v2)
```
    提供精确的加法运算
    如果传入多个值为null或者空，则返回0
    需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：
    德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数
    也就是说，在这些国家地区，1.20表示120，而非1.2。
    
    参数:
    
    v1 - 被加数
    
    v2 - 加数
    
    返回:
    
    和
  - add
```
public static BigDecimal add(Number... values)
```
    提供精确的加法运算
    如果传入多个值为null或者空，则返回0
    需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：
    德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数
    也就是说，在这些国家地区，1.20表示120，而非1.2。
    
    参数:
    
    values - 多个被加值
    
    返回:
    
    和
  - add
```
public static BigDecimal add(String... values)
```
    提供精确的加法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被加值
    
    返回:
    
    和
  - add
```
public static BigDecimal add(BigDecimal... values)
```
    提供精确的加法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被加值
    
    返回:
    
    和
  - sub
```
public static double sub(float v1,
                         float v2)
```
    提供精确的减法运算
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static double sub(float v1,
                         double v2)
```
    提供精确的减法运算
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static double sub(double v1,
                         float v2)
```
    提供精确的减法运算
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static double sub(double v1,
                         double v2)
```
    提供精确的减法运算
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static double sub(Double v1,
                         Double v2)
```
    提供精确的减法运算
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static BigDecimal sub(Number v1,
                             Number v2)
```
    提供精确的减法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    v1 - 被减数
    
    v2 - 减数
    
    返回:
    
    差
  - sub
```
public static BigDecimal sub(Number... values)
```
    提供精确的减法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被减值
    
    返回:
    
    差
  - sub
```
public static BigDecimal sub(String... values)
```
    提供精确的减法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被减值
    
    返回:
    
    差
  - sub
```
public static BigDecimal sub(BigDecimal... values)
```
    提供精确的减法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被减值
    
    返回:
    
    差
  - mul
```
public static double mul(float v1,
                         float v2)
```
    提供精确的乘法运算
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static double mul(float v1,
                         double v2)
```
    提供精确的乘法运算
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static double mul(double v1,
                         float v2)
```
    提供精确的乘法运算
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static double mul(double v1,
                         double v2)
```
    提供精确的乘法运算
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static double mul(Double v1,
                         Double v2)
```
    提供精确的乘法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static BigDecimal mul(Number v1,
                             Number v2)
```
    提供精确的乘法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static BigDecimal mul(Number... values)
```
    提供精确的乘法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被乘值
    
    返回:
    
    积
  - mul
```
public static BigDecimal mul(String v1,
                             String v2)
```
    提供精确的乘法运算
    
    参数:
    
    v1 - 被乘数
    
    v2 - 乘数
    
    返回:
    
    积
  - mul
```
public static BigDecimal mul(String... values)
```
    提供精确的乘法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被乘值
    
    返回:
    
    积
  - mul
```
public static BigDecimal mul(BigDecimal... values)
```
    提供精确的乘法运算
    如果传入多个值为null或者空，则返回0
    
    参数:
    
    values - 多个被乘值
    
    返回:
    
    积
  - div
```
public static double div(float v1,
                         float v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static double div(float v1,
                         double v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         float v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         double v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static double div(Double v1,
                         Double v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(Number v1,
                             Number v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(String v1,
                             String v2)
```
    提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    返回:
    
    两个参数的商
  - div
```
public static double div(float v1,
                         float v2,
                         int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static double div(float v1,
                         double v2,
                         int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         float v2,
                         int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         double v2,
                         int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static double div(Double v1,
                         Double v2,
                         int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(Number v1,
                             Number v2,
                             int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(String v1,
                             String v2,
                             int scale)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    返回:
    
    两个参数的商
  - div
```
public static double div(float v1,
                         float v2,
                         int scale,
                         RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static double div(float v1,
                         double v2,
                         int scale,
                         RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         float v2,
                         int scale,
                         RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static double div(double v1,
                         double v2,
                         int scale,
                         RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static double div(Double v1,
                         Double v2,
                         int scale,
                         RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(Number v1,
                             Number v2,
                             int scale,
                             RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(String v1,
                             String v2,
                             int scale,
                             RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - div
```
public static BigDecimal div(BigDecimal v1,
                             BigDecimal v2,
                             int scale,
                             RoundingMode roundingMode)
```
    提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
    
    参数:
    
    v1 - 被除数
    
    v2 - 除数
    
    scale - 精确度，如果为负值，取绝对值
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    两个参数的商
  - round
```
public static BigDecimal round(double v,
                               int scale)
```
    保留固定位数小数
    采用四舍五入策略 RoundingMode.HALF_UP
    例如保留2位小数：123.456789 =》 123.46
    
    参数:
    
    v - 值
    
    scale - 保留小数位数
    
    返回:
    
    新值
  - roundStr
```
public static String roundStr(double v,
                              int scale)
```
    保留固定位数小数
    采用四舍五入策略 RoundingMode.HALF_UP
    例如保留2位小数：123.456789 =》 123.46
    
    参数:
    
    v - 值
    
    scale - 保留小数位数
    
    返回:
    
    新值
  - round
```
public static BigDecimal round(String numberStr,
                               int scale)
```
    另请参阅:
    
    BigDecimals.round(String, int)
  - round
```
public static BigDecimal round(BigDecimal number,
                               int scale)
```
    另请参阅:
    
    BigDecimals.round(BigDecimal, int)
  - round
```
public static BigDecimal round(double v,
                               int scale,
                               RoundingMode roundingMode)
```
    保留固定位数小数
    例如保留四位小数：123.456789 =》 123.4567
    
    参数:
    
    v - 值
    
    scale - 保留小数位数
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    新值
  - roundStr
```
public static String roundStr(double v,
                              int scale,
                              RoundingMode roundingMode)
```
    保留固定位数小数
    例如保留四位小数：123.456789 =》 123.4567
    
    参数:
    
    v - 值
    
    scale - 保留小数位数
    
    roundingMode - 保留小数的模式 RoundingMode
    
    返回:
    
    新值
  - round
```
public static BigDecimal round(String numberStr,
                               int scale,
                               RoundingMode roundingMode)
```
    另请参阅:
    
    BigDecimals.round(String, int, RoundingMode)
  - round
```
public static BigDecimal round(BigDecimal number,
                               int scale,
                               RoundingMode roundingMode)
```
    另请参阅:
    
    BigDecimals.round(BigDecimal, int, RoundingMode)
  - roundHalfEven
```
public static BigDecimal roundHalfEven(Number number,
                                       int scale)
```
    另请参阅:
    
    BigDecimals.roundHalfEven(Number, int)
  - roundHalfEven
```
public static BigDecimal roundHalfEven(BigDecimal value,
                                       int scale)
```
    另请参阅:
    
    BigDecimals.roundHalfEven(BigDecimal, int)
  - roundDown
```
public static BigDecimal roundDown(Number number,
                                   int scale)
```
    另请参阅:
    
    BigDecimals.roundDown(Number, int)
  - roundDown
```
public static BigDecimal roundDown(BigDecimal value,
                                   int scale)
```
    另请参阅:
    
    BigDecimals.roundDown(BigDecimal, int)
  - decimalFormat
```
public static String decimalFormat(String pattern,
                                   double value)
```
    格式化double
    对 DecimalFormat 做封装
    参数:
    pattern - 格式格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。
    
    0 =》取一位整数
    
    0.00 =》取一位整数和两位小数
    
    00.000 =》取两位整数和三位小数
    
    # =》取所有整数部分
    
    #.##% =》以百分比方式计数，并取两位小数
    
    #.#####E0 =》显示为科学计数法，并取五位小数
    
    ,### =》每三位以逗号进行分隔，例如：299,792,458
    
    光速大小为每秒,###米 =》将格式嵌入文本
    value - 值
    
    返回:
    
    格式化后的值
  - decimalFormat
```
public static String decimalFormat(String pattern,
                                   long value)
```
    格式化double
    对 DecimalFormat 做封装
    参数:
    pattern - 格式格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。
    
    0 =》取一位整数
    
    0.00 =》取一位整数和两位小数
    
    00.000 =》取两位整数和三位小数
    
    # =》取所有整数部分
    
    #.##% =》以百分比方式计数，并取两位小数
    
    #.#####E0 =》显示为科学计数法，并取五位小数
    
    ,### =》每三位以逗号进行分隔，例如：299,792,458
    
    光速大小为每秒,###米 =》将格式嵌入文本
    value - 值
    
    返回:
    
    格式化后的值
  - decimalFormat
```
public static String decimalFormat(String pattern,
                                   Object value)
```
    格式化double
    对 DecimalFormat 做封装
    参数:
    pattern - 格式格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。
    
    0 =》取一位整数
    
    0.00 =》取一位整数和两位小数
    
    00.000 =》取两位整数和三位小数
    
    # =》取所有整数部分
    
    #.##% =》以百分比方式计数，并取两位小数
    
    #.#####E0 =》显示为科学计数法，并取五位小数
    
    ,### =》每三位以逗号进行分隔，例如：299,792,458
    
    光速大小为每秒,###米 =》将格式嵌入文本
    value - 值，支持BigDecimal、BigInteger、Number等类型
    
    返回:
    
    格式化后的值
  - decimalFormat
```
public static String decimalFormat(String pattern,
                                   Object value,
                                   RoundingMode roundingMode)
```
    格式化double
    对 DecimalFormat 做封装
    参数:
    pattern - 格式格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。
    
    0 =》取一位整数
    
    0.00 =》取一位整数和两位小数
    
    00.000 =》取两位整数和三位小数
    
    # =》取所有整数部分
    
    #.##% =》以百分比方式计数，并取两位小数
    
    #.#####E0 =》显示为科学计数法，并取五位小数
    
    ,### =》每三位以逗号进行分隔，例如：299,792,458
    
    光速大小为每秒,###米 =》将格式嵌入文本
    value - 值，支持BigDecimal、BigInteger、Number等类型
    
    roundingMode - 保留小数的方式枚举
    
    返回:
    
    格式化后的值
  - decimalFormatMoney
```
public static String decimalFormatMoney(double value)
```
    格式化金额输出，每三位用逗号分隔
    
    参数:
    
    value - 金额
    
    返回:
    
    格式化后的值
  - formatPercent
```
public static String formatPercent(double number,
                                   int scale)
```
    格式化百分比，小数采用四舍五入方式
    
    参数:
    
    number - 值
    
    scale - 保留小数位数
    
    返回:
    
    百分比
  - isNumber
```
public static boolean isNumber(CharSequence str)
```
    是否为数字，支持包括：
```
 1、10进制
 2、16进制数字（0x开头）
 3、科学计数法形式（1234E3）
 4、类型标识形式（123D）
 5、正负数标识形式（+123、-234）
 
```
    参数:
    
    str - 字符串值
    
    返回:
    
    是否为数字
  - isInteger
```
public static boolean isInteger(String s)
```
    判断String是否是整数
    支持10进制
    
    参数:
    
    s - String
    
    返回:
    
    是否为整数
  - isLong
```
public static boolean isLong(String s)
```
    判断字符串是否是Long类型
    支持10进制
    
    参数:
    
    s - String
    
    返回:
    
    是否为Long类型
  - isDouble
```
public static boolean isDouble(String s)
```
    判断字符串是否是浮点数
    
    参数:
    
    s - String
    
    返回:
    
    是否为Double类型
  - isPrime
```
public static boolean isPrime(int n)
```
    是否是质数（素数）
    质数表的质数又称素数。指整数在一个大于1的自然数中,除了1和此整数自身外,没法被其他自然数整除的数。
    
    参数:
    
    n - 数字
    
    返回:
    
    是否是质数
  - generateRandomNumber
```
public static int[] generateRandomNumber(int begin,
                                         int end,
                                         int size)
```
    生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
    
    参数:
    
    begin - 最小数字（包含该数）
    
    end - 最大数字（不包含该数）
    
    size - 指定产生随机数的个数
    
    返回:
    
    随机int数组
  - generateRandomNumber
```
public static int[] generateRandomNumber(int begin,
                                         int end,
                                         int size,
                                         int[] seed)
```
    生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
    
    参数:
    
    begin - 最小数字（包含该数）
    
    end - 最大数字（不包含该数）
    
    size - 指定产生随机数的个数
    
    seed - 种子，用于取随机数的int池
    
    返回:
    
    随机int数组
  - generateBySet
```
public static Integer[] generateBySet(int begin,
                                      int end,
                                      int size)
```
    生成不重复随机数根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
    
    参数:
    
    begin - 最小数字（包含该数）
    
    end - 最大数字（不包含该数）
    
    size - 指定产生随机数的个数
    
    返回:
    
    随机int数组
  - range
```
public static int[] range(int stop)
```
    从0开始给定范围内的整数列表，步进为1
    
    参数:
    
    stop - 结束（包含）
    
    返回:
    
    整数列表
  - range
```
public static int[] range(int start,
                          int stop)
```
    给定范围内的整数列表，步进为1
    
    参数:
    
    start - 开始（包含）
    
    stop - 结束（包含）
    
    返回:
    
    整数列表
  - range
```
public static int[] range(int start,
                          int stop,
                          int step)
```
    给定范围内的整数列表
    
    参数:
    
    start - 开始（包含）
    
    stop - 结束（包含）
    
    step - 步进
    
    返回:
    
    整数列表
  - appendRange
```
public static Collection<Integer> appendRange(int start,
                                              int stop,
                                              Collection<Integer> values)
```
    将给定范围内的整数添加到已有集合中，步进为1
    
    参数:
    
    start - 开始（包含）
    
    stop - 结束（包含）
    
    values - 集合
    
    返回:
    
    集合
  - appendRange
```
public static Collection<Integer> appendRange(int start,
                                              int stop,
                                              int step,
                                              Collection<Integer> values)
```
    将给定范围内的整数添加到已有集合中
    
    参数:
    
    start - 开始（包含）
    
    stop - 结束（包含）
    
    step - 步进
    
    values - 集合
    
    返回:
    
    集合
  - factorial
```
public static BigInteger factorial(BigInteger n)
```
    计算阶乘
    n! = n * (n-1) * ... * 2 * 1
    
    参数:
    
    n - 阶乘起始
    
    返回:
    
    结果
  - factorial
```
public static BigInteger factorial(BigInteger start,
                                   BigInteger end)
```
    计算范围阶乘
    factorial(start, end) = start * (start - 1) * ... * (end + 1)
    
    参数:
    
    start - 阶乘起始（包含）
    
    end - 阶乘结束，必须小于起始（不包括）
    
    返回:
    
    结果
  - factorial
```
public static long factorial(long start,
                             long end)
```
    计算范围阶乘
    factorial(start, end) = start * (start - 1) * ... * (end + 1)
    
    参数:
    
    start - 阶乘起始（包含）
    
    end - 阶乘结束，必须小于起始（不包括）
    
    返回:
    
    结果
  - factorial
```
public static long factorial(long n)
```
    计算阶乘
    n! = n * (n-1) * ... * 2 * 1
    
    参数:
    
    n - 阶乘起始
    
    返回:
    
    结果
  - sqrt
```
public static long sqrt(long x)
```
    平方根算法
    推荐使用 Math.sqrt(double)
    
    参数:
    
    x - 值
    
    返回:
    
    平方根
  - processMultiple
```
public static int processMultiple(int selectNum,
                                  int minNum)
```
    可以用于计算双色球、大乐透注数的方法
    比如大乐透35选5可以这样调用processMultiple(7,5); 就是数学中的：C75=7*6/2*1
    
    参数:
    
    selectNum - 选中小球个数
    
    minNum - 最少要选中多少个小球
    
    返回:
    
    注数
  - divisor
```
public static int divisor(int m,
                          int n)
```
    最大公约数
    
    参数:
    
    m - 第一个值
    
    n - 第二个值
    
    返回:
    
    最大公约数
  - multiple
```
public static int multiple(int m,
                           int n)
```
    最小公倍数
    
    参数:
    
    m - 第一个值
    
    n - 第二个值
    
    返回:
    
    最小公倍数
  - compare
```
public static int compare(char x,
                          char y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回小于0的数，x>y返回大于0的数
    
    另请参阅:
    
    Character.compare(char, char)
  - compare
```
public static int compare(double x,
                          double y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回小于0的数，x>y返回大于0的数
    
    另请参阅:
    
    Double.compare(double, double)
  - compare
```
public static int compare(int x,
                          int y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回小于0的数，x>y返回大于0的数
    
    另请参阅:
    
    Integer.compare(int, int)
  - compare
```
public static int compare(long x,
                          long y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回小于0的数，x>y返回大于0的数
    
    另请参阅:
    
    Long.compare(long, long)
  - compare
```
public static int compare(short x,
                          short y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回小于0的数，x>y返回大于0的数
    
    另请参阅:
    
    Short.compare(short, short)
  - compare
```
public static int compare(byte x,
                          byte y)
```
    比较两个值的大小
    
    参数:
    
    x - 第一个值
    
    y - 第二个值
    
    返回:
    
    x==y返回0，x<y返回-1，x>y返回1
    
    另请参阅:
    
    Byte.compare(byte, byte)
  - isGreater
```
public static boolean isGreater(BigDecimal bigNum1,
                                BigDecimal bigNum2)
```
    比较大小，参数1 > 参数2 返回true
    
    参数:
    
    bigNum1 - 数字1
    
    bigNum2 - 数字2
    
    返回:
    
    是否大于
  - isGreaterOrEqual
```
public static boolean isGreaterOrEqual(BigDecimal bigNum1,
                                       BigDecimal bigNum2)
```
    比较大小，参数1 >= 参数2 返回true
    
    参数:
    
    bigNum1 - 数字1
    
    bigNum2 - 数字2
    
    返回:
    
    是否大于等于
  - isLess
```
public static boolean isLess(BigDecimal bigNum1,
                             BigDecimal bigNum2)
```
    比较大小，参数1 < 参数2 返回true
    
    参数:
    
    bigNum1 - 数字1
    
    bigNum2 - 数字2
    
    返回:
    
    是否小于
  - isLessOrEqual
```
public static boolean isLessOrEqual(BigDecimal bigNum1,
                                    BigDecimal bigNum2)
```
    比较大小，参数1<=参数2 返回true
    
    参数:
    
    bigNum1 - 数字1
    
    bigNum2 - 数字2
    
    返回:
    
    是否小于等于
  - isIn
```
public static boolean isIn(BigDecimal value,
                           BigDecimal minInclude,
                           BigDecimal maxInclude)
```
    检查值是否在指定范围内
    
    参数:
    
    value - 值
    
    minInclude - 最小值（包含）
    
    maxInclude - 最大值（包含）
    
    返回:
    
    经过检查后的值
  - equals
```
public static boolean equals(double num1,
                             double num2)
```
    比较大小，值相等返回true
    此方法通过调用Double.doubleToLongBits(double)方法来判断是否相等
    此方法判断值相等时忽略精度的，即0.00 == 0
    
    参数:
    
    num1 - 数字1
    
    num2 - 数字2
    
    返回:
    
    是否相等
  - equals
```
public static boolean equals(float num1,
                             float num2)
```
    比较大小，值相等返回true
    此方法通过调用Float.floatToIntBits(float)方法来判断是否相等
    此方法判断值相等时忽略精度的，即0.00 == 0
    
    参数:
    
    num1 - 数字1
    
    num2 - 数字2
    
    返回:
    
    是否相等
  - equals
```
public static boolean equals(long num1,
                             long num2)
```
    比较大小，值相等返回true
    此方法修复传入long型数据由于没有本类型重载方法,导致数据精度丢失
    
    参数:
    
    num1 - 数字1
    
    num2 - 数字2
    
    返回:
    
    是否相等
  - equals
```
public static boolean equals(Number number1,
                             Number number2)
```
    比较数字值是否相等，相等返回true
    需要注意的是BigDecimal需要特殊处理
    BigDecimal使用compareTo方式判断，因为使用equals方法也判断小数位数，如2.0和2.00就不相等，
    此方法判断值相等时忽略精度的，即0.00 == 0
    - 如果用户提供两个Number都是BigDecimal，则通过调用BigDecimal.compareTo(BigDecimal)方法来判断是否相等
    - 其他情况调用Object.equals(Object)比较
    参数:
    
    number1 - 数字1
    
    number2 - 数字2
    
    返回:
    
    是否相等
    
    另请参阅:
    
    Objects.equals(Object, Object)
  - equals
```
public static boolean equals(BigDecimal bigNum1,
                             BigDecimal bigNum2)
```
    比较大小，值相等返回true
    此方法通过调用BigDecimal.compareTo(BigDecimal)方法来判断是否相等
    此方法判断值相等时忽略精度的，即0.00 == 0
    
    参数:
    
    bigNum1 - 数字1
    
    bigNum2 - 数字2
    
    返回:
    
    是否相等
  - equals
```
public static boolean equals(char c1,
                             char c2,
                             boolean ignoreCase)
```
    比较两个字符是否相同
    
    参数:
    
    c1 - 字符1
    
    c2 - 字符2
    
    ignoreCase - 是否忽略大小写
    
    返回:
    
    是否相同
    
    另请参阅:
    
    Chars.equals(char, char, boolean)
  - min
```
public static <T extends Comparable<? super T>> T min(T[] numberArray)
```
    取最小值
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    ObjectArrays.min(Comparable[])
  - min
```
public static long min(long... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    PrimitiveArrays.min(long...)
  - min
```
public static int min(int... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    PrimitiveArrays.min(int...)
  - min
```
public static short min(short... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    PrimitiveArrays.min(short...)
  - min
```
public static double min(double... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    PrimitiveArrays.min(double...)
  - min
```
public static float min(float... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    PrimitiveArrays.min(float...)
  - min
```
public static BigDecimal min(BigDecimal... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    另请参阅:
    
    ObjectArrays.min(Comparable[])
  - max
```
public static <T extends Comparable<? super T>> T max(T[] numberArray)
```
    取最大值
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    ObjectArrays.max(Comparable[])
  - max
```
public static long max(long... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    PrimitiveArrays.max(long...)
  - max
```
public static int max(int... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    PrimitiveArrays.max(int...)
  - max
```
public static short max(short... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    PrimitiveArrays.max(short...)
  - max
```
public static double max(double... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    PrimitiveArrays.max(double...)
  - max
```
public static float max(float... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    PrimitiveArrays.max(float...)
  - max
```
public static BigDecimal max(BigDecimal... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    另请参阅:
    
    ObjectArrays.max(Comparable[])
  - toBinaryString
```
public static String toBinaryString(Number number)
```
    获得数字对应的二进制字符串
    
    参数:
    
    number - 数字
    
    返回:
    
    二进制字符串
  - toString
```
public static String toString(Number number,
                              String defaultValue)
```
    数字转字符串
    调用Object.toString()，并去除尾小数点儿后多余的0
    
    参数:
    
    number - A Number
    
    defaultValue - 如果number参数为null，返回此默认值
    
    返回:
    
    A String.
  - toString
```
public static String toString(Number number)
```
    数字转字符串
    调用Object.toString()或 BigDecimal.toPlainString()，并去除尾小数点儿后多余的0
    
    参数:
    
    number - A Number
    
    返回:
    
    A String.
  - toString
```
public static String toString(Number number,
                              boolean isStripTrailingZeros)
```
    数字转字符串
    调用Object.toString()或 BigDecimal.toPlainString()，并去除尾小数点儿后多余的0
    
    参数:
    
    number - A Number
    
    isStripTrailingZeros - 是否去除末尾多余0，例如5.0返回5
    
    返回:
    
    A String.
  - toString
```
public static String toString(BigDecimal bigDecimal)
```
  - toString
```
public static String toString(BigDecimal bigDecimal,
                              boolean isStripTrailingZeros)
```
  - toBigDecimal
```
public static BigDecimal toBigDecimal(Number number)
```
  - toBigDecimal
```
public static BigDecimal toBigDecimal(String numberStr)
```
  - toBigInteger
```
public static BigInteger toBigInteger(Number number)
```
  - toBigInteger
```
public static BigInteger toBigInteger(String number)
```
  - newBigInteger
```
public static BigInteger newBigInteger(String str)
```
  - parseInt
```
public static int parseInt(String number)
                    throws NumberFormatException
```
    解析转换数字字符串为int型数字，规则如下：
```
 1、0x开头的视为16进制数字
 2、0开头的忽略开头的0
 3、其它情况按照10进制转换
 4、空串返回0
 5、.123形式返回0（按照小于0的小数对待）
 6、123.56截取小数点之前的数字，忽略小数部分
 
```
    参数:
    
    number - 数字，支持0x开头、0开头和普通十进制
    
    返回:
    
    int
    
    抛出:
    
    NumberFormatException - 数字格式异常
  - parseLong
```
public static long parseLong(String number)
```
    解析转换数字字符串为long型数字，规则如下：
```
 1、0x开头的视为16进制数字
 2、0开头的忽略开头的0
 3、空串返回0
 4、其它情况按照10进制转换
 5、.123形式返回0（按照小于0的小数对待）
 6、123.56截取小数点之前的数字，忽略小数部分
 
```
    参数:
    
    number - 数字，支持0x开头、0开头和普通十进制
    
    返回:
    
    long
  - parseFloat
```
public static float parseFloat(String number)
```
    解析转换数字字符串为long型数字，规则如下：
```
 1、0开头的忽略开头的0
 2、空串返回0
 3、其它情况按照10进制转换
 4、.123形式返回0.123（按照小于0的小数对待）
 
```
    参数:
    
    number - 数字，支持0x开头、0开头和普通十进制
    
    返回:
    
    long
  - parseDouble
```
public static double parseDouble(String number)
```
    解析转换数字字符串为long型数字，规则如下：
```
 1、0开头的忽略开头的0
 2、空串返回0
 3、其它情况按照10进制转换
 4、.123形式返回0.123（按照小于0的小数对待）
 
```
    参数:
    
    number - 数字，支持0x开头、0开头和普通十进制
    
    返回:
    
    long
  - parseNumber
```
public static Number parseNumber(String numberStr)
                          throws NumberFormatException
```
    将指定字符串转换为Number 对象
    此方法不支持科学计数法
    需要注意的是，在不同Locale下，数字的表示形式也是不同的，例如：
    德国、荷兰、比利时、丹麦、意大利、罗马尼亚和欧洲大多地区使用`,`区分小数
    也就是说，在这些国家地区，1.20表示120，而非1.2。
    
    参数:
    
    numberStr - Number字符串
    
    返回:
    
    Number对象
    
    抛出:
    
    NumberFormatException - 包装了ParseException，当给定的数字字符串无法解析时抛出
  - parseInt
```
public static Integer parseInt(String numberStr,
                               Integer defaultValue)
```
    解析转换数字字符串为 Integer 规则如下：
```
 1、0x开头的视为16进制数字
 2、0开头的忽略开头的0
 3、其它情况按照10进制转换
 4、空串返回0
 5、.123形式返回0（按照小于0的小数对待）
 6、123.56截取小数点之前的数字，忽略小数部分
 7、解析失败返回默认值
 
```
    参数:
    
    numberStr - 数字字符串，支持0x开头、0开头和普通十进制
    
    defaultValue - 如果解析失败, 将返回defaultValue, 允许null
    
    返回:
    
    Integer
  - parseLong
```
public static Long parseLong(String numberStr,
                             Long defaultValue)
```
    解析转换数字字符串为 Long 规则如下：
```
 1、0x开头的视为16进制数字
 2、0开头的忽略开头的0
 3、其它情况按照10进制转换
 4、空串返回0
 5、.123形式返回0（按照小于0的小数对待）
 6、123.56截取小数点之前的数字，忽略小数部分
 7、解析失败返回默认值
 
```
    参数:
    
    numberStr - 数字字符串，支持0x开头、0开头和普通十进制
    
    defaultValue - 如果解析失败, 将返回defaultValue, 允许null
    
    返回:
    
    Long
  - parseFloat
```
public static Float parseFloat(String numberStr,
                               Float defaultValue)
```
    解析转换数字字符串为 Float 规则如下：
```
 1、0开头的忽略开头的0
 2、空串返回0
 3、其它情况按照10进制转换
 4、.123形式返回0.123（按照小于0的小数对待）
 
```
    参数:
    
    numberStr - 数字字符串，支持0x开头、0开头和普通十进制
    
    defaultValue - 如果解析失败, 将返回defaultValue, 允许null
    
    返回:
    
    Float
  - parseDouble
```
public static Double parseDouble(String numberStr,
                                 Double defaultValue)
```
    解析转换数字字符串为 Double 规则如下：
```
 1、0开头的忽略开头的0
 2、空串返回0
 3、其它情况按照10进制转换
 4、.123形式返回0.123（按照小于0的小数对待）
 
```
    参数:
    
    numberStr - 数字字符串，支持0x开头、0开头和普通十进制
    
    defaultValue - 如果解析失败, 将返回defaultValue, 允许null
    
    返回:
    
    Double
  - parseNumber
```
public static Number parseNumber(String numberStr,
                                 Number defaultValue)
```
    将指定字符串转换为Number 此方法不支持科学计数法
    
    参数:
    
    numberStr - Number字符串
    
    defaultValue - 如果解析失败, 将返回defaultValue, 允许null
    
    返回:
    
    Number对象
  - toBytes
```
public static byte[] toBytes(int value)
```
  - toInt
```
public static int toInt(byte[] bytes)
```
  - toUnsignedByteArray
```
public static byte[] toUnsignedByteArray(BigInteger value)
```
  - toUnsignedByteArray
```
public static byte[] toUnsignedByteArray(int length,
                                         BigInteger value)
```
  - fromUnsignedByteArray
```
public static BigInteger fromUnsignedByteArray(byte[] buf)
```
  - fromUnsignedByteArray
```
public static BigInteger fromUnsignedByteArray(byte[] buf,
                                               int off,
                                               int length)
```
  - toDouble
```
public static double toDouble(Number value)
```
    Number值转换为double
    float强制转换存在精度问题，此方法避免精度丢失
    
    参数:
    
    value - 被转换的float值
    
    返回:
    
    double值
  - isBeside
```
public static boolean isBeside(long number1,
                               long number2)
```
    判断两个数字是否相邻，例如1和2相邻，1和3不相邻
    判断方法为做差取绝对值判断是否为1
    
    参数:
    
    number1 - 数字1
    
    number2 - 数字2
    
    返回:
    
    是否相邻
  - isBeside
```
public static boolean isBeside(int number1,
                               int number2)
```
    判断两个数字是否相邻，例如1和2相邻，1和3不相邻
    判断方法为做差取绝对值判断是否为1
    
    参数:
    
    number1 - 数字1
    
    number2 - 数字2
    
    返回:
    
    是否相邻
  - partValue
```
public static int partValue(int total,
                            int partCount)
```
    把给定的总数平均分成N份，返回每份的个数
    当除以分数有余数时每份+1
    
    参数:
    
    total - 总数
    
    partCount - 份数
    
    返回:
    
    每份的个数
  - partValue
```
public static int partValue(int total,
                            int partCount,
                            boolean isPlusOneWhenHasRem)
```
    把给定的总数平均分成N份，返回每份的个数
    如果isPlusOneWhenHasRem为true，则当除以分数有余数时每份+1，否则丢弃余数部分
    
    参数:
    
    total - 总数
    
    partCount - 份数
    
    isPlusOneWhenHasRem - 在有余数时是否每份+1
    
    返回:
    
    每份的个数
  - isPowerOfTwo
```
public static boolean isPowerOfTwo(long n)
```
    判断一个整数是否是2的幂
    
    参数:
    
    n - 待验证的整数
    
    返回:
    
    如果n是2的幂返回true, 反之返回false
  - isValidNumber
```
public static boolean isValidNumber(Number number)
```
    检查是否为有效的数字
    检查Double和Float是否为无限大，或者Not a Number
    非数字类型和Null将返回true
    
    参数:
    
    number - 被检查类型
    
    返回:
    
    检查结果，非数字类型和Null将返回true
  - isValid
```
public static boolean isValid(double number)
```
    检查是否为有效的数字
    检查double否为无限大，或者Not a Number（NaN）
    
    参数:
    
    number - 被检查double
    
    返回:
    
    检查结果
  - isValid
```
public static boolean isValid(float number)
```
    检查是否为有效的数字
    检查double否为无限大，或者Not a Number（NaN）
    
    参数:
    
    number - 被检查double
    
    返回:
    
    检查结果
  - isOdd
```
public static boolean isOdd(int num)
```
    检查是否为奇数
    
    参数:
    
    num - 被判断的数值
    
    返回:
    
    是否是奇数
  - isEven
```
public static boolean isEven(int num)
```
    检查是否为偶数
    
    参数:
    
    num - 被判断的数值
    
    返回:
    
    是否是偶数

类 Numbers

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

Numbers

方法详细资料

calculate

floorDiv

floorDiv

ceilDiv

ceilDiv

pow

pow

add

add

add

add

add

add

add

add

add

sub

sub

sub

sub

sub

sub

sub

sub

sub

mul

mul

mul

mul

mul

mul

mul

mul

mul

mul

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

div

round

roundStr

round

round

round

roundStr

round

round

roundHalfEven

roundHalfEven

roundDown

roundDown

decimalFormat

decimalFormat

decimalFormat

decimalFormat