【Java基础教程】（三十六）常用类库篇 · 第六讲：数学运算类——全面讲解Java数学计算支持类库，BigDecimal、Math、Random、DecimalFormat...~
Java基础教程之常用类库 · 数学运算类
- 1️⃣ 概念
-
-
- 数学运算类汇总
-
- 2️⃣ 优势和缺点
- 3️⃣ 使用
-
-
- 3.1 各数学计算支持类使用案例
- 3.2 Math类
- 3.3 BigDecimal类
- 3.4 Random类
- 3.5 DecimalFormat类
-
- 4️⃣ 应用场景
- 5️⃣ 使用技巧
- 总结
- 本文源码下载地址
1️⃣ 概念
在现代软件开发中，数学计算是不可或缺的一部分。为了满足企业及开发人员对数学运算的需求，Java 提供了一系列强大而丰富的数学计算相关类，其中包括Math、Random、BigDecimal等等。这些类旨在提供高度精确和可靠的数学操作，使开发人员能够处理任何规模和复杂度的定量问题。
数学运算类汇总
将Java中所有用于表示数学计算支持的类汇总，罗列如下表：
| 类名 | 描述 |
|---|---|
Math |
提供常用数学函数和运算符实现 |
BigDecimal |
支持高精度任意精度定点数计算 |
BigInteger |
支持高精度任意精度整数计算 |
StrictMath |
与Math类提供相同的方法，使用非严格浮点数语义 |
Random |
生成伪随机数序列 |
DecimalFormat |
格式化数字输出 |
MathContext |
提供精确的数学运算上下文环境 |
以上这些类在Java中提供了广泛的数学计算支持。它们可以执行各种数值计算和操作，包括三角函数、指数、对数、幂、绝对值、最大值、最小值等。
BigDecimal 和 BigInteger 类具有处理任意精度整数和定点数计算的能力，而 Random 类用于生成伪随机数。DecimalFormat 则用来格式化数字输出，MathContext 提供了精确的数学运算环境。这些类在各种场景下发挥重要作用，让开发人员能够进行精确和高效的数学计算。
在本文中，主要介绍最常用的Math 、BigDecimal、Random等类的使用及操作方式等相关知识。而其他类的详细操作方法API等信息，由于篇幅原因本文不再做更多介绍，感兴趣的朋友可私信我一起交流。
Math类是 Java 中的一个常见工具类，提供了许多静态方法来执行数学运算。它支持三角函数、指数、对数、幂、绝对值、最大值、最小值等常用运算。Math类使用基本的浮点数运算，适用于大多数简单的数学计算。BigDecimal类是 Java 中用于执行精确任意精度定点数计算的类。它可以处理极大和极小的数值，并提供高精度的计算结果。相比于Math类中的浮点数运算，BigDecimal可以保证运算结果的精度和准确性；Random类：用于生成伪随机数。它的设计目标是以可预测性和均匀分布性为基础，提供一种可靠的随机数生成方式。
2️⃣ 优势和缺点
Math类
- 优点：静态方法方便直接调用，不需要实例化对象；封装了常见的数学运算，提供了简便的操作。
- 缺点：基于基本浮点数运算，可能导致精度损失，所以不适用于高精度计算。
BigDecimal类
- 优点：提供任意精度的计算，避免了浮点数运算导致的精度损失；支持基本的算术运算、指数运算等功能。
- 缺点：内存占用较大，运算速度比基本数据类型慢。
Random类
- 优点：提供了一系列方法来生成随机数，其使用简单而直观。在一般情况下，随机数生成速度相对较快，适用于大多数应用场景。
- 缺点：生成的随机数序列实际上是一个确定性的算法产生的，因此完全依赖于初始种子值。如果种子值不足够随机，可能会导致生成的随机数序列呈现明显可预测的模式；生成的随机数序列不适合用于加密或安全目的。
3️⃣ 使用
3.1 各数学计算支持类使用案例
下面是一个示例程序，演示了如何使用Java中的一些数学计算支持类，包括：Math类、BigDecimal类、BigInteger类、Random类、DecimalFormat类、StrictMath类、MathContext类。代码都有解释说明，以便更好地理解其用法和功能：
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.text.DecimalFormat;
import java.util.Random;
public class MathSupportExample {
public static void main(String[] args) {
// Math 类示例
double squareRoot = Math.sqrt(16); // 计算平方根，结果为 4.0
System.out.println("Square root: " + squareRoot);
double power = Math.pow(2, 5); // 计算指数，结果为 32.0
System.out.println("Power: " + power);
int absValue = Math.abs(-10); // 计算绝对值，结果为 10
System.out.println("Absolute value: " + absValue);
double randomNum = Math.random(); // 生成介于 [0,1) 的随机浮点数
System.out.println("Random number: " + randomNum);
// BigDecimal 类示例
BigDecimal bigDecimal1 = new BigDecimal("10");
BigDecimal bigDecimal2 = new BigDecimal("3");
BigDecimal sum = bigDecimal1.add(bigDecimal2); // 相加，结果为 13
System.out.println("Sum: " + sum);
// BigInteger 类示例
BigInteger bigInteger1 = new BigInteger("10");
BigInteger bigInteger2 = new BigInteger("3");
BigInteger product = bigInteger1.multiply(bigInteger2); // 相乘，结果为 30
System.out.println("Product: " + product);
// Random 类示例
Random random = new Random();
int randInt = random.nextInt(100); // 生成 [0, 100) 范围内的随机整数
System.out.println("Random integer: " + randInt);
// DecimalFormat 类示例
DecimalFormat decimalFormat = new DecimalFormat("#0.00");
double value = 3.14159265;
String formattedValue = decimalFormat.format(value); // 格式化数字为指定格式
System.out.println("Formatted value: " + formattedValue);
// StrictMath 类示例
double sinValue = StrictMath.sin(Math.PI / 2); // 计算正弦值，结果为 1.0
System.out.println("Sine value: " + sinValue);
double expValue = StrictMath.exp(1); // 计算e的指数幂，结果为 2.718281828459045
System.out.println("Exponential value: " + expValue);
double maxNum = StrictMath.max(10, 5); // 比较两个数，返回较大值，结果为 10
System.out.println("Maximum number: " + maxNum);
// MathContext 类示例
BigDecimal bigDecimal = new BigDecimal("3.14159265359");
MathContext mathContext = new MathContext(4); // 设置精确度为4位
BigDecimal roundedValue = bigDecimal.round(mathContext); // 四舍五入至指定精确度，结果为 3.142
System.out.println("Rounded value: " + roundedValue);
}
}
此示例程序演示了如何使用Math类进行数学运算、BigDecimal和BigInteger类进行高精度计算、Random类生成伪随机数、DecimalFormat类格式化输出。
还展示了如何使用StrictMath类提供与Math类相同的方法，但使用非严格浮点数语义，如计算正弦值、指数函数和比较两个数。如何使用MathContext类来控制BigDecimal对象的精度。
运行结果如下：
Square root: 4.0
Power: 32.0
Absolute value: 10
Random number: 0.15580789544457363
Sum: 13
Product: 30
Random integer: 23
Formatted value: 3.14
Sine value: 1.0
Exponential value: 2.7182818284590455
Maximum number: 10.0
Rounded value: 3.142
3.2 Math类
Math类是Java中一个常用且便捷的数学支持类，它提供了基本的数学运算和常量，可以满足大多数的数学计算需求。
下面是Java的Math类中的全部操作方法API的简要介绍，以表格形式列举如下：
| 方法 | 描述 |
|---|---|
random() |
返回一个[0, 1)范围内的随机浮点数 |
round(float a) |
返回一个浮点数四舍五入为最接近的整数 |
round(double a) |
返回一个双精度浮点数四舍五入为最接近的整数 |
ceil(double a) |
返回大于或等于给定浮点数的最小整数 |
floor(double a) |
返回小于或等于给定浮点数的最大整数 |
max(int a, int b) |
返回两个整数中较大的那个值（方法重载，还支持操作：长整数、浮点数） |
min(int a, int b) |
返回两个整数中较小的那个值（方法重载，还支持操作：长整数、浮点数） |
| — | — |
abs(int a) |
返回一个整数的绝对值（方法重载，还支持操作：长整数、浮点数） |
exp(double a) |
返回指数函数 e x e^x ex 的值 |
log(double a) |
返回一个数的自然对数（以e为底） |
pow(double a, double b) |
返回一个数的指定次幂 |
sqrt(double a) |
返回一个数的平方根 |
| — | — |
sin(double a) |
返回一个角度的正弦函数值 |
cos(double a) |
返回一个角度的余弦函数值 |
tan(double a) |
返回一个角度的正切函数值 |
asin(double a) |
返回一个角度的反正弦函数值 |
acos(double a) |
返回一个角度的反余弦函数值 |
atan(double a) |
返回一个角度的反正切函数值 |
toDegrees(double angrad) |
将弧度转换为角度 |
toRadians(double angdeg) |
将角度转换为弧度 |
| — | — |
ulp(float f) |
返回浮点数的最小单位 |
ulp(double d) |
返回双精度浮点数的最小单位 |
下面是一个示例程序，演示了如何使用Math类中的一些方法：
import java.util.Random;
public class MathExample {
public static void main(String[] args) {
// random()
double randomValue = Math.random(); // 生成[0,1)范围内的随机浮点数
System.out.println("Random value: " + randomValue);
// round(double a)
double roundedValue = Math.round(3.7); // 四舍五入为最接近的整数，结果为4
System.out.println("Rounded value: " + roundedValue);
// ceil(double a)
double ceilValue = Math.ceil(3.2); // 返回大于或等于给定浮点数的最小整数，结果为4
System.out.println("Ceil value: " + ceilValue);
// floor(double a)
double floorValue = Math.floor(3.8); // 返回小于或等于给定浮点数的最大整数，结果为3
System.out.println("Floor value: " + floorValue);
// max(int a, int b)
int maxValue = Math.max(10, 7); // 返回两个整数中较大的那个值，结果为10
System.out.println("Max value: " + maxValue);
// min(int a, int b)
int minValue = Math.min(5, 3); // 返回两个整数中较小的那个值，结果为3
System.out.println("Min value: " + minValue);
// abs(int a)
int absoluteValue = Math.abs(-10); // 返回一个整数的绝对值，结果为10
System.out.println("Absolute value: " + absoluteValue);
// exp(double a)
double exponentialValue = Math.exp(1); // 计算e的指数幂，结果为2.718281828459045
System.out.println("Exponential value: " + exponentialValue);
// log(double a)
double logarithm = Math.log(Math.E); // 返回一个数的自然对数（以e为底），结果为1.0
System.out.println("Logarithm value: " + logarithm);
// pow(double a, double b)
double power = Math.pow(2, 3); // 返回一个数的指定次幂，结果为8.0
System.out.println("Power value: " + power);
// sqrt(double a)
double squareRoot = Math.sqrt(25); // 返回一个数的平方根，结果为5.0
System.out.println("Square root value: " + squareRoot);
// sin(double a)
double sineValue = Math.sin(Math.PI / 6); // 返回一个角度的正弦函数值，结果为0.5
System.out.println("Sine value: " + sineValue);
// asin(double a)
double arcsineValue = Math.asin(0.5); // 返回一个角度的反正弦函数值，结果为0.5235987755982989
System.out.println("Arcsine value: " + arcsineValue);
// toDegrees(double angrad)
double degrees = Math.toDegrees(Math.PI / 4); // 将弧度转换为角度，结果为45.0
System.out.println("Degrees value: " + degrees);
// toRadians(double angdeg)
double radians = Math.toRadians(90); // 将角度转换为弧度，结果为1.5707963267948966
System.out.println("Radians value: " + radians);
// ulp(float f)
float ulpValueFloat = Math.ulp(1.23f); // 返回浮点数的最小单位，结果为1.1920929E-7
System.out.println("Ulp value (float): " + ulpValueFloat);
// ulp(double d)
double ulpValueDouble = Math.ulp(1.23); // 返回双精度浮点数的最小单位，结果为2.220446049250313E-16
System.out.println("Ulp value (double): " + ulpValueDouble);
}
}
这个示例程序演示了如何使用Math类中的各种方法。它包括生成随机数、数值舍入四舍五入、向上取整和向下取整、比较两个数的大小、计算绝对值、指数函数、对数、幂函数、平方根、三角函数（正弦、反正弦）、角度和弧度之间的转换、浮点数最小单位等操作。这些方法可以在各种数学计算场景中使用，以满足不同的需求。
运行结果如下：
Random value: 0.7044894178514141
Rounded value: 4.0
Ceil value: 4.0
Floor value: 3.0
Max value: 10
Min value: 3
Absolute value: 10
Exponential value: 2.718281828459045
Logarithm value: 1.0
Power value: 8.0
Square root value: 5.0
Sine value: 0.49999999999999994
Arcsine value: 0.5235987755982989
Degrees value: 45.0
Radians value: 1.5707963267948966
Ulp value (float): 1.1920929E-7
Ulp value (double): 2.220446049250313E-16
3.3 BigDecimal类
BigDecimal类是Java中用于精确计算的高精度数值运算类。它提供了基本的数学运算操作，比如加法、减法、乘法、除法、取余、幂等等。在大数据计算和金融应用等场景中，BigDecimal类可以保证计算结果的精确性和准确性。
下面是BigDecimal类中的全部操作方法API的汇总介绍：
| 方法 | 描述 |
|---|---|
add(BigDecimal augend) |
将此BigDecimal与指定BigDecimal相加 |
subtract(BigDecimal subtrahend) |
从此BigDecimal中减去指定BigDecimal |
multiply(BigDecimal multiplicand) |
将此BigDecimal与指定BigDecimal相乘 |
divide(BigDecimal divisor) |
将此BigDecimal除以指定BigDecimal |
remainder(BigDecimal divisor) |
返回此BigDecimal除以指定BigDecimal的余数 |
pow(int n) |
返回此BigDecimal的n次幂 |
setScale(int newScale, RoundingMode roundingMode) |
将此BigDecimal的标度设置为指定值，并进行舍入操作 |
abs() |
返回此BigDecimal的绝对值 |
negate() |
返回此BigDecimal的相反数 |
compareTo(BigDecimal val) |
将此BigDecimal与指定BigDecimal进行比较，返回一个负整数、零或正整数 |
equals(Object x) |
检查此BigDecimal是否与指定对象相等 |
toString() |
将此BigDecimal转化为String |
下面是一个示例程序，演示了如何使用BigDecimal类中的各个方法：
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalExample {
public static void main(String[] args) {
// 创建BigDecimal实例
BigDecimal num1 = new BigDecimal("10.50");
BigDecimal num2 = new BigDecimal("5.25");
// add(BigDecimal augend)
BigDecimal sum = num1.add(num2); // 将num1与num2相加
System.out.println("Sum: " + sum);
// subtract(BigDecimal subtrahend)
BigDecimal difference = num1.subtract(num2); // 从num1中减去num2
System.out.println("Difference: " + difference);
// multiply(BigDecimal multiplicand)
BigDecimal product = num1.multiply(num2); // 将num1与num2相乘
System.out.println("Product: " + product);
// divide(BigDecimal divisor)
BigDecimal quotient = num1.divide(num2, 2, RoundingMode.HALF_UP); // 将num1除以num2（结果保留两位小数）
System.out.println("Quotient: " + quotient);
// remainder(BigDecimal divisor)
BigDecimal remainder = num1.remainder(num2); // 返回num1除以num2的余数
System.out.println("Remainder: " + remainder);
// pow(int n)
BigDecimal power = num1.pow(3); // 计算num1的3次幂
System.out.println("Power: " + power);
// setScale(int newScale, RoundingMode roundingMode)
BigDecimal scaledNum = num1.setScale(2, RoundingMode.HALF_UP); // 将num1的小数位数设置为2并进行四舍五入
System.out.println("Scaled number: " + scaledNum);
// abs()
BigDecimal absoluteValue = num1.abs(); // 获取num1的绝对值
System.out.println("Absolute value: " + absoluteValue);
// negate()
BigDecimal negatedValue = num1.negate(); // 获取num1的相反数
System.out.println("Negated value: " + negatedValue);
// compareTo(BigDecimal val)
int comparisonResult = num1.compareTo(num2); // 比较num1和num2的大小关系
if (comparisonResult == 0) {
System.out.println("Both numbers are equal");
} else if (comparisonResult < 0) {
System.out.println("Number 1 is less than Number 2");
} else {
System.out.println("Number 1 is greater than Number 2");
}
// equals(Object x)
boolean isEqual = num1.equals(num2); // 检查num1是否与num2相等
System.out.println("Is equal? " + isEqual);
// toString()
String stringValue = num1.toString(); // 将BigDecimal转换为String
System.out.println("String value: " + stringValue);
}
}
这个示例程序演示了如何使用BigDecimal类中的各个方法。它包括创建BigDecimal实例、加法、减法、乘法、除法、取余、幂、精度设置、绝对值、相反数、比较大小、检查相等性以及转换为字符串等操作。BigDecimal类提供了更精确和可靠的数值计算功能，适用于需要处理大数值或进行高精度计算的场景。
运行结果如下：
Sum: 15.75
Difference: 5.25
Product: 55.1250
Quotient: 2.00
Remainder: 0.00
Power: 1157.625000
Scaled number: 10.50
Absolute value: 10.50
Negated value: -10.50
Number 1 is greater than Number 2
Is equal? false
String value: 10.50
3.4 Random类
Random类用于生成随机数。它提供了多个生成随机整数、浮点数和字节数组的方法。种子是控制随机数序列的起始点，可以通过 setSeed(long seed) 方法设置。使用Random类可以生成不同范围内的随机整数和浮点数，并进行随机选择。它在各种需要随机性的应用中很有用，如游戏、模拟和密码学等领域。
下面是Java的Random类中的全部操作方法API的汇总介绍：
| 方法 | 描述 |
|---|---|
nextInt() |
返回一个随机的int类型整数 |
nextInt(int origin, int bound) |
返回一个介于origin（包括）和bound（不包括）之间的int类型整数 |
nextDouble() |
返回一个随机的double类型浮点数 |
nextBytes(byte[] bytes) |
生成随机的字节数组并将其放入指定的字节数组中 |
setSeed(long seed) |
设置此Random对象的种子 |
下面是一个示例程序，演示了如何使用Random类中的各个方法：
import java.util.Random;
import java.util.Arrays;
public class RandomExample {
public static void main(String[] args) {
// 创建Random实例
Random random = new Random();
// nextInt()
int randomNumber = random.nextInt(); // 生成一个随机的int类型整数
System.out.println("Random number: " + randomNumber);
// nextInt(int origin, int bound)
int rangeNumber = random.nextInt(10); // 生成一个介于0（包括）和10（不包括）之间的int类型整数
System.out.println("Range number: " + rangeNumber);
// nextDouble()
double randomDouble = random.nextDouble(); // 生成一个随机的double类型浮点数
System.out.println("Random double: " + randomDouble);
// nextBytes(byte[] bytes)
byte[] byteArray = new byte[5];
random.nextBytes(byteArray); // 生成随机的字节数组并将其放入指定的字节数组中
System.out.println("Random bytes: " + Arrays.toString(byteArray));
// setSeed(long seed)
random.setSeed(12L); // 设置Random对象的种子为12L
long seededRandom1 = random.nextLong(); // 使用种子生成一个随机的long类型整数
System.out.println("Seeded random1: " + seededRandom1);
random.setSeed(12L);
long seededRandom2 = random.nextLong(); // 使用种子生成一个随机的long类型整数
System.out.println("Seeded random2: " + seededRandom2);
}
}
这个示例程序演示了如何使用Random类中的各个方法。它包括创建Random实例、生成随机整数、生成指定范围内的随机整数、生成随机浮点数、生成随机字节数组以及设置种子等操作。Random类提供了生成伪随机数的能力，可以在需要随机性的场景中使用，如游戏、模拟和密码学等。
运行结果如下：
Random number: -1803381675
Range number: 1
Random double: 0.8991983917654687
Random bytes: [103, -55, -4, -16, 122]
Seeded random1: -4982598272866526024
Seeded random2: -4982598272866526024
如何理解
setSeed(long seed)方法，种子(seed)是什么？
在计算机编程中，Random类用于生成伪随机数。为了生成随机数，Random对象需要一个起始点，这个起始点就是种子(seed)。种子是一个初始值，它作为随机数生成算法的输入，并决定了生成的随机数序列。
Random对象使用确定性算法根据种子(seed)生成随机数。当传入相同的种子，Random对象将产生相同的随机数序列。这意味着如果设置了相同的种子，那么每次调用生成随机数的方法时都会得到相同的预测性结果。
通过设置不同的种子(seed)，我们可以获得不同的随机数序列。通常情况下，我们可以使用当前时间作为种子值，以确保每次程序执行时都会生成不同的随机数序列。但有时候，我们希望具有可重现性，即使在不同的执行环境中也可以生成相同的随机数序列，这时可以手动设置种子为特定的值。
总结来说，种子(seed)是Random对象生成随机数的起始点，不同的种子会生成不同的随机数序列。
3.5 DecimalFormat类
DecimalFormat类中的操作方法可以帮助我们自定义数字格式，并进行数字格式化操作，如设置小数位数、设置前缀和后缀符号以及设置取整模式等。
下表是Java的DecimalFormat类的全部操作方法API：
| 方法签名 | 描述 |
|---|---|
DecimalFormat() |
创建一个DecimalFormat对象，默认使用的格式样式与默认语言环境相关 |
DecimalFormat(String pattern) |
用给定的模式创建一个DecimalFormat对象 |
applyLocalizedPattern(String pattern) |
根据本地化约定将给定的模式应用于格式器 |
applyPattern(String pattern) |
将给定的模式应用于格式器 |
format(double number) |
格式化给定的数字，返回一个字符串结果 |
getMaximumFractionDigits() |
返回此格式器用于格式化小数部分的最大位数 |
getMinimumFractionDigits() |
返回此格式器用于格式化小数部分的最小位数 |
getNegativePrefix() |
返回负数前缀的字符串 |
getNegativeSuffix() |
返回负数后缀的字符串 |
getPositivePrefix() |
返回正数前缀的字符串 |
getPositiveSuffix() |
返回正数后缀的字符串 |
setMaximumFractionDigits(int newValue) |
设置此格式器用于格式化小数部分的最大位数 |
setMinimumFractionDigits(int newValue) |
设置此格式器用于格式化小数部分的最小位数 |
setNegativePrefix(String newValue) |
设置负数前缀的字符串 |
setNegativeSuffix(String newValue) |
设置负数后缀的字符串 |
setPositivePrefix(String newValue) |
设置正数前缀的字符串 |
setPositiveSuffix(String newValue) |
设置正数后缀的字符串 |
setRoundingMode(RoundingMode mode) |
设置四舍五入模式 |
下面是一个示例程序，演示如何使用上述每个DecimalFormat类的方法：
import java.text.DecimalFormat;
import java.math.RoundingMode;
public class DecimalFormatExample {
public static void main(String[] args) {
double number = 12345.12345678;
// 创建一个DecimalFormat对象，默认使用的格式样式与默认语言环境相关
DecimalFormat df1 = new DecimalFormat();
System.out.println(df1.format(number));
// 用给定的模式创建一个DecimalFormat对象
DecimalFormat df2 = new DecimalFormat("#,###.00");
System.out.println(df2.format(number));
// 将给定的模式应用于格式器
df1.applyPattern("0.##");
System.out.println(df1.format(number));
// 根据本地化约定将给定的模式应用于格式器
df2.applyLocalizedPattern("#.###");
System.out.println(df2.format(number));
// 设置此格式器用于格式化小数部分的最大位数
int maxFractionDigits = 5;
df1.setMaximumFractionDigits(maxFractionDigits);
System.out.println(df1.format(number));
// 设置此格式器用于格式化小数部分的最小位数
double tempNumber = 666;
int minFractionDigits = 1;
df2.setMinimumFractionDigits(minFractionDigits);
System.out.println(df2.format(tempNumber));
// 返回此格式器用于格式化小数部分的最大位数
int maxDigits1 = df1.getMaximumFractionDigits();
System.out.println("Maximum fraction digits for df1: " + maxDigits1);
// 返回此格式器用于格式化小数部分的最小位数
int minDigits2 = df2.getMinimumFractionDigits();
System.out.println("Minimum fraction digits for df2: " + minDigits2);
// 设置负数前缀的字符串
df1.setNegativePrefix("(-)");
// 设置负数后缀的字符串
df1.setNegativeSuffix(" NEGATIVE");
// 设置正数前缀的字符串
df1.setPositivePrefix("+");
// 设置正数后缀的字符串
df1.setPositiveSuffix(" POSITIVE");
// 设置四舍五入模式
df1.setRoundingMode(RoundingMode.HALF_UP);
// 格式化给定的数字，返回一个字符串结果
String formattedNumber1 = df1.format(number);
number = -1234.123456;
String formattedNumber2 = df1.format(number);
System.out.println("Formatted number using df1: " + formattedNumber1);
System.out.println("Formatted number using df1: " + formattedNumber2);
}
}
程序运行结果如下：
12,345.123
12,345.12
12345.12
12345.123
12345.12346
666.0
Maximum fraction digits for df1: 5
Minimum fraction digits for df2: 1
Formatted number using df1: +12345.12346 POSITIVE
Formatted number using df1: (-)1234.12346 NEGATIVE
4️⃣ 应用场景
Java 的数学计算相关类可广泛应用于各种场景，包括但不限于：
- 科学计算和统计分析；
- 金融领域的复杂计算（如货币交易、税务计算）；
- 游戏开发中的碰撞检测、物理模拟等；
- 图像处理中的几何变换、滤波等。
注意：
使用时注意需要结合具体业务场景要求选择合适的精度和运算方式，避免精度丢失和错误结果。
当涉及处理精确货币计算时，务必使用 BigDecimal 类以避免舍入误差。
5️⃣ 使用技巧
-
BigDecimal类
BigDecimal类用于进行高精度的数学计算，提供了精确的数字操作。它适用于需要精确计算、处理货币等涉及小数位数较多或要求高精度的场景。使用技巧：- 创建
BigDecimal对象时，可以使用字符串或基本数据类型作为参数传入构造函数。避免使用双精度浮点数或浮点字面值来创建对象，以免精度丢失； - 使用
BigDecimal的方法执行数学运算时，例如add、subtract等。注意使用对应的方法进行除法运算时，指定精确的舍入规则(RoundingMode)； - 避免使用
doubleValue方法将对象转换为双精度浮点数，因为这可能导致精度损失。尽量保持结果在BigDecimal类型中进行处理。
- 创建
-
Math类
Math类提供了很多数学计算相关的静态方法，可用于执行各种数学计算操作。使用技巧：- 尽量避免多次调用
Math类中的复杂计算方法，因为其底层可能会执行较慢。如果需要重复使用某个计算结果，可以将其保存在变量中，避免重复计算； - 注意
Math类中的一些常量（如PI和E），可以通过静态字段直接访问，避免重复计算或调用一个方法来获取常量的值。
- 尽量避免多次调用
-
Random类
Random类用于生成伪随机数。使用技巧：- 想要生成特定范围内的随机数，使用
nextInt、nextDouble等方法，并根据需要进行线性变换或缩放操作； - 尽量避免在频繁循环或大量生成随机数的场景中创建新的对象。可以将对象声明为全局变量，以便多次使用同一个对象；
- 在创建
Random对象时，建议将种子(seed)设置为当前时间的毫秒数，以获得较好的随机性。
- 想要生成特定范围内的随机数，使用
-
DecimalFormat类
DecimalFormat类用于格式化数字。通过指定模式(pattern)和相关设置，可以自定义数字的显示方式，包括小数位数、千分位分隔符、前缀后缀等。使用技巧：- 对于重复使用相同模式的情况，避免每次都重新创建
DecimalFormat对象。建议将对象声明为静态变量，以便多次重用； - 注意设置适当的舍入模式(
RoundingMode)来控制格式化后的数字舍入规则，以满足需要的精确度和准确性要求。
- 对于重复使用相同模式的情况，避免每次都重新创建
以上是关于几个常用的Java数学计算类库的基本使用和一些优化技巧。根据具体的需求和情境，可以进一步了解它们的详细功能和更多用法，并根据实际情况进行调整和优化代码。
总结
Java 的数学计算相关类提供了强大的数学运算和操作功能。开发人员可以根据实际需求，选择适当的类来执行简单或高精度的数学计算。但在使用过程中，需要注意选择合适的精度、性能优化和避免误差等问题。通过熟悉这些类的特性与用法，并灵活运用，我们能够更好地利用 Java 提供的数学计算能力解决实际问题。
本文源码下载地址
Java的数学运算处理类讲解代码（BigDecimal、Math、Random、DecimalFormat类全部操作方法API）
⏪ 温习回顾上一篇（点击跳转）：
《【Java基础教程】（三十五）常用类库篇 · 第五讲：System类——解析系统辅助工具System类，一个系统操作与资源管理工具类 ~》
⏩ 继续阅读下一篇（点击跳转）：
《【Java基础教程】（三十七）常用类库篇 · 第七讲：日期时间处理类——三万字全面讲解 LocalDateTime和 DateTimeFormatter，Date、Calendar ~》
