Java 数学计算（一）：BigDecimal 详解 + 代码示例

已于 2023-03-31 08:42:09 修改
阅读量1.1k 收藏 15
点赞数 14
分类专栏： Java 教程：从入门到精通 文章标签： java 开发语言 BigDecimal
于 2023-03-27 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67276852/article/details/129785571
版权

在这里插入图片描述

❤️ 个人主页：水滴技术
🌸 订阅专栏：Java 教程：从入门到精通
🚀 支持水滴：点赞👍 + 收藏⭐ + 留言💬

文章目录

大家好，我是水滴~~

本文主要对 BigDecimal 类进行详细介绍，主要内容有：构造器、静态方法、静态常量、常用方法、舍入模式，并提供了大量的代码示例，可以将该文章当成工具书来用。

一、构造器

通过构造器获取 BigDecimal 的实例， 传入值共分为四大类：字符数组、字符串、数字、BigInteger 对象。

1.1 传入字符数组

通过传入字符数组的构造器有四个，要求所有字符都是数字：

  • BigDecimal(char[] in)：传入字符数组
  • BigDecimal(char[] in, int offset, int len)：传入字符数组、偏移量、长度
  • BigDecimal(char[] in, MathContext mc)：传入字符数组，并指定精度和舍入模式
  • BigDecimal(char[] in, int offset, int len, MathContext mc)：传入字符数组、偏移量、长度，并指定精度和舍入模式

代码示例：

// 字符数组
char[] in = "123.456".toCharArray();

// 传入字符数组
BigDecimal bd1 = new BigDecimal(in);
System.out.println("bd1 --> " + bd1);

// 传入字符数组、偏移量、长度
BigDecimal bd2 = new BigDecimal(in, 2, 4);
System.out.println("bd2 --> " + bd2);

// 传入字符数组，并指定精度和舍入模式
BigDecimal bd3 = new BigDecimal(in, new MathContext(5, RoundingMode.HALF_UP));
System.out.println("bd3 --> " + bd3);

// 传入字符数组、偏移量、长度，并指定精度和舍入模式
BigDecimal bd4 = new BigDecimal(in, 2, 4, new MathContext(2, RoundingMode.HALF_UP));
System.out.println("bd4 --> " + bd4);

输出结果：

bd1 --> 123.456
bd2 --> 3.45
bd3 --> 123.46
bd4 --> 3.5

1.2 传入字符串

通过传入字符串的构造器有两个，要求字符串是个数字：

  • BigDecimal(String val)：传入字符串
  • BigDecimal(String val, MathContext mc)：传入字符串，并指定精度和舍入模式

代码示例：

// 字符串
String val = "123.456";

// 传入字符串
BigDecimal bd1 = new BigDecimal(val);
System.out.println("bd1 --> " + bd1);

// 传入字符串，并指定精度和舍入模式
BigDecimal bd2 = new BigDecimal(val, new MathContext(5, RoundingMode.HALF_UP));
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> 123.456
bd2 --> 123.46

1.3 传入数字

通过传入数字类型的构造器有六个，其中 int、long、double 各两个：

  • BigDecimal(int val)：传入 int 类型
  • BigDecimal(int val, MathContext mc)：传入 int 类型，并指定精度和舍入模式
  • BigDecimal(long val)：传入 long 类型
  • BigDecimal(long val, MathContext mc)：传入 long 类型，并指定精度和舍入模式
  • BigDecimal(double val)：传入 double 类型（存在精度问题，不推荐使用）
  • BigDecimal(double val, MathContext mc)：传入 double 类型，并指定精度和舍入模式（存在精度问题，不推荐使用）

代码示例：

// 传入 int 类型
BigDecimal bd1 = new BigDecimal(123456);
System.out.println("bd1 --> " + bd1);

// 传入 int 类型，并指定精度和舍入模式
BigDecimal bd2 = new BigDecimal(123456, new MathContext(5));
System.out.println("bd2 --> " + bd2);

// 传入 long 类型
BigDecimal bd3 = new BigDecimal(123456L);
System.out.println("bd3 --> " + bd3);

// 传入 long 类型，并指定精度和舍入模式
BigDecimal bd4 = new BigDecimal(123456L, new MathContext(5));
System.out.println("bd4 --> " + bd4);

// 传入 double 类型（存在精度问题，不推荐使用）
BigDecimal bd5 = new BigDecimal(123.456);
System.out.println("bd5 --> " + bd5);

// 传入 double 类型，并指定精度和舍入模式（存在精度问题，不推荐使用）
BigDecimal bd6 = new BigDecimal(123.456, new MathContext(5));
System.out.println("bd6 --> " + bd6);

输出结果：

bd1 --> 123456
bd2 --> 1.2346E+5
bd3 --> 123456
bd4 --> 1.2346E+5
bd5 --> 123.4560000000000030695446184836328029632568359375
bd6 --> 123.46

1.4 传入 BigInteger 对象

通过传入 BigInteger 对象的构造器有四个：

  • BigDecimal(BigInteger val)：传入 BigInteger 对象
  • BigDecimal(BigInteger val, MathContext mc)：传入 BigInteger 对象，并指定精度和舍入模式
  • BigDecimal(BigInteger unscaledVal, int scale)：传入 BigInteger 对象，并进入缩放
  • BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)：传入 BigInteger 对象，并进入缩放，并指定精度和舍入模式

代码示例：

// BigInteger 对象
BigInteger val = BigInteger.valueOf(123456);

// 传入 BigInteger 对象
BigDecimal bd1 = new BigDecimal(val);
System.out.println("bd1 --> " + bd1);

// 传入 BigInteger 对象，并指定精度和舍入模式
BigDecimal bd2 = new BigDecimal(val, new MathContext(5));
System.out.println("bd2 --> " + bd2);

// 传入 BigInteger 对象，并进行缩放
BigDecimal bd3 = new BigDecimal(val, 3);
System.out.println("bd3 --> " + bd3);

// 传入 BigInteger 对象，并进行缩放，并指定精度和舍入模式
BigDecimal bd4 = new BigDecimal(val, 3, new MathContext(5));
System.out.println("bd4 --> " + bd4);

输出结果：

bd1 --> 123456
bd2 --> 1.2346E+5
bd3 --> 123.456
bd4 --> 123.46

二、静态方法

BigDecimal 提供了三个静态方法 valueOf()，传入数字即可获取 BigDecimal 实例：

  • BigDecimal valueOf(long val)：静态方法，传入 long 类型
  • BigDecimal valueOf(long unscaledVal, int scale)：静态方法，传入 long 类型，并且进行缩放
  • BigDecimal valueOf(double val)：静态方法，传入 double 类型（会将传入值转为字符串，没有精度问题）

代码示例：

// 静态方法，传入 long 类型
BigDecimal bd1 = BigDecimal.valueOf(123456);
System.out.println("bd1 --> " + bd1);

// 静态方法，传入 long 类型，并且进行缩放
BigDecimal bd2 = BigDecimal.valueOf(123456, 3);
System.out.println("bd2 --> " + bd2);

// 静态方法，传入 double 类型（会将传入值转为字符串，没有精度问题）
BigDecimal bd3 = BigDecimal.valueOf(123.456);
System.out.println("bd3 --> " + bd3);

输出结果：

bd1 --> 123456
bd2 --> 123.456
bd3 --> 123.456

三、静态常量

BigDecimal 提供了三个静态常量，用于获取“零”的实例、“一”的实例、“十”的实例：

  • BigDecimal.ZERO：“零”的静态常量
  • BigDecimal.ONE：“一”的静态常量
  • BigDecimal.TEN：“十”的静态常量

代码示例：

// “零”的静态常量
BigDecimal bd1 = BigDecimal.ZERO;
System.out.println("bd1 --> " + bd1);

// “一”的静态常量
BigDecimal bd2 = BigDecimal.ONE;
System.out.println("bd2 --> " + bd2);

// “十”的静态常量
BigDecimal bd3 = BigDecimal.TEN;
System.out.println("bd3 --> " + bd3);

输出结果：

bd1 --> 0
bd2 --> 1
bd3 --> 10

四、常用方法

4.1 加法（add）

加法运算是由两个 BigDecimal 对象进行相加，返回结果也是一个 BigDecimal 对象。加法运算共有两个重载方法可使用：

  • BigDecimal add(BigDecimal augend)：加法运算
  • BigDecimal add(BigDecimal augend, MathContext mc)：加法运算，并指定精度和舍入模式

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("56.78");
BigDecimal val2 = new BigDecimal("12.34");

// 加法运算
BigDecimal bd1 = val1.add(val2);
System.out.println(val1 + " + " + val2 + " = " + bd1);

// 加法运算，，并指定精度和舍入模式
BigDecimal bd2 = val1.add(val2, new MathContext(3, RoundingMode.HALF_UP));
System.out.println(val1 + " + " + val2 + " = " + bd2);

输出结果：

56.78 + 12.34 = 69.12
56.78 + 12.34 = 69.1

4.2 减法（subtract）

减法运算是由两个 BigDecimal 对象进行相减，返回结果也是一个 BigDecimal 对象。减法运算共有两个重载方法可使用：

  • BigDecimal subtract(BigDecimal subtrahend)：减法运算
  • BigDecimal subtract(BigDecimal subtrahend, MathContext mc)：减法运算，并指定精度和舍入模式

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("56.78");
BigDecimal val2 = new BigDecimal("12.34");

// 减法运算
BigDecimal bd1 = val1.subtract(val2);
System.out.println(val1 + " - " + val2 + " = " + bd1);

// 减法运算，，并指定精度和舍入模式
BigDecimal bd2 = val1.subtract(val2, new MathContext(3, RoundingMode.HALF_UP));
System.out.println(val1 + " - " + val2 + " = " + bd2);

输出结果：

56.78 - 12.34 = 44.44
56.78 - 12.34 = 44.4

4.3 乘法（multiply）

乘法运算是由两个 BigDecimal 对象进行相乘，返回结果也是一个 BigDecimal 对象。乘法运算共有两个重载方法可使用：

  • BigDecimal multiply(BigDecimal multiplicand)：乘法运算
  • BigDecimal multiply(BigDecimal multiplicand, MathContext mc)：乘法运算，并指定精度和舍入模式

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("56.78");
BigDecimal val2 = new BigDecimal("12.34");

// 乘法运算
BigDecimal bd1 = val1.multiply(val2);
System.out.println(val1 + " * " + val2 + " = " + bd1);

// 乘法运算，并指定精度和舍入模式
BigDecimal bd2 = val1.multiply(val2, new MathContext(4, RoundingMode.HALF_UP));
System.out.println(val1 + " * " + val2 + " = " + bd2);

输出结果：

56.78 * 12.34 = 700.6652
56.78 * 12.34 = 700.7

4.4 除法（divide）

除法运算是由两个 BigDecimal 对象进行相除，返回结果也是一个 BigDecimal 对象。除法相对比较特殊，由于可能存在除不尽的情况，有些方法会抛出 ArithmeticException 异常，这个在介绍具体方法时会指明。

除法运算共有六个重载方法，其中两个方法在 Java 9 的时候被废弃，我们这里只介绍剩余四个：

  • BigDecimal divide(BigDecimal divisor)：除法运算（未处理除不尽的情况，会报 ArithmeticException 异常，不推荐使用）
  • BigDecimal divide(BigDecimal divisor, MathContext mc)：除法运算，并指定精度和舍入模式
  • BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode)：除法运算，并指定舍入模式
  • BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)：除法运算，并指定保留的小数位数和舍入模式

代码示例：

// 构造三个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("12.34");
BigDecimal val2 = new BigDecimal("2");
BigDecimal val3 = new BigDecimal("3");

// 除法运算（未处理除不尽的情况，会报 ArithmeticException 异常，不推荐使用）
BigDecimal bd1 = val1.divide(val2);
System.out.println(val1 + " / " + val2 + " = " + bd1);

// 除法运算，并指定精度和舍入模式
BigDecimal bd2 = val1.divide(val3, new MathContext(4, RoundingMode.HALF_UP));
System.out.println(val1 + " / " + val3 + " = " + bd2);

// 除法运算，并指定舍入模式
BigDecimal bd3 = val1.divide(val3, RoundingMode.HALF_UP);
System.out.println(val1 + " / " + val3 + " = " + bd3);

// 除法运算，并指定保留的小数位数和舍入模式
BigDecimal bd4 = val1.divide(val3, 4, RoundingMode.HALF_UP);
System.out.println(val1 + " / " + val3 + " = " + bd4);

输出结果：

12.34 / 2 = 6.17
12.34 / 3 = 4.113
12.34 / 3 = 4.11
12.34 / 3 = 4.1133

4.5 商的整数和余数

4.5.1 取整

divideToIntegralValue 方法是将两个 BigDecimal 对象相除后，获取整数部分，其共有两个重载方法：

  • BigDecimal divideToIntegralValue(BigDecimal divisor)：取整
  • BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc)：取整，并指定精度（精度不够会抛出 ArithmeticException 异常）

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1234.5678");
BigDecimal val2 = new BigDecimal("3");

// 取整
BigDecimal bd1 = val1.divideToIntegralValue(val2);
System.out.println("[" + val1 + " / " + val2 + "] = " + bd1);

// 取整，并指定精度
BigDecimal bd2 = val1.divideToIntegralValue(val2, new MathContext(4));
System.out.println("[" + val1 + " / " + val2 + "] = " + bd2);

输出结果：

[1234.5678 / 3] = 411.0000
[1234.5678 / 3] = 411.0

4.5.2 取余

remainder 方法是将两个 BigDecimal 对象相除后，取其余数，其共有两个重载方法：

  • BigDecimal remainder(BigDecimal divisor)：取余
  • BigDecimal remainder(BigDecimal divisor, MathContext mc)：取余，并指定精度（精度不够会抛出 ArithmeticException 异常）

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1234.5678");
BigDecimal val2 = new BigDecimal("3");

// 取余
BigDecimal bd1 = val1.remainder(val2);
System.out.println(val1 + " % " + val2 + " = " + bd1);

// 取余，并指定精度
BigDecimal bd2 = val1.remainder(val2, new MathContext(3));
System.out.println(val1 + " % " + val2 + " = " + bd2);

输出结果：

1234.5678 % 3 = 1.5678
1234.5678 % 3 = 1.5678

4.5.3 同时取整和取余

divideAndRemainder 方法可以同时取两个 BigDecimal 对象相除后的整数部分和余数。如果同时需要整商和余数，这种方法比分开使用取整和取余的方法更快，因为除尘只需要执行一次。

其共有两个重载方法：

代码示例：

// 构造两个 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1234.5678");
BigDecimal val2 = new BigDecimal("3");

// 同时取商的整数和余数
BigDecimal[] bd1 = val1.divideAndRemainder(val2);
System.out.println("[" + val1 + " / " + val2 + "] = " + bd1[0]);
System.out.println(" " + val1 + " % " + val2 + "  = " + bd1[1]);

// 同时取商的整数和余数，并指定精度
BigDecimal[] bd2 = val1.divideAndRemainder(val2, new MathContext(3));
System.out.println("[" + val1 + " / " + val2 + "] = " + bd2[0]);
System.out.println(" " + val1 + " % " + val2 + "  = " + bd2[1]);

输出结果：

[1234.5678 / 3] = 411.0000
 1234.5678 % 3  = 1.5678
[1234.5678 / 3] = 411.000
 1234.5678 % 3  = 1.5678

4.6 幂运算

通过 pow 方法可以做幂运算。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val = new BigDecimal("2");

// 幂运算
BigDecimal bd1 = val.pow(10);
System.out.println("bd1 --> " + bd1);

// 幂运算，并指定精度
BigDecimal bd2 = val.pow(10, new MathContext(4));
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> 1024
bd2 --> 1024

4.7 绝对值

通过 abs 方法获取绝对值。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val = new BigDecimal("-1024");

// 取绝对值
BigDecimal bd1 = val.abs();
System.out.println("bd1 --> " + bd1);

// 取绝对值，并指定精度
BigDecimal bd2 = val.abs(new MathContext(4));
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> 1024
bd2 --> 1024

4.8 取反（负号）

通过 negate 方法可以对数进行取反，相当于 -this

代码示例：

// 构造 BigDecimal 对象
BigDecimal val = new BigDecimal("1024");

// 取反
BigDecimal bd1 = val.negate();
System.out.println("bd1 --> " + bd1);

// 取反，并指定精度
BigDecimal bd2 = val.negate(new MathContext(4));
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> -1024
bd2 --> -1024

4.9 正号

通过 plus 做正号处理，等于本身，相当于 +this。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val = new BigDecimal("-1024");

// 取正
BigDecimal bd1 = val.plus();
System.out.println("bd1 --> " + bd1);

// 取正，并指定精度
BigDecimal bd2 = val.plus(new MathContext(4));
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> -1024
bd2 --> -1024

4.10 符号

通过 signum 获取该数的符号：正数为 1；零为 0；负数为 -1

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("10");
BigDecimal val2 = new BigDecimal("0");
BigDecimal val3 = new BigDecimal("-11");

// 符号函数，获取该数的正负号
System.out.println("bd1 --> " + val1.signum());
System.out.println("bd2 --> " + val2.signum());
System.out.println("bd3 --> " + val3.signum());

输出结果：

bd1 --> 1
bd2 --> 0
bd3 --> -1

4.11 移位

可以对数值进行小数点移位，左移位使用 movePointLeft 方法，右移位使用 movePointRight 方法。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val = new BigDecimal("1234.5678");

// 小数点左移位
BigDecimal bd1 = val.movePointLeft(2);
System.out.println("bd1 --> " + bd1);

// 小数点右移位
BigDecimal bd2 = val.movePointRight(2);
System.out.println("bd2 --> " + bd2);

输出结果：

bd1 --> 12.345678
bd2 --> 123456.78

4.12 最大值和最小值

可以获取两个数的最大值和最小值，最大值使用 max 方法，最小值使用 min 方法。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1024");
BigDecimal val2 = new BigDecimal("2048");

// 取最小值
BigDecimal bd1 = val1.min(val2);
System.out.println("min --> " + bd1);

// 取最大值
BigDecimal bd2 = val1.max(val2);
System.out.println("max --> " + bd2);

输出结果：

min --> 1024
max --> 2048

4.13 转换方法

  • long longValue()：转换为 long 值
  • int intValue()：转换为 int 值
  • float floatValue()：转换为 float 值
  • double doubleValue()：转换为 double 值
  • BigInteger toBigInteger()：转换为 BigInteger对象
  • toString：转为 String 字符串，有必要时使用科学计数法
  • toEngineeringString：转为 String 字符串，有必要时使用工程计数法
  • toPlainString：转为 String 字符串，不使用任何计数法

五、舍入模式

BigDecimal 可以通过 setScale() 或 round() 方法来单独设置精度和舍入模式，不同的舍入模式返回的结果也会不同。我们在制定算法时，要先确定舍入模式。

舍入模式共有八种，可以从 RoundingMode 中查看，内容如下：

5.1 UP

从零舍入。只要检测到“废弃数”为非零，就往前入一。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.UP));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.UP));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.UP));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.UP));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.UP));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.UP));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.UP));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.UP));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.UP));

输出结果：

1.9      2
1.5      2
1.4      2
1.1      2
1.0      1
-1.0    -1
-1.4    -2
-1.5    -2
-1.9    -2

5.2 DOWN

舍入到零。永远舍掉“废弃数”，相当于截断。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.DOWN));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.DOWN));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.DOWN));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.DOWN));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.DOWN));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.DOWN));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.DOWN));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.DOWN));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.DOWN));

输出结果：

1.9      1
1.5      1
1.4      1
1.1      1
1.0      1
-1.0    -1
-1.4    -1
-1.5    -1
-1.9    -1

5.3 CEILING

向正无穷舍入。如果结果为正数，则表现为 RoundingMode.UP；如果为负数，则表现为 RoundingMode.DOWN。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.CEILING));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.CEILING));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.CEILING));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.CEILING));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.CEILING));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.CEILING));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.CEILING));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.CEILING));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.CEILING));

输出结果：

1.9      2
1.5      2
1.4      2
1.1      2
1.0      1
-1.0    -1
-1.4    -1
-1.5    -1
-1.9    -1

5.4 FLOOR

向负无穷舍入。如果结果为正数，则表现为 RoundingMode.DOWN ；如果为负数，则表现为 RoundingMode.UP。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.FLOOR));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.FLOOR));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.FLOOR));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.FLOOR));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.FLOOR));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.FLOOR));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.FLOOR));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.FLOOR));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.FLOOR));

输出结果：

1.9      1
1.5      1
1.4      1
1.1      1
1.0      1
-1.0    -1
-1.4    -2
-1.5    -2
-1.9    -2

5.5 HALF_UP

向“最接近的”数字舍入，也是我们通常说的“四舍五入”。

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.HALF_UP));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.HALF_UP));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.HALF_UP));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.HALF_UP));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.HALF_UP));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.HALF_UP));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.HALF_UP));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.HALF_UP));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.HALF_UP));

输出结果：

1.9      2
1.5      2
1.4      1
1.1      1
1.0      1
-1.0    -1
-1.4    -1
-1.5    -2
-1.9    -2

5.6 HALF_DOWN

向“最邻近”的数字舍入，也就是“五舍六入”

代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.6");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.HALF_DOWN));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.HALF_DOWN));

输出结果：

1.9      2
1.5      1
1.4      1
1.1      1
1.0      1
-1.0    -1
-1.4    -1
-1.5    -1
-1.9    -2

5.7 HALF_EVEN

该舍入模式分两种情况：如果“废弃数”左边的数字为奇数，则与 HALF_UP 相同；如果为偶数，则与 HALF_DOWN 相同。

“废弃数”左边的数字为奇数，代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("1.9");
BigDecimal val2 = new BigDecimal("1.5");
BigDecimal val3 = new BigDecimal("1.4");
BigDecimal val4 = new BigDecimal("1.1");
BigDecimal val5 = new BigDecimal("1.0");
BigDecimal val6 = new BigDecimal("-1.0");
BigDecimal val7 = new BigDecimal("-1.4");
BigDecimal val8 = new BigDecimal("-1.5");
BigDecimal val9 = new BigDecimal("-1.9");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.HALF_EVEN));

输出结果：

1.9      2
1.5      2
1.4      1
1.1      1
1.0      1
-1.0    -1
-1.4    -1
-1.5    -2
-1.9    -2

“废弃数”左边的数字为偶数，代码示例：

// 构造 BigDecimal 对象
BigDecimal val1 = new BigDecimal("2.6");
BigDecimal val2 = new BigDecimal("2.5");
BigDecimal val3 = new BigDecimal("2.4");
BigDecimal val4 = new BigDecimal("2.1");
BigDecimal val5 = new BigDecimal("2.0");
BigDecimal val6 = new BigDecimal("-2.0");
BigDecimal val7 = new BigDecimal("-2.4");
BigDecimal val8 = new BigDecimal("-2.5");
BigDecimal val9 = new BigDecimal("-2.6");

// 设置精度和舍入模式
System.out.println(val1 + "\t\t\t" + val1.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val2 + "\t\t\t" + val2.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val3 + "\t\t\t" + val3.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val4 + "\t\t\t" + val4.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val5 + "\t\t\t" + val5.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val6 + "\t\t"   + val6.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val7 + "\t\t"   + val7.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val8 + "\t\t"   + val8.setScale(0, RoundingMode.HALF_EVEN));
System.out.println(val9 + "\t\t"   + val9.setScale(0, RoundingMode.HALF_EVEN));

输出结果：

2.6      3
2.5      2
2.4      2
2.1      2
2.0      2
-2.0    -2
-2.4    -2
-2.5    -2
-2.6    -3

5.8 UNNECESSARY

断言所请求的操作具有精确的结果，因此不需要舍入。如果对获得精确结果的操作指定了此舍入模式，则会抛出 ArithmeticException 异常。

热门专栏

👍 《Python入门核心技术》
👍 《IDEA 教程：从入门到精通》
👍 《Java 教程：从入门到精通》
👍 《MySQL 教程：从入门到精通》
👍 《大数据核心技术从入门到精通》

在这里插入图片描述

水滴技术
关注
  • 14
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 16
    评论
专栏目录
java BigDecimal类精度计算用法练习——计算一年的工资
tcbdbd的博客
04-23 310
要求： 每个月基本工资16000元 每个月交社保为工资的10% 出差一天补贴80元 加班一小时40元 每年发17个月工资，最后5个月的工资 不算社保 最后一个月的工资 需要7%的税 问小明今天加班45天 每天加班4个小时 出差26天 他的总工资多少 精确到小数点后2位 源代码： package com.oracle.core; import java.math.BigDecimal; pu...
java BigDecimal 计算
qq_35226176的博客
12-12 305
BigDecimal基础计算
BigDecimal 货币计算(JAVA)
Y-CAT的专栏
06-05 1787
java中的简单浮点数类型float和double不能够进行运算。不光是Java，在其它很多编程语言中也有这样的问题。 在执行下面一段程序我们会看到什么： public class Test { public static void main(String args[]) { System.out.println(0.05 + 0.01)
【JavaBigDecimal练习】利用BigDecimal精确计算欧拉数
ankewlin的博客
09-03 449
利用BigDecimal精确计算欧拉数小数点后面1000位 相信大家对于泰勒展开已经熟记于心，接下来我们就利用下列的泰勒展开： ex=1+11!x+12!x2+13!x3+.......+1n!xn \qquad e^x = 1+\frac{1}{1!}x+\frac{1}{2!}x^2+\frac{1}{3!}x^3+.......+\frac{1}{n!}x^n ex=1+1!1​x+2!1​x2+3!1​x3+.......+n!1​xn 当展开式满足下列条件时：x=1 \qquad x =1x=
Java BigDecimal_abs大数练习
WORLD_NO_ONE的博客
04-04 157
Java BigDecimal_abs大数练习。
BigDecimal详解、代码示例和经常遇到的坑
最新发布
02-05
bigdecimal 详解、代码示例和经常遇到的坑
Java使用BigDecimal进行高精度计算的示例代码
08-29
Java 使用 BigDecimal 进行高精度计算的示例代码 在 Java 中，浮点类型的数值计算存在舍入误差的问题，因为浮点数不是精确值。因此，在进行高精度计算时，需要使用 BigDecimal 类来避免舍入误差。 首先，为什么...
Java BigDecimal详解_动力节点Java学院整理
08-30
Java BigDecimal详解 BigDecimal 是 Java 中的一个类，它由任意精度的整数非标度值和 32 位的整数标度 (scale) 组成。它主要用于商业计算、银行存款数额等场合，需要提供完全精确的结果。 知识点 1：BigDecimal 的...
Java中BigDecimal的基本运算(详解)
08-29
Java中BigDecimal的基本运算详解 Java中的BigDecimal是一种高精度的数据类型，它可以用来表示非常大的整数和小数，提供了丰富的数学运算功能。下面我们将对Java中BigDecimal的基本运算进行详细的介绍。 构造方法 ...
Java Bigdecimal使用原理详解
08-19
Java Bigdecimal使用原理详解 Java Bigdecimal是Java语言中用于精确计算的类，它可以完善float和double类无法进行精确计算的缺憾。...通过详细的示例代码，开发者可以更好地理解和使用BigDecimal类。
java练习代码之BigDecimal操作
code1Boy的博客
01-12 1075
java练习代码之BigDecimal操作 import org.junit.Test; import java.math.BigDecimal; /** * Created by shiqiang on 2018/1/11. */ public class Demo extends BaseJunit{ @Test public void getF() {
Java中BigDecimal类实现小数精确运算
刘小毅的博客
12-16 660
先来看一个例子： System.out.println(2.0 - 1.1); 结果为： 0.8999999999999999 很明显，这不是我们开发中需要的精度，我们需要得到更准确的结果。这里，引入BigDecimal类（Math包里的类），示例： import java.math.BigDecimal; BigDecimal bd1 = new BigDecimal(2.0); BigD...
Java使用BigDecimal精确计算的简单公式计算器
diba19990213的博客
07-26 281
由于工作需要,写了一个使用BigDecimal运算的精确计算的计算器(然后发现其实比不用BigDecimal的并好不到哪里去) 只能做加减乘除 double类型的数字在千万级别的时候会转成科学计数法,我这个不会(我估计能有方法不以科学计数法显示) 其中用到的知识就是中缀表达式转后缀表达式,我是从这里学的: http://www.cnblogs.com/mygmh/archive/...
java 四分位距算法和标准差
qq_41585350的博客
04-26 1211
import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class AlgorithmUtil { /** * 求四分位距 * * @param param * @return */ public static
Java BigDecimal 常用代码模版记录【持续更新，欢迎补充】
EJoft的博客
04-22 271
在电商领域，涉及到金额的遍历一般会使用 BigDecimal ，这里总结其常用的代码。 两数进行比较 比较两个金额是否相等，如 12 与 12.00，可以使用 compareTo 方法进行比较，如果返回0则相等，反之不相等。 private boolean moneyEqual(String a, String b) { return new BigDecimal(a).compareTo(new BigDecimal(b)) == 0; } @Test public void moneyEqua
Java进行数字计算 BigDecimal计算（加减乘除）
热门推荐
qq_492448446的博客
01-05 2万+
Java进行数字计算 BigDecimal计算（加减乘除）
java 中 BigDecimal 详解
鹏神丶明月天
07-29 3979
ROUND_HALF_EVEN//向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN。但是，在项目中，我们不可能让这种情况出现，特别是金融项目，因为涉及金额的计算都必须十分精确，你想想，如果你的支付宝账户余额显示193.99999999999998，那是一种怎么样的体验？，这边我们要避免这个错误产生，在进行除法运算的时候，针对可能出现的小数产生的计算，必须要多传两个参数。...
BigDecimal 舍入模式（Rounding mode）介绍
WGH100817的博客
11-20 2052
BigDecimal 舍入模式（Rounding mo...
Java中的Bigdecimal类型运算
架构师的方向
07-02 649
Java中的Bigdecimal类型运算 双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。Java在java.math包中提 供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。表5.7中列出了BigDecimal类的主要构造器和方法。 构造器 描 述 BigDecimal(int)创建
Java计算器实现与浮点数精确处理：BigDecimal应用
这是一份针对初学者和进阶者设计的Java教程，涵盖了计算器实现的细节、浮点数精度问题的解决方案，以及Java语言的核心知识点，旨在帮助学习者巩固Java编程技能，特别是对于理解和使用`BigDecimal`类进行精确计算的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水滴技术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值