指南
核心(hutool-core)
数字数学(math)

NumberUtil

NumberUtil是Hutool中用于处理数字的核心工具类，提供了丰富的数字处理功能，包括精确计算、数字转换、格式化、统计分析等。

# 主要功能

精确计算：加法、减法、乘法、除法等精确运算
数字转换：字符串转数字、数字转字符串、进制转换
数字格式化：中文数字、英文数字、罗马数字、金额格式化
统计分析：平均值、方差、标准差、最大值、最小值等
数字验证：判断是否为数字、整数、小数等
数字比较：大小比较、范围判断
特殊数值处理：分数、金额等

# 精确计算

# add(Number... values)

提供精确的加法运算。

BigDecimal sum = NumberUtil.add(1.23, 4.56, 7.89);
// 输出: 13.68

# sub(Number... values)

提供精确的减法运算。

BigDecimal diff = NumberUtil.sub(10.0, 1.23, 4.56);
// 输出: 4.21

# mul(Number... values)

提供精确的乘法运算。

BigDecimal product = NumberUtil.mul(2.5, 4.0, 2.0);
// 输出: 20.0

# div(Number dividend, Number divisor)

提供精确的除法运算，默认保留10位小数。

BigDecimal quotient = NumberUtil.div(10.0, 3.0);
// 输出: 3.3333333333

// 自定义保留小数位数
BigDecimal quotient2 = NumberUtil.div(10.0, 3.0, 2);
// 输出: 3.33

# div(Number dividend, Number divisor, int scale, RoundingMode roundingMode)

提供精确的除法运算，自定义保留小数位数和舍入模式。

BigDecimal quotient = NumberUtil.div(10.0, 3.0, 2, RoundingMode.UP);
// 输出: 3.34

# 数字转换

# parseInt(String str)

将字符串转换为int类型。

int num = NumberUtil.parseInt("123");
// 输出: 123

# parseDouble(String str)

将字符串转换为double类型。

double d = NumberUtil.parseDouble("123.456");
// 输出: 123.456

# toBigDecimal(Object obj)

将对象转换为BigDecimal类型。

BigDecimal bd1 = NumberUtil.toBigDecimal(123);
BigDecimal bd2 = NumberUtil.toBigDecimal("123.456");
BigDecimal bd3 = NumberUtil.toBigDecimal(123.456);

# toString(Number number)

将数字转换为字符串。

String str = NumberUtil.toString(123.456);
// 输出: "123.456"

# toString(Number number, int scale)

将数字转换为字符串，保留指定小数位数。

String str = NumberUtil.toString(123.456, 2);
// 输出: "123.46"

# 进制转换

# toHex(int num)

将十进制数转换为十六进制字符串。

String hex = NumberUtil.toHex(123);
// 输出: "7b"

# toBinary(int num)

将十进制数转换为二进制字符串。

String binary = NumberUtil.toBinary(123);
// 输出: "1111011"

# toOctal(int num)

将十进制数转换为八进制字符串。

String octal = NumberUtil.toOctal(123);
// 输出: "173"

# toInt(String str, int radix)

将指定进制的字符串转换为十进制整数。

int decimal = NumberUtil.toInt("7b", 16);
// 输出: 123

int decimal2 = NumberUtil.toInt("1111011", 2);
// 输出: 123

# 数字格式化

# formatChinese(long num)

将数字格式化为中文数字。

String chinese = NumberUtil.formatChinese(123);
// 输出: "一百二十三"

String chinese2 = NumberUtil.formatChinese(1001);
// 输出: "一千零一"

# formatChineseMoney(double money)

将数字格式化为中文金额。

String chineseMoney = NumberUtil.formatChineseMoney(123.45);
// 输出: "壹佰贰拾叁元肆角伍分"

String chineseMoney2 = NumberUtil.formatChineseMoney(1000.01);
// 输出: "壹仟元零壹分"

# formatEnglish(long num)

将数字格式化为英文数字。

String english = NumberUtil.formatEnglish(123);
// 输出: "one hundred and twenty-three"

# formatRoman(int num)

将数字格式化为罗马数字。

String roman = NumberUtil.formatRoman(123);
// 输出: "CXXIII"

# formatPercent(double value, int scale)

将数字格式化为百分比字符串。

String percent = NumberUtil.formatPercent(0.1234, 2);
// 输出: "12.34%"

# 统计分析

# avg(Collection<? extends Number> values)

计算平均值。

List<Double> list = ListUtil.of(1.0, 2.0, 3.0, 4.0, 5.0);
double avg = NumberUtil.avg(list);
// 输出: 3.0

# sum(Collection<? extends Number> values)

计算总和。

List<Double> list = ListUtil.of(1.0, 2.0, 3.0, 4.0, 5.0);
double sum = NumberUtil.sum(list);
// 输出: 15.0

# max(Collection<? extends Number> values)

计算最大值。

List<Double> list = ListUtil.of(1.0, 5.0, 3.0, 4.0, 2.0);
double max = NumberUtil.max(list);
// 输出: 5.0

# min(Collection<? extends Number> values)

计算最小值。

List<Double> list = ListUtil.of(1.0, 5.0, 3.0, 4.0, 2.0);
double min = NumberUtil.min(list);
// 输出: 1.0

# variance(Collection<? extends Number> values)

计算方差。

List<Double> list = ListUtil.of(1.0, 2.0, 3.0, 4.0, 5.0);
double variance = NumberUtil.variance(list);
// 输出: 2.5

# standardDeviation(Collection<? extends Number> values)

计算标准差。

List<Double> list = ListUtil.of(1.0, 2.0, 3.0, 4.0, 5.0);
double stdDev = NumberUtil.standardDeviation(list);
// 输出: 1.5811388300841898

# 数字验证

# isNumber(String str)

判断字符串是否为数字。

boolean isNum = NumberUtil.isNumber("123");
// 输出: true

boolean isNum2 = NumberUtil.isNumber("123.45");
// 输出: true

boolean isNum3 = NumberUtil.isNumber("abc");
// 输出: false

# isInteger(String str)

判断字符串是否为整数。

boolean isInt = NumberUtil.isInteger("123");
// 输出: true

boolean isInt2 = NumberUtil.isInteger("123.45");
// 输出: false

# isDouble(String str)

判断字符串是否为小数。

boolean isDouble = NumberUtil.isDouble("123.45");
// 输出: true

boolean isDouble2 = NumberUtil.isDouble("123");
// 输出: false

# isOdd(int num)

判断是否为奇数。

boolean isOdd = NumberUtil.isOdd(123);
// 输出: true

# isEven(int num)

判断是否为偶数。

boolean isEven = NumberUtil.isEven(124);
// 输出: true

# 数字比较

# compare(Number num1, Number num2)

比较两个数字的大小。

int compareResult = NumberUtil.compare(123, 456);
// 输出: -1 (表示123 < 456)

int compareResult2 = NumberUtil.compare(456, 123);
// 输出: 1 (表示456 > 123)

int compareResult3 = NumberUtil.compare(123, 123);
// 输出: 0 (表示123 == 123)

# between(Number num, Number min, Number max)

判断数字是否在指定范围内。

boolean isBetween = NumberUtil.between(5, 1, 10);
// 输出: true

boolean isBetween2 = NumberUtil.between(15, 1, 10);
// 输出: false

# isZero(Number num)

判断数字是否为0。

boolean isZero = NumberUtil.isZero(0);
// 输出: true

boolean isZero2 = NumberUtil.isZero(0.0);
// 输出: true

boolean isZero3 = NumberUtil.isZero(1.0);
// 输出: false

# 特殊数值处理

# toFraction(String value)

将字符串转换为分数。

Fraction fraction = NumberUtil.toFraction("0.5");
// 输出: 1/2

Fraction fraction2 = NumberUtil.toFraction("1.25");
// 输出: 5/4

# toFraction(double value)

将double转换为分数。

Fraction fraction = NumberUtil.toFraction(0.75);
// 输出: 3/4

# createMoney(String money)

创建金额对象。

Money money = NumberUtil.createMoney("123.45");
// 输出: 123.45

# 数字生成

# randomInt(int min, int max)

生成指定范围内的随机整数。

int random = NumberUtil.randomInt(1, 100);
// 输出: 1-100之间的随机整数

# randomDouble(double min, double max, int scale)

生成指定范围内的随机小数，保留指定小数位数。

double random = NumberUtil.randomDouble(1.0, 10.0, 2);
// 输出: 1.00-10.00之间的随机小数，保留两位小数

# sequence(long start, long end)

生成指定范围内的连续整数列表。

List<Long> sequence = NumberUtil.sequence(1, 5);
// 输出: [1, 2, 3, 4, 5]

# 注意事项

精确计算：对于需要精确计算的场景，建议使用BigDecimal类型，避免浮点数精度问题。
性能考虑：某些复杂的计算（如方差、标准差）可能会消耗较多资源，对于大数据量应考虑性能影响。
数字格式化：不同的格式化方法适用于不同场景，如中文数字适合中文环境，罗马数字适合特殊展示需求。
进制转换：进制转换仅支持整数类型，不支持小数。
随机数生成：randomInt和randomDouble方法使用的是Java的Random类，如需更高安全性，建议使用SecureRandom。

# 总结

NumberUtil提供了丰富的数字处理功能，涵盖了从基础的数字转换、格式化到复杂的数学计算、统计分析等多个方面。通过使用NumberUtil，可以大大简化Java中的数字处理，提高开发效率，同时避免常见的数字处理问题（如浮点数精度问题）。

无论是金融计算、数据分析还是日常开发，NumberUtil都能提供简洁高效的解决方案。

← 数字数学 MathUtil→