BigDecimal舍位模式与有效精度 -----商业与科学计算

最新推荐文章于 2023-12-27 17:18:42 发布
最新推荐文章于 2023-12-27 17:18:42 发布
阅读量992 收藏
点赞数
分类专栏： 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeu12331/article/details/81986053
版权

发现身边不少同事在金融业务场景计算中使用近似计算，感到非常惊讶。
基于二进制有时无法精确地表示一个包含小数的数值，只能采用近似表示，这还不是最糟糕，更糟糕的是，我们在二进制表示的近似值上，利用计算机运算电路来计算得到的误差可能进一步放大,这种方式的唯一好处就是运算速度快，但可能无法得到精确的运算数值。
基于二进制有时无法精确地表示一个包含小数的数值，只能采用近似表示。因此，我们会发现0.3+0.3 !=0.6,对于有严格精确度要求的业务场景下是不能这么用。
为了实现精确计算，我们可以开发一个十进制运算的计算器程序，这样我们就能利用该程序进行运算处理，得到精确结果。这个计算器就是BigDecimal。

这里我们主要关注的是BigDecimal的舍位模式与有效数字位数设置

BigDecimal舍位模式：

ROUND_UP
进位舍入模式，在舍弃部分非零情况下，向前进位加1，始终增加数字(始终对非零舍弃部分前面的数字加1)。 
ROUND_DOWN
截断舍入模式，始终不进位。注意，此舍入模式始终不会增加计算值的大小。

ROUND_CEILING
舍入模式朝向正无穷大，如果BigDecimal是正的，则表现为ROUND_UP；如果为负，则表现为ROUND_DOWN。请注意，此舍入模式永远不会降低计算值。 

ROUND_FLOOR
舍入模式朝向负无穷大，如果BigDecimal是正的，则表现为ROUND_DOWN；如果为负，则表现为ROUND_UP。请注意，此舍入模式永远不会增加计算值。

ROUND_HALF_UP
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，在这种情况下。如果舍弃部分大于等于0.5，则表现为ROUND_UP，否则，表现为ROUND_DOWN

ROUND_HALF_DOWN
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，在这种情况下。如果舍弃部分大于0.5，则表现为ROUND_UP；否则，表现为ROUND_DOWN。 

ROUND_HALF_EVEN（银行家舍入法）
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，在这种情况下，则向相邻的偶数舍入。即：
如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP相同;
如果舍弃部分左边的数字为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。

注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。

ROUND_UNNECESSARY
断言请求的操作具有精确的结果，因此不需要舍入。
指定此舍入模式时，如果无法获得精确结果，则抛出ArithmeticException


MathContext 运算上下文(设置有效数字位数)
new MathContext(6, RoundingMode.UP)
6：表示最大有效数字位数为6位。（有效精度即：从左边第一个不是0的数字起，到末位数止），有效数字位数越多，精度越高，计算越准确（属于数学范畴，大家应该都能明白）
RoundingMode.UP：处理有效精度时可能需要用到的舍位模式

示例代码如下：

public class BigDecimalTest {

    public static void main(String[] args) {
        
        Double a = 0.66666663;
        Double b = 0.33333332;    
        Double c= a+b;
        System.out.println("a="+a.toString());
        System.out.println("b="+b.toString());
        System.out.println("c="+c.toString());
                        
        BigDecimal amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_UP);
        System.out.println("BigDecimal.ROUND_UP: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_UP);
        System.out.println("BigDecimal.ROUND_UP: 123.5523 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_UP);
        System.out.println("BigDecimal.ROUND_UP: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_DOWN);
        System.out.println("BigDecimal.ROUND_DOWN: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_DOWN);
        System.out.println("BigDecimal.ROUND_DOWN: 123.5523 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_DOWN);
        System.out.println("BigDecimal.ROUND_DOWN: 123.5423 ="+amount.toString());
        
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_CEILING);
        System.out.println("BigDecimal.ROUND_CEILING: 123.5623 ="+amount.toString());
    
        amount = new BigDecimal("-123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_CEILING);
        System.out.println("BigDecimal.ROUND_CEILING: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_CEILING);
        System.out.println("BigDecimal.ROUND_CEILING: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("-123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_CEILING);
        System.out.println("BigDecimal.ROUND_CEILING: -123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_FLOOR);
        System.out.println("BigDecimal.ROUND_FLOOR: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("-123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_FLOOR);
        System.out.println("BigDecimal.ROUND_FLOOR: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_FLOOR);
        System.out.println("BigDecimal.ROUND_FLOOR: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("-123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_FLOOR);
        System.out.println("BigDecimal.ROUND_FLOOR: -123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("-123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("-123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: -123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("-123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_UP);
        System.out.println("BigDecimal.ROUND_HALF_UP: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("-123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("-123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: -123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("-123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("BigDecimal.ROUND_HALF_DOWN: -123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.5423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.2623");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.2623 ="+amount.toString());
        
        amount = new BigDecimal("123.2423");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.2423 ="+amount.toString());
        
        
        amount = new BigDecimal("123.5523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.5623 ="+amount.toString());
        
        amount = new BigDecimal("123.6523");
        amount = amount.setScale(1, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("BigDecimal.ROUND_HALF_EVEN: 123.5423 ="+amount.toString());
        
        amount = new BigDecimal("123.5623");
        amount = amount.abs(new MathContext(8, RoundingMode.UP));//用于数值有效数字位数设置
        System.out.println("BigDecimal.ROUND_UP: 123.5623 ="+amount.toString());
        
        amount = amount.abs(new MathContext(6, RoundingMode.UP));//用于数值有效数字位数设置
        System.out.println("BigDecimal.ROUND_UP: 123.5623 ="+amount.toString());
        
        amount = amount.abs(new MathContext(4, RoundingMode.UP));//用于数值有效数字位数设置
        System.out.println("BigDecimal.ROUND_UP: 123.5623 ="+amount.toString());
        
        amount = amount.abs(new MathContext(2, RoundingMode.UP));//用于数值有效数字位数设置
        System.out.println("BigDecimal.ROUND_UP: 123.5623 ="+amount.toString());
        
    }
}
 

 

 

 

漠刀
关注
专栏目录
精确到两位有效精度
rypen的博客
01-23 1270
今天，产品同学兴致冲冲的给我提了个小小的需求，面带微笑的说：小哥哥小哥哥，由于韩元的汇率很低，能不能把韩元的估值小数位精确到两位有效的精度？ 具体我来解释一下，例如：0.0002345要处理成0.00023，0.0112345处理成0.011，就是说小数点后最多只能看到两个大于0的数字。 了解到这个问题之后我嘴角微微一笑，小case，不就是字符串的截取么。事实也是如此，字符串动态截取完全能实现...
Java BigDecimal详解--double 精度计算
sooxin的专栏
08-22 2993
Java BigDecimal详解   1.引言 　　float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。 先看下面代码 ...
BigDecimal讲解简介（二）
习惯有你&的博客
04-27 515
Java中BigDecimal的8种舍入模式 1、ROUND_UP 　　舍入远离零的舍入模式。 　　在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。 　　注意,此舍入模式始终不会减少计算值的大小。 　　2、ROUND_DOWN 　　接近零的舍入模式。 　　在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1,即截短)。 　　注意,此舍入模式始终不会增
java使用BigDecimal 处理商业精度及高精度详解
山鬼谣的专栏
11-15 3904
前言之前我是写过一篇类似笔记： java处理高精度的商业计算但是呢，写的太简单，关键还没有写到要点，所以重新写一篇。情形由于公司最近要求把股票相关的数据，全部交给后端来处理，不再由前端来处理。 股票大家都知道，这里面的计算都是商业级别的，小数点4+位那是再正常不过啦。 比如这样几组数字2539230979.0000 //流通受限股份 8680253870 //某个股东持股数 0.4081 //某
Java 科学计算之 BigDecimal 全集
风尘博客
06-17 695
一、BigDecimal的产生背景 首先我们先来看如下代码示例： @Test public void countDemo() { logger.info("result:{}", 0.06 + 0.01); logger.info("result:{}", 1.0 - 0.42); logger.info("result:{}", 4.015 * 100); logger.info("result:{}", 303.1 / 1000); } 结果如下 result:0.06
decimal java 位数_java – 找到BigDecimal中有效位数的简洁方法？
weixin_39572152的博客
02-17 778
我相信你想要一个stripTrailingZeros,precision和scale的组合,如下所示：import java.math.*;public class Test {public static void main(String[] args) {test("5000"); // 4test("5000.00"); // 4test("5000.12"); // 6te...
bigdecimal除法不四舍五入_BigDecimal四舍五入与保留位
weixin_35117981的博客
12-29 5488
1.引言借用《Effactive Java》这本书中的话，float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。2.BigDecimal简介BigDeci...
Double类型精度问题&&BigDecimal用法
Slovef的博客
06-17 1582
Double类型精度问题&&BigDecimal用法 一. Double 代码 @Test public void testDouble() { double a = 0.1; double b = 0.2; double c = 0.3; System.out.println(a + b); System.out.println(c - a); Syste...
mathcontext保留2位小数_BigDecimal 小数 浮点数 精度 财务计算
weixin_34596012的博客
12-24 1677
简介float和double类型的使用局限：单精度浮点型变量float可以处理6~7位有效数，双精度浮点型变量double可以处理15~16位有效数，在实际应用中，如果需要对更大或者更小的数进行运算和处理，这时候float和double就如能为力了。借用《Effactive Java》这本书中的话，float和double类型的主要设计目标是为了科学计算和工程计算，他们执行二进制浮点运算，这是为了...
Java中BigDecimal的加减乘除、比较大小与使用注意事项
08-28
这是因为`float`和`double`类型虽然适用于科学计算和工程计算，但它们基于二进制浮点运算，不能保证完全精确的结果。而`BigDecimal`类提供了对任意精度的十进制数的支持，确保了商业计算中的准确性。 ### `...
BigDecimal舍入模式总结及运用场景分析
独码乐，不如众码乐，乐享其中
08-14 1710
数字舍入模式setScale()常见的共7种： ROUND_UP：从零舍入。始终在非零丢弃分数之前增加数字。 ROUND_DOWN：向零舍入。 ROUND_HALF_UP：向“最近的邻居”舍入，除非两个邻居是等距的，此时向上舍入。 ROUND_HALF_DOWN：向“最近的邻居”舍入，除非两个邻居是等距的，此时向下舍入。 ROUND_HALF_EVEN：向“最近的邻居”舍入，除非两个邻居是等距的，向偶数邻居舍入。 ROUND_CEILING：向正无穷大舍入。 ROUND_FLOOR：向负无穷大舍入。....
BigDecimal 超过16位有效位的数进行精确运算
夏安的博客
08-05 5107
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算...
BigDecimal里面八种舍位模式
热门推荐
admin_15082037343的博客
04-16 1万+
BigDecimal.ROUND_UP 翻译：舍入模式从零舍入。始终在丢弃非零小数之前递增数字。请注意，此舍入模式永远不会减小计算值的大小。 不论正负，保留精度之前的数字加一 0.123456789 保留四位小数结果为：0.1235 -0.123456789 保留四位小数结果为：-0.1235 BigDecimal.ROUND_DOWN 翻译：舍入模式向零舍入。切勿在舍弃小数（即截断）之前增加数字。请注意，这种舍入模式永远不会增加计算值的大小。 不论正负，保留精度之后的数字直接截掉（丢弃） 0.12.
关于BigDecimal精度部分总结
旋转丶木马的博客
11-01 484
关于BigDecimal精度部分总结 BigDecimal类概述 Java中提供了大数字（超过16位有效位）的操作类，即java.math.BigInteger类和java.math.BigDecimal类，用高精度计算。其中BigInteger类是针对大整数的处理类，BigDecimal 类则是针对大小数的处理类。 在商业计算中,对数字精度要求较高,必须使用 BigInteger 类和 BigD...
BigDecimal 八种舍入模式介绍
LX2016341134的博客
04-29 6579
BigDecimal 八种舍入模式介绍 一、BigDecimal 简介 二、BigDecimal 的舍入模式 ROUND_UP ROUND_DOWN ROUND_CEILING ROUND_FLOOR ROUND_HALF_UP ROUND_HALF_DOWN ROUND_HALF_EVEN ROUND_UNNECESSARY 三、BigDecimal 常用方法
关于BigDecimal
siege
08-31 364
关于BigDecimal
BigDecimal四舍五入用法介绍
a1k2l45k的博客
12-27 5270
BigDecimal.setScale() 方法可以将 BigDecimal 对象四舍五入后保留指定小数位数，其中第一个参数表示小数点后保留的位数，第二个参数表示使用四舍五入策略。其中，ROUND_HALF_UP 是 BigDecimal 官方提供的四舍五入策略，表示直接将舍去部分加 0.5 后再进行向上舍入。
java.math.BigDecimal保留两位有效数字
每天进步一点
07-28 2236
java例子： double abc = 1.234567890; new java.math.BigDecimal(abc).setScale(2,java.math.BigDecimal.ROUND_HALF_UP).doubleValue()); setScale（）方法的第一位为小数点后面的位数！若小数点后面的位数小于setScale（）方法所设定...
bigdecmail 到文本_java中如何使用BigDecimal使得Double类型保留两位有效数字
weixin_39589511的博客
12-19 295
一、场景：从数据表中读出Decimal类型的数据直接塞给Double类型的对象时，并不会有什么异常。如果要再此基础上计算，就会发生异常。比如：读出数据为0.0092，将其乘以100，则变成了0.919999999999999...二、原因：java mysql 数据类型对照如下：类型名称显示长度数据库类型JAVA类型JDBC类型索引(int)描述VARCHARL+NVARCHARjava.lang...
bigdecimal转化为string出现0E-10
最新发布
09-20
当你使用`BigDecimal`转换为字符串时，遇到`0E-10`这样的表示，这是因为`BigDecimal`在进行精度较低的小数表示时，会采用科学计数法来节省空间，并显示成这种形式。这里的`0E-10`意味着零乘以十的负十次方，即小数点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值