数字处理

Java 语言提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如三角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数方法。除此之外，Java 语言还提供了一些常用的数学常量，如 PI、E 等。本节将讲解 Math 类以及其中的一些常用方法。

在实际开发中，随机数的使用是很普遍的，因此要掌握生成随机数的操作。在 Java 中主要提供了两种生成随机数的方式，分别为调用 Math 类的 random() 方法生成随机数和调用 Random 类生成各种数据类型的随机数。

Java 语言还提供了大数字的操作类，即 java.math.BigInteger 类与 java.math.BigDecimal 类。这两个类用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal 类则是针对大小数的处理类。

数字格式化

数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字。数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中，程序开发人员可以使用 java.text.DecimalFormat 类来格式化数字，本节将着重讲解 DecimalFormat 类。

在 Java 中，没有格式化的数据遵循以下原则：

  • 如果数据绝对值大于 0.001 并且小于 10000000，则以常规小数形式进行表示。

  • 如果数据绝对值小于 0.001 或者大于 10000000，则使用科学记数法进行表示。

由于上述输出格式不能满足解决实际问题的要求，因此通常将结果格式化为指定形式后进行输出。在 Java 中，程序开发人员可以使用 DecimalFormat 类进行格式化操作。

DecimalFormat 类是 NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。使用 DecimalFormat 类可以为要输出的数字加上单位或控制数字的精度。一般情况下，数字格式可以在实例化 DecimalFormat 对象时予以设置，也可以通过 DecimalFormat 类中的 applyPattern() 方法予以设置。

当格式化数字时，可以在 DecimalFormat 类中使用一些特殊字符构成一个格式化模板，使数字按照一定的特殊字符规则进行匹配。表11.7列举了格式化模板中的特殊字符及其所代表的含义。

image 2024 03 01 16 49 05 689
Figure 1. 表11.7 DecimalFormat类中的特殊字符及其说明

下面以实例说明数字格式化的使用。

【例11.6】DecimalFormat类的常用方法（实例位置：资源包\TM\sl\11\6）

在项目中创建 DecimalFormatSimpleDemo 类，在类中分别定义 SimgleFormat() 方法和 UseApplyPatternMethodFormat() 方法实现两种格式化数字的方式。

import java.text.DecimalFormat;

public class DecimalFormatSimpleDemo {
	// 使用实例化对象时设置格式化模式
	static public void SimgleFormat(String pattern, double value) {
		DecimalFormat myFormat = new DecimalFormat(pattern); // 实例化DecimalFormat对象
		String output = myFormat.format(value); // 将数字进行格式化
		System.out.println(value + " " + pattern + " " + output);
	}

	// 使用applyPattern()方法对数字进行格式化
	static public void UseApplyPatternMethodFormat(String pattern, double value) {
		DecimalFormat myFormat = new DecimalFormat(); // 实例化DecimalFormat对象
		myFormat.applyPattern(pattern); // 调用applyPattern()方法设置格式化模板
		System.out.println(value + " " + pattern + " " + myFormat.format(value));
	}

	public static void main(String[] args) {
		SimgleFormat("###,###.###", 123456.789); // 调用静态SimgleFormat()方法
		SimgleFormat("00000000.###kg", 123456.789); // 在数字后加上单位
		// 按照格式模板格式化数字，不存在的位以0显示
		SimgleFormat("000000.000", 123.78);
		// 调用静态UseApplyPatternMethodFormat()方法
		UseApplyPatternMethodFormat("#.###%", 0.789); // 将数字转换为百分数形式
		UseApplyPatternMethodFormat("###.##", 123456.789); // 将小数点后格式化为两位
		UseApplyPatternMethodFormat("0.00\u2030", 0.789); // 将数字转化为千分数形式
	}
}

运行结果如下：

     123456.789 ###,###.### 123,456.789
     123456.789 00000000.###kg 00123456.789kg
     123.78 000000.000 000123.780
     0.789 #.###% 78.9%
     123456.789 ###.## 123456.79
     0.789 0.00‰ 789.00‰

在本实例中可以看到，代码的第一行使用 import 关键字导入了 java.text.DecimalFormat 类，这是告知系统下面的代码将使用 DecimalFormat 类。然后定义了两个格式化数字的方法，这两个方法的参数都为两个，分别代表数字格式化模板和具体需要格式化的数字。虽然这两个方法都可以实现数字的格式化，但采用的方式有所不同，SimgleFormat() 方法是在实例化 DecimalFormat 对象时设置数字格式化模板的，而 UseApplyPatternMethodFormat() 方法是在实例化 DecimalFormat 对象后调用 applyPattern() 方法设置数字格式化模板的。最后，在主方法中根据不同形式的模板格式化数字。在结果中可以看到：在对以 “0” 特殊字符构成的模板进行格式化时，如果数字某位不存在，则将显示 0；而在对以 “#” 特殊字符构成的模板进行格式化操作时，格式化后的数字位数与数字本身的位数一致。

在 DecimalFormat 类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字进行格式化设置。例如：

DecimalFormat myFormat = new DecimalFormat();  // 实例化 DecimalFormat 类对象
myFormat.setGroupingSize(2);   // 设置将数字分组的大小
myFormat.setGroupingUsed(false);  // 设置是否支持分组

在上述代码中，setGroupingSize() 方法设置格式化数字的分组大小，setGroupingUsed() 方法设置是否可以对数字进行分组操作。为了使读者更好地理解这两个方法的使用，来看下面的实例。

在项目中创建 DecimalMethod 类，在类的主方法中调用 setGroupingSize() 与 setGroupingUsed() 方法实现数字的分组。

import java.text.DecimalFormat;

public class DecimalFormatSimpleDemo {
	// 使用实例化对象时设置格式化模式
	static public void SimgleFormat(String pattern, double value) {
		DecimalFormat myFormat = new DecimalFormat(pattern); // 实例化DecimalFormat对象
		String output = myFormat.format(value); // 将数字进行格式化
		System.out.println(value + " " + pattern + " " + output);
	}

	// 使用applyPattern()方法对数字进行格式化
	static public void UseApplyPatternMethodFormat(String pattern, double value) {
		DecimalFormat myFormat = new DecimalFormat(); // 实例化DecimalFormat对象
		myFormat.applyPattern(pattern); // 调用applyPattern()方法设置格式化模板
		System.out.println(value + " " + pattern + " " + myFormat.format(value));
	}

	public static void main(String[] args) {
		SimgleFormat("###,###.###", 123456.789); // 调用静态SimgleFormat()方法
		SimgleFormat("00000000.###kg", 123456.789); // 在数字后加上单位
		// 按照格式模板格式化数字，不存在的位以0显示
		SimgleFormat("000000.000", 123.78);
		// 调用静态UseApplyPatternMethodFormat()方法
		UseApplyPatternMethodFormat("#.###%", 0.789); // 将数字转换为百分数形式
		UseApplyPatternMethodFormat("###.##", 123456.789); // 将小数点后格式化为两位
		UseApplyPatternMethodFormat("0.00\u2030", 0.789); // 将数字转化为千分数形式
	}
}

运行结果如下：

     将数字以每两个数字进行分组 12,34,56.789
     不允许对数字进行分组 123456.789

Math类

Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便。可以使用如下形式调用：

Math.数学方法

在 Math 类中，除函数方法外还存在一些常用数学常量，如 PI、E 等。这些数学常量作为 Math 类的成员变量出现，调用起来也很简单。可以使用如下形式调用：

Math.PI
Math.E

Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数函数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

三角函数方法

Math 类中包含的三角函数方法如下。

  • public static double sin(double a)：返回角的三角正弦。

  • public static double cos(double a)：返回角的三角余弦。

  • public static double tan(double a)：返回角的三角正切。

  • public static double asin(double a)：返回一个值的反正弦。

  • public static double acos(double a)：返回一个值的反余弦。

  • public static double atan(double a)：返回一个值的反正切。

  • public static double toRadians(double angdeg)：将角度转换为弧度。

  • public static double toDegrees(double angrad)：将弧度转换为角度。

以上每个方法的参数和返回值都是 double 型的。将这些方法的参数的值设置为 double 型是有一定道理的，参数以弧度代替角度来实现，其中1°等于π/180弧度，因此180°可以使用π弧度来表示。除了可以获取角的正弦、余弦、正切、反正弦、反余弦、反正切，Math 类还提供了角度和弧度相互转换的方法，即 toRadians() 和 toDegrees()。但需要注意的是，角度与弧度的转换通常是不精确的。

【例11.7】在Java代码中进行三角函数运算（实例位置：资源包\TM\sl\11\7）

在项目中创建 TrigonometricFunction 类，在类的主方法中调用 Math 类提供的各种三角函数运算方法，并输出运算结果。

public class TrigonometricFunction {
	public static void main(String[] args) {
		System.out.println("90度的正弦值：" + Math.sin(Math.PI / 2)); // 取90°的正弦
		System.out.println("0度的余弦值：" + Math.cos(0)); // 取0°的余弦
		System.out.println("60度的正切值：" + Math.tan(Math.PI / 3)); // 取60°的正切
		System.out.println("2的平方根与2商的反正弦值：" + Math.asin(Math.sqrt(2) / 2));// 取2的平方根与2商的反正弦
		System.out.println("2的平方根与2商的反余弦值：" + Math.acos(Math.sqrt(2) / 2));// 取2的平方根与2商的反余弦
		System.out.println("1的反正切值：" + Math.atan(1)); // 取1的反正切
		System.out.println("120度的弧度值：" + Math.toRadians(120.0)); // 取120°的弧度值
		System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI / 2)); // 取π/2的角度
	}
}

运行结果如下：

     90度的正弦值：1.0
     0度的余弦值：1.0
     60度的正切值：1.7320508075688767
     2的平方根与2商的反正弦值：0.7853981633974484
     2的平方根与2商的反余弦值：0.7853981633974483
     1的反正切值：0.7853981633974483
     120度的弧度值：2.0943951023931953
     π/2的角度值：90.0

通过运行结果可以看出，90°的正弦值为1，0°的余弦值为1，60°的正切与 Math.sqrt(3) 的值应该是一致的，也就是取3的平方根。在结果中可以看到，第4～6行的值是基本相同的，这个值被换算后正是45°，也就是获取的 Math.sqrt(2)/2 反正弦、反余弦值与1的反正切值都是45°。最后两行输出语句实现的是角度和弧度的转换，其中 Math.toRadians(120.0) 语句是获取120°的弧度值，而 Math.toDegrees(Math.PI/2) 语句是获取 π/2 的角度值。读者可以将这些具体的值使用π的形式表示出来，与上述结果应该是基本一致的，这些结果不能做到十分精确，因为π本身也是一个近似值。

指数函数方法

Math 类中与指数相关的函数方法如下。

  • public static double exp(double a)：用于获取e的a次方，即取eª。

  • public static double log(double a)：用于取自然对数，即取lna的值。

  • public static double log10(double a)：用于取底数为10的a的对数。

  • public static double sqrt(double a)：用于取a的平方根，其中a的值不能为负值。

  • public static double cbrt(double a)：用于取a的立方根。

  • public static double pow(double a,double b)：用于取a的b次方。

指数运算包括求方根、取对数以及求 n 次方的运算。为了使读者更好地理解这些运算函数方法的用法，下面举例说明。

【例11.8】在Java代码中进行指数函数运算（实例位置：资源包\TM\sl\11\8）

在项目中创建 ExponentFunction 类，在类的主方法中调用 Math 类中的方法实现指数函数的运算，并输出运算结果。

public class ExponentFunction {
	public static void main(String[] args) {
		System.out.println("e的平方值：" + Math.exp(2)); // 取e的2次方
		System.out.println("以e为底2的对数值：" + Math.log(2)); // 取以e为底2的对数
		System.out.println("以10为底2的对数值：" + Math.log10(2)); // 取以10为底2的对数
		System.out.println("4的平方根值：" + Math.sqrt(4)); // 取4的平方根
		System.out.println("8的立方根值：" + Math.cbrt(8)); // 取8的立方根
		System.out.println("2的2次方值：" + Math.pow(2, 2)); // 取2的2次方
	}
}

运行结果如下：

     e的平方值：7.38905609893065
     以e为底2的对数值：0.6931471805599453
     以10为底2的对数值：0.3010299956639812
     4的平方根值：2.0
     8的立方根值：2.0
     2的2次方值：4.0

在本实例中可以看到，使用 Math 类中的方法比较简单，直接使用 Math 类名调用相应的方法即可。

取整函数方法

在具体的问题中，取整操作使用也很普遍，因此 Java 在 Math 类中添加了数字取整方法。Math 类中主要包括以下几种取整方法。

  • public static double ceil(double a)：返回大于或等于参数的最小整数。

  • public static double floor(double a)：返回小于或等于参数的最大整数。

  • public static double rint(double a)：返回与参数最接近的整数，如果存在两个同样接近的整数，则结果取偶数。

  • public static int round(float a)：将参数加上0.5后返回与参数最近的整数。

  • public static long round(double a)：将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型。

下面以1.5作为参数，获取取整函数的返回值。图11.1用坐标轴的形式对此进行了展示。

image 2024 03 01 17 25 11 426
Figure 2. 图11.1 取整函数的返回值

由于数1.0和数2.0距离数1.5都是0.5个单位长度，因此 Math.rint(1.5) 返回偶数 2.0。

【例11.9】各场景下取整函数的运算结果（实例位置：资源包\TM\sl\11\9）

在项目中创建 IntFunction 类，在类的主方法中调用 Math 类中的方法实现取整函数的运算，并输出运算结果。

public class IntFunction {
	public static void main(String[] args) {
		//返回第一个大于等于参数的整数
		System.out.println("使用ceil()方法取整：" + Math.ceil(5.2));
		//返回第一个小于等于参数的整数
		System.out.println("使用floor()方法取整：" + Math.floor(2.5));
		//返回与参数最接近的整数
		System.out.println("使用rint()方法取整：" + Math.rint(2.7));
		//返回与参数最接近的整数
		System.out.println("使用rint()方法取整：" + Math.rint(2.5));
		//将参数加上0.5后返回最接近的整数
		System.out.println("使用round()方法取整：" + Math.round(3.4f));
		//将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
		System.out.println("使用round()方法取整：" + Math.round(2.5));
	}
}

运行结果如下：

     使用ceil()方法取整：6.0
     使用floor()方法取整：2.0
     使用rint()方法取整：3.0
     使用rint()方法取整：2.0
     使用round()方法取整：3
     使用round()方法取整：3

取最大值 最小值 绝对值函数方法

在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下。

  • public static double max(double a,double b)：取a与b之间的最大值。

  • public static int min(int a,int b)：取a与b之间的最小值，参数为整型。

  • public static long min(long a,long b)：取a与b之间的最小值，参数为长整型。

  • public static float min(float a,float b)：取a与b之间的最小值，参数为单精度浮点型。

  • public static double min(double a,double b)：取a与b之间的最小值，参数为双精度浮点型。

  • public static int abs(int a)：返回整型参数的绝对值。

  • public static long abs(long a)：返回长整型参数的绝对值。

  • public static float abs(float a)：返回单精度浮点型参数的绝对值。

  • public static double abs(double a)：返回双精度浮点型参数的绝对值。

【例11.10】取最大值、最小值、绝对值的方法（实例位置：资源包\TM\sl\11\10）

在项目中创建 AnyFunction 类，在类的主方法中调用 Math 类中的方法实现求两数的最大值、最小值和取绝对值的运算，并输出运算结果。

public class AnyFunction {
	public static void main(String[] args) {
		System.out.println("4和8较大者:" + Math.max(4, 8)); // 取两个参数的最大值
		System.out.println("4.4和4较小者：" + Math.min(4.4, 4)); // 取两个参数的最小值
		System.out.println("-7的绝对值：" + Math.abs(-7)); // 取参数的绝对值
	}
}

运行结果如下：

     4和8较大者：8
     4.4和4较小者：4.0
     -7的绝对值：7

Random类

Random 类是 JDK 中的随机数生成器类，程序开发人员可以通过实例化一个 Random 类对象来创建一个随机数生成器，语法如下：

Random r = new Random();

以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为每时每刻的时间不可能相同，所以产生的随机数不同。但是，如果运行速度太快，也会产生两个运行结果相同的随机数。

用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下：

Random r = new Random(seedValue);

  • r：Random类对象。

  • seedValue：随机数生成器的种子。

在 Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法。

  • public int nextInt()：返回一个随机整数。

  • public int nextInt(int n)：返回大于或等于0且小于n的随机整数。

  • public long nextLong()：返回一个随机长整型值。

  • public boolean nextBoolean()：返回一个随机布尔型值。

  • public float nextFloat()：返回一个随机单精度浮点型值。

  • public double nextDouble()：返回一个随机双精度浮点型值。

  • public double nextGaussian()：返回一个概率密度为高斯分布的双精度浮点型值。

【例11.11】获取不同取值范围、不同类型的随机数（实例位置：资源包\TM\sl\11\11）

在项目中创建 RandomDemo 类，在类的主方法中创建 Random 类的对象，使用该对象生成各种类型的随机数，并输出结果。

import java.util.Random;

public class RandomDemo {
	public static void main(String[] args) {
		Random r = new Random(); // 实例化一个Random类
		// 随机产生一个整数
		System.out.println("随机产生一个整数:" + r.nextInt());
		// 随机产生一个大于等于0且小于10的整数
		System.out.println("随机产生一个大于等于0小于10的整数：" + r.nextInt(10));
		// 随机产生一个布尔型的值
		System.out.println("随机产生一个布尔型的值：" + r.nextBoolean());
		// 随机产生一个双精度型的值
		System.out.println("随机产生一个双精度型的值：" + r.nextDouble());
		// 随机产生一个浮点型的值
		System.out.println("随机产生一个浮点型的值：" + r.nextFloat());
		// 随机产生一个概率密度为高斯分布的双精度值
		System.out.println("随机产生一个概率密度为高斯分布的双精度值：" + r.nextGaussian());
	}
}

代码每次运行得到的结果都会不同，笔者写稿时的运行结果如下：

     随机产生一个整数：-991995210
     随机产生一个大于或等于0且小于10的整数：5
     随机产生一个布尔型的值：true
     随机产生一个双精度浮点型的值：0.05001508158115486
     随机产生一个单精度浮点型的值：0.31018203
     随机产生一个概率密度为高斯分布的双精度浮点型的值：0.6781040183219917

random() 方法返回的值实际上是伪随机数，它通过复杂的运算而得到一系列的数。该方法使用当前时间作为随机数生成器的参数，因此每次执行程序时都会产生不同的随机数。

BigInteger类

BigInteger 类的数字范围较 Integer 类的数字范围要大得多。前文介绍过 Integer 类是 int 的包装类，int 的最大值为231-1，如果要计算更大的数字，使用 Integer 类就无法实现了，因此 Java 提供了 BigInteger 类来处理更大的数字。BigInteger 类支持任意精度的整数，也就是说，在运算中 BigInteger 类可以准确地表示任何大小的整数值而不会丢失信息。

在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。

使用 BigInteger 类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。

例如，将 2 转换为 BigInteger 类型，可以使用以下语句进行初始化操作：

BigInteger twoInstance = new BigInteger("2");

参数 2 的双引号不能省略，因为参数是以字符串的形式存在的。

一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数学运算和位运算以及一些取相反数、取绝对值等操作。下面列举了 BigInteger 类中常用的几种运算方法。

  • public BigInteger add(BigInteger val)：做加法运算。

  • public BigInteger subtract(BigInteger val)：做减法运算。

  • public BigInteger multiply(BigInteger val)：做乘法运算。

  • public BigInteger divide(BigInteger val)：做除法运算。

  • public BigInteger remainder(BigInteger val)：做取余操作。

  • public BigInteger[] divideAndRemainder(BigInteger val)：用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。

  • public BigInteger pow(int exponent)：进行取参数的 exponent 次方操作。

  • public BigInteger negate()：取相反数。

  • public BigInteger shiftLeft(int n)：将数字左移n位，如果n为负数，做右移操作。

  • public BigInteger shiftRight(int n)：将数字右移n位，如果n为负数，做左移操作。

  • public BigInteger and(BigInteger val)：做与操作。

  • public BigInteger or(BigInteger val)：做或操作。

  • public int compareTo(BigInteger val)：做数字比较操作。

  • public boolean equals(Object x)：当参数 x 是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回true。

  • public BigInteger min(BigInteger val)：返回较小的数值。

  • public BigInteger max(BigInteger val)：返回较大的数值。

【例11.12】使用BigInteger类进行数学运算（实例位置：资源包\TM\sl\11\12）

在项目中创建 BigIntegerDemo 类，然后在类的主方法中创建两个 BigInteger 类对象，再对两个对象进行加、减、乘、除和其他运算，最后输出运算结果。

import java.math.BigInteger;

public class BigIntegerDemo {
	public static void main(String[] args) {
		BigInteger b1= new BigInteger("987654321987654321"); // 第1个大数字
		BigInteger b2 = new BigInteger("123456789123456789"); // 第2个大数字
		// 加法运算
		System.out.println("加法操作：" + b1.add(b2));
		// 减法运算
		System.out.println("减法操作：" + b1.subtract(b2));
		// 乘法运算
		System.out.println("乘法操作：" + b1.multiply(b2));
		// 除法运算
		System.out.println("除法操作：" + b1.divide(b2));
		// 取商运算
		System.out.println("取商：" + b1.divideAndRemainder(b2)[0]);
		// 取余运算
		System.out.println("取余数：" + b1.divideAndRemainder(b2)[1]);
		// 2次方运算
		System.out.println("做2次方操作：" + b1.pow(2));
		// 相反数运算
		System.out.println("取相反数操作：" + b1.negate());
	}
}

运行结果如下：

     加法操作：1111111111111111110
     减法操作：864197532864197532
     乘法操作：121932631356500531347203169112635269
     除法操作：8
     取商：8
     取余数：9000000009
     做2次方操作：975461059740893157555403139789971041
     取相反数操作：-987654321987654321

在本实例中需要注意的是，divideAndRemainder() 方法做除法操作，以数组的形式返回，数组中第一个值为做除法的商，第二个值为做除法的余数。

BigDecimal类

BigDecimal 类和 BigInteger 类都能实现大数字的运算，不同的是 BigDecimal 类加入了小数的概念。一般的 float 型和 double 型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，因此要使用 BigDecimal 类。BigDecimal 类支持任何精度的定点数，可以用它来精确计算货币值。在 BigDecimal 类中，常用的两个构造方法如表11.8所示。

image 2024 03 01 19 37 01 542
Figure 3. 表11.8 BigDecimal类中的常用构造方法

BigDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商的小数点后的末位数字的处理是需要考虑的。BigDecimal 类实现的加、减、乘、除的方法如表11.9所示。

image 2024 03 01 19 37 38 578
Figure 4. 表11.9 BigDecimal类实现的加、减、乘、除的方法

在上述方法中，BigDecimal 类中的 divide() 方法有多种设置，用于返回商的小数点后的末位数字的处理，这些模式的名称与含义如表11.10所示。

image 2024 03 01 19 38 16 079
Figure 5. 表11.10 BigDecimal类中的divide()方法的多种处理模式

下面设计一个类，这个类包括任意两个 BigDecimal 类型数字的加、减、乘、除运算方法。

【例11.13】使用BigDecimal类进行数学运算（实例位置：资源包\TM\sl\11\13）

在项目中创建 BigDecimalDemo 类，然后在类的主方法中创建两个 BigDecimal 类对象，再对两个对象进行加、减、乘、除运算，最后输出运算结果。

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalDemo {
	public static void main(String[] args) {
		BigDecimal b1 = new BigDecimal("0.00987654321");  // 第 1 个大小数
		BigDecimal b2 = new BigDecimal("0.00123456789");  // 第 2 个大小数
		System.out.println("两个数字相加结果：" + b1.add(b1));   // 加法运算
		System.out.println("两个数字相减结果：" + b1.subtract(b2));  // 减法运算
		System.out.println("两个数字相乘结果：" + b1.multiply(b2));  // 乘法运算
		// 除法运算，商小数点后保留9位，并对结果进行四舍五入操作
		System.out.println("两个数字相除，保留小数点后9位：" + b1.divide(b2,9, RoundingMode.HALF_UP));
	}
}

运行结果如下：

     两个数字相加结果：0.01111111111111111110
     两个数字相减结果：0.00864197532864197532
     两个数字相乘结果：0.0000121932631356500531347203169112635269
     两个数字相除，保留小数点后9位：8.000000073

编程训练（答案位置：资源包\TM\sl\11\编程训练）

【训练3】求偶数和 尝试开发一个程序，获取2～32（不包括32）的6个偶数，并求得这6个偶数的和。

【训练4】计算圆面积 尝试开发一个程序，定义一个求圆面积的方法，其中以圆半径作为参数，并将计算结果保留5位小数。