39、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中所有用于表示数学计算支持的类汇总，罗列如下表：

以上这些类在Java中提供了广泛的数学计算支持。它们可以执行各种数值计算和操作，包括三角函数、指数、对数、幂、绝对值、最大值、最小值等。

BigDecimal 和 BigInteger 类具有处理任意精度整数和定点数计算的能力，而 Random 类用于生成伪随机数。DecimalFormat 则用来格式化数字输出，MathContext 提供了精确的数学运算环境。这些类在各种场景下发挥重要作用，让开发人员能够进行精确和高效的数学计算。

在本文中，主要介绍最常用的Math 、BigDecimal、Random等类的使用及操作方式等相关知识。而其他类的详细操作方法API等信息，由于篇幅原因本文不再做更多介绍，感兴趣的朋友可私信我一起交流。

• Math 类是 Java 中的一个常见工具类，提供了许多静态方法来执行数学运算。它支持三角函数、指数、对数、幂、绝对值、最大值、最小值等常用运算。Math 类使用基本的浮点数运算，适用于大多数简单的数学计算。
• BigDecimal 类是 Java 中用于执行精确任意精度定点数计算的类。它可以处理极大和极小的数值，并提供高精度的计算结果。相比于 Math 类中的浮点数运算，BigDecimal 可以保证运算结果的精度和准确性；
• Random类：用于生成伪随机数。它的设计目标是以可预测性和均匀分布性为基础，提供一种可靠的随机数生成方式。

2️⃣ 优势和缺点

1、 Math类；

• 优点：静态方法方便直接调用，不需要实例化对象；封装了常见的数学运算，提供了简便的操作。
• 缺点：基于基本浮点数运算，可能导致精度损失，所以不适用于高精度计算。

1、 BigDecimal类；

• 优点：提供任意精度的计算，避免了浮点数运算导致的精度损失；支持基本的算术运算、指数运算等功能。
• 缺点：内存占用较大，运算速度比基本数据类型慢。

1、 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的简要介绍，以表格形式列举如下：

下面是一个示例程序，演示了如何使用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的汇总介绍：

下面是一个示例程序，演示了如何使用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的汇总介绍：

下面是一个示例程序，演示了如何使用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类的方法：

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️⃣ 使用技巧

1、 BigDecimal类；
BigDecimal类用于进行高精度的数学计算，提供了精确的数字操作。它适用于需要精确计算、处理货币等涉及小数位数较多或要求高精度的场景。使用技巧：

• 创建BigDecimal对象时，可以使用字符串或基本数据类型作为参数传入构造函数。避免使用双精度浮点数或浮点字面值来创建对象，以免精度丢失；
• 使用BigDecimal的方法执行数学运算时，例如add、subtract等。注意使用对应的方法进行除法运算时，指定精确的舍入规则(RoundingMode)；
• 避免使用doubleValue方法将对象转换为双精度浮点数，因为这可能导致精度损失。尽量保持结果在BigDecimal类型中进行处理。

2、 Math类；
Math类提供了很多数学计算相关的静态方法，可用于执行各种数学计算操作。使用技巧：

• 尽量避免多次调用Math类中的复杂计算方法，因为其底层可能会执行较慢。如果需要重复使用某个计算结果，可以将其保存在变量中，避免重复计算；
• 注意Math类中的一些常量（如PI和E），可以通过静态字段直接访问，避免重复计算或调用一个方法来获取常量的值。

3、 Random类；
Random类用于生成伪随机数。使用技巧：

• 想要生成特定范围内的随机数，使用nextInt、nextDouble等方法，并根据需要进行线性变换或缩放操作；
• 尽量避免在频繁循环或大量生成随机数的场景中创建新的对象。可以将对象声明为全局变量，以便多次使用同一个对象；
• 在创建Random对象时，建议将种子(seed)设置为当前时间的毫秒数，以获得较好的随机性。

4、 DecimalFormat类；
DecimalFormat类用于格式化数字。通过指定模式(pattern)和相关设置，可以自定义数字的显示方式，包括小数位数、千分位分隔符、前缀后缀等。使用技巧：

• 对于重复使用相同模式的情况，避免每次都重新创建DecimalFormat对象。建议将对象声明为静态变量，以便多次重用；
• 注意设置适当的舍入模式(RoundingMode)来控制格式化后的数字舍入规则，以满足需要的精确度和准确性要求。

以上是关于几个常用的Java数学计算类库的基本使用和一些优化技巧。根据具体的需求和情境，可以进一步了解它们的详细功能和更多用法，并根据实际情况进行调整和优化代码。

* 总结

Java 的数学计算相关类提供了强大的数学运算和操作功能。开发人员可以根据实际需求，选择适当的类来执行简单或高精度的数学计算。但在使用过程中，需要注意选择合适的精度、性能优化和避免误差等问题。通过熟悉这些类的特性与用法，并灵活运用，我们能够更好地利用 Java 提供的数学计算能力解决实际问题。

* 本文源码下载地址

Java的数学运算处理类讲解代码（BigDecimal、Math、Random、DecimalFormat类全部操作方法API）

[ ]nbsp_nbsp 2