四舍六入，奇进偶不进

于 2024-03-21 09:12:45 发布
阅读量835 收藏 2
点赞数 3
文章标签： java 前端 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYX3693/article/details/136896132
版权
文章详细介绍了Java中的数据修约规则，包括四舍六入和奇进偶不进的原则，以及RTS函数的具体实现，通过字符串截取和判断后位数值进行精确控制。
摘要由CSDN通过智能技术生成

数据修约规则

修约描述：四舍六入，奇进偶不进；保留n位有效数字时，第n+1位小于等于4时舍去，第n+1位大于等于6时进位。第n+1为5时，则判断第n+2位为奇数还是偶数，为奇数时进位，为偶数时不进位。

用法：=RTS(A1,n)，n为保留几位有效数字

例如：=RTS(1.23512,3)

值为1.24

原因：1.23后一位为5,5的后一位时1为奇数，需要进位，则为1.24

主要思路就是字符串截取，判断后一位的值，如果是5判断后两位的值

里面里面有不少重复判断代码，后续有空了再改改

    public static String RTS(String data, int numberCnt) {
        double num = Double.parseDouble(data);
        int pointPlace = data.indexOf("."); //小数点存在的位置
        if (data.contains(".") && data.length() < numberCnt) {
            //有效位数不够，补0
            int length = numberCnt - (data.length() - 1);
            for (int i = 0; i < length; i++) {
                data = data + 0;
            }
            return data;
        }
        //处理部分在小数
        if (data.contains(".") && pointPlace <= numberCnt) {
            int index = data.substring(0, numberCnt).contains(".") ? numberCnt + 1 : numberCnt;
            //保留的总位数是否够位
            if (data.length() - 1 >= numberCnt) {
                char c;
                //保留的数字为整数部分,判断小数点后一位
                if (index == numberCnt) {
                    c = data.charAt(index + 1);
                    if (c >= '6') { //
                        int i;
                        int add;
                        if (numberCnt == data.indexOf(".")) {
                            i = 1;
                            add = 10;
                        } else {
                            i = numberCnt - data.indexOf(".");
                            add = 1;
                        }
                        double pow = num * Math.pow(10, i);
                        pow = pow + add;
                        String s = String.valueOf(pow / Math.pow(10, i));
                        data = s.substring(0, index);

                    } else if (c <= '4') { //不变
                        data = data.substring(0, index);
                    } else if ((c == '5' && index + 1 < data.length())) {
                        //特殊情况  小数点的情况
                        if (numberCnt == data.indexOf(".")) {
                            if (data.length() - data.indexOf(".") == 2) { //先判断5后面还有没有值
                                data = data.substring(0, index);
                            } else if (data.charAt(index + 2) % 2 != 0) {
                                int i = numberCnt + 1 - data.indexOf(".");
                                double pow = num * Math.pow(10, i);
                                pow = pow + 10;
                                String s = String.valueOf(pow / Math.pow(10, i));
                                data = s.substring(0, index);
                            } else { //偶数不变
                                data = data.substring(0, index);
                            }
                        } else {
                            if (data.charAt(index + 1) % 2 != 0) { //奇数进一
                                int i = numberCnt + 1 - data.indexOf(".");
                                double pow = num * Math.pow(10, i);
                                pow = pow + 10;
                                String s = String.valueOf(pow / Math.pow(10, i));
                                data = s.substring(0, index);
                            } else { //偶数不变
                                data = data.substring(0, index);
                            }
                        }
                    } else {
                        data = data.substring(0, index);
                    }
                    return data;
                } else if (index == data.length()) {
                    return data;
                } else {
                    c = data.charAt(index);
                    if (c >= '6') { //
                        int i;
                        int add;
                        if (numberCnt == data.indexOf(".")) {
                            i = 1;
                            add = 10;
                        } else {
                            i = numberCnt - data.indexOf(".");
                            add = 1;
                        }
                        double pow = num * Math.pow(10, i);
                        pow = pow + add;
                        String s = String.valueOf(pow / Math.pow(10, i));
                        data = s.substring(0, index);

                    } else if (c <= '4') { //不变
                        data = data.substring(0, index);
                    } else if ((c == '5' && index + 1 < data.length())) {
                        //特殊情况  小数点的情况
                        if (numberCnt == data.indexOf(".")) {
                            if (data.length() - data.indexOf(".") == 2) { //先判断5后面还有没有值
                                data = data.substring(0, index);
                            } else if (data.charAt(index + 2) % 2 != 0) {
                                int i = numberCnt + 1 - data.indexOf(".");
                                double pow = num * Math.pow(10, i);
                                pow = pow + 10;
                                String s = String.valueOf(pow / Math.pow(10, i));
                                data = s.substring(0, index);
                            } else { //偶数不变
                                data = data.substring(0, index);
                            }
                        } else {
                            if (data.charAt(index + 1) % 2 != 0) { //奇数进一
                                int i = numberCnt + 1 - data.indexOf(".");
                                double pow = num * Math.pow(10, i);
                                pow = pow + 10;
                                String s = String.valueOf(pow / Math.pow(10, i));
                                data = s.substring(0, index);
                            } else { //偶数不变
                                data = data.substring(0, index);
                            }
                        }
                    } else {
                        data = data.substring(0, index);
                    }
                    return data;
                }
            } else {
                //补0
                for (int i = 0; i < numberCnt - (data.length() - 1); i++) {
                    data = data + 0;
                }
            }
            //保留的部分在整数部分
        } else if (numberCnt <= pointPlace - 1) {
            //保留的最后一位小数前最后一位
            if (numberCnt + 1 == pointPlace) {
                if (data.charAt(numberCnt) <=  '4') {
                    data = data.substring(0, numberCnt);
                    data = data + 0;
                } else if(data.charAt(numberCnt) >=  '6') {
                    data = data.substring(0, numberCnt);
                    double newStr = Double.parseDouble(data);
                    newStr = newStr + 1;
                    data = String.valueOf(newStr * Math.pow(10, 1));
                }else if(data.charAt(numberCnt) ==  '5'){
                    if (data.charAt(numberCnt + 2) % 2 != 0){
                        data = data.substring(0, numberCnt);
                        double newStr = Double.parseDouble(data);
                        newStr = newStr + 1;
                        data = String.valueOf(newStr * Math.pow(10, 1));
                        if (data.contains(".")) {
                            data = data.substring(0, data.indexOf("."));
                        }
                    }else {
                        data = data.substring(0, numberCnt);
                        data = data + 0;
                    }
                }
            } else {
                //剩下的处理逻辑和整数部分相同
                data = data.substring(0, data.indexOf("."));
                int differ = data.length() - numberCnt;
                char c = data.charAt(numberCnt);
                if (c >= '6') {
                    data = data.substring(0, numberCnt);
                    double newStr = Double.parseDouble(data);
                    newStr = newStr + 1;
                    data = String.valueOf(newStr * Math.pow(10, differ));
                } else if (c <= '4') {
                    data = data.substring(0, numberCnt);
                    for (int i = 0; i < differ; i++) {
                        data = data + 0;
                    }
                } else if (c == '5') {
                    if (numberCnt == data.length() - 1) { //先判断5后面还有没有值
                        data = data.substring(0, numberCnt);
                        data = data + 0;
                    } else if (data.charAt(numberCnt + 1) % 2 != 0) {
                        data = data.substring(0, numberCnt);
                        double newStr = Double.parseDouble(data);
                        newStr = newStr + 1;
                        data = String.valueOf(newStr * Math.pow(10, differ));
                        //结果包含.0 去除
                        if (data.contains(".")) {
                            data = data.substring(0, data.indexOf("."));
                        }
                    } else { //偶数不变
                        data = data.substring(0, numberCnt);
                        for (int i = 0; i < differ; i++) {
                            data = data + 0;
                        }
                    }
                }
            }
        } else {
            //处理数据为整数
            if (data.length() <= numberCnt) {
                return data;
            } else {
                int differ = data.length() - numberCnt;
                char c = data.charAt(numberCnt);
                if (c >= '6') {
                    data = data.substring(0, numberCnt);
                    double newStr = Double.parseDouble(data);
                    newStr = newStr + 1;
                    data = String.valueOf(newStr * Math.pow(10, differ));
                } else if (c <= '4') {
                    data = data.substring(0, numberCnt);
                    for (int i = 0; i < differ; i++) {
                        data = data + 0;
                    }
                } else if (c == '5') {
                    if (numberCnt == data.length() - 1) { //先判断5后面还有没有值
                        data = data.substring(0, numberCnt);
                        data = data + 0;
                    } else if (data.charAt(numberCnt + 1) % 2 != 0) {
                        data = data.substring(0, numberCnt);
                        double newStr = Double.parseDouble(data);
                        newStr = newStr + 1;
                        data = String.valueOf(newStr * Math.pow(10, differ));
                        //结果包含.0 去除
                        if (data.contains(".")) {
                            data = data.substring(0, data.indexOf("."));
                        }
                    } else { //偶数不变
                        data = data.substring(0, numberCnt);
                        for (int i = 0; i < differ; i++) {
                            data = data + 0;
                        }
                    }
                }
            }
        }
        return data;
    }

LYX3693
关注
自己写的Oracle四舍六入奇进偶不进的函数
05-15
自己写的Oracle四舍六入奇进偶不进的函数，实现了四舍六入五单进的修约规则，已经测试通过，并应用到项目中了！
自己写的sql server四舍六入奇进偶不进的函数
05-15
自己写的sql server四舍六入奇进偶不进的函数，实现了四舍六入五单进的修约规则，已经测试通过，并应用到项目中了！
关于C# Math 处理奇进偶不进
weixin_30822451的博客
05-13 479
　　　　话说，最近一次系统维护 用JS读取导入Excel中的实验数据，出现被自动四舍五入。后来到客户现场听客户反馈 Excel实验数据要求 奇进偶不进。 关于 奇进偶不进 产生的由来：从统计学的角度，“奇进偶舍”比“四舍五入”要科学，在大量运算时，它使舍入后的结果误差的均值趋于零，而不是像四舍五入那样逢五就入，导致结果偏向大数，使得误差产生积累进而产生系统误差，“奇进偶舍...
java实现奇进偶不进原则
ychjava的博客
11-28 1206
java完整代码地址：https://www.52zsku.com/upload/detail/2c91808d6e6e328a016e7d0120da000c.html
“4舍6入5看齐，奇进偶不进”与“四舍五入”的区别
热门推荐
慕言小鹏
05-06 4万+
“4舍6入5看齐,奇进偶不进”我觉得并不是因为浮点数在计算机表示的问题。计算机浮点数的表示是 ieee 定义的标准规则，如果 python 中存在，没道理其他语言中不存在。事实上是因为该取舍方法比过去的 "四舍五入" 方法在科学计算中更准确。而国家标准也已经规定使用 “4舍6入5看齐,奇进偶不进” 取代"四舍五入".从统计学的角度上来讲,如果大量数据无脑的采用四舍五入会造成统计结果偏大。而"奇进偶...
自己写的vb四舍六入奇进偶不进的excle中的函数
05-15
自己写的vb四舍六入奇进偶不进的函数，excle函数，已经测试通过，并应用到实际的项目中了，可放心使用
Excel表中如何实现“四舍六入-逢五奇进偶舍”.doc
最新发布
10-20
在Excel表格中，有时我们需要按照特定的规则进行数值的四舍六入，即“逢五奇进偶舍”。这种规则通常在计量领域中被广泛采用，以减少测量误差。在Excel的标准函数中，并没有直接提供符合这一规则的内置函数。但用户...
关于C# Math 处理奇进偶不进的实现代码
09-02
"奇进偶不进"（又称Banker's Rounding或Rounding to Even）是一种舍入规则，它的核心思想是在遇到四舍五入中点值时，如果这个中点值是偶数则保留不变，如果是奇数则向上舍入。这种方法在统计学和金融计算中广泛应用...
js奇进偶舍
05-01
js奇进偶舍,经测试已用到项目中
round函数四舍五入的规则（4舍6入5奇进偶不进）
jlbaowei的专栏
01-09 8178
round(12.25) =12.2round(12.35) =12.4c#四舍五入     Decimal d= (Decimal)  12.35d.ToString("0.0") //保留1位小数 vb.net四舍五入     format("12.35","0.0")
python random.round 修约方法 4舍6入5看齐,奇进偶不进
weixin_39454561的博客
02-13 1万+
奇进偶不进 根据国家标准的有关规定，过去所采用的“四舍五入”的方法早已被“4舍6入5看齐，奇进偶不进”的方法所取代。 就是说，拟舍弃数小于5时，均应按“四舍五入”的方法舍弃;拟舍弃数大于或等于6时，则应按“四舍五入”的方法进入; 只有拟舍弃数是5时，则应看其前一位数是奇数还是偶数，如是奇数则进入，如是偶数则舍弃。这样取舍的优点是相对准确，在计算结构百分比时一般不会出现超过100%的现象。 数值修约...
修约函数，四舍六入五看齐，奇进偶不进的C++实现方法
qq_64303606的博客
05-24 1425
修约函数，四舍六入五看齐，奇进偶不进的C++实现方法
Android 四舍五入，设置double，保留num位小数
谁对谁错重要吗的博客
03-29 942
public static String limitDouble2(double d, int num) { String d2 = String.format("%."+num+"f", d); return new BigDecimal(d2).toString(); }
四舍六入五考虑
kmblack1的专栏
07-07 3833
C版本 /*四舍六入五考虑 当有效位数后一位的数字≤4时，其后的数字直接舍去； 当有效位数后一位的数字≥6时，其后数字舍去并进1； 当有效位数后一位的数字=5时，要分两种情况： 5后面一位的数字如果不等于0，则舍5进1； 5后面一位数字如果等于0，又要分两种情况： 5的前面如果是奇数，则舍5进1； 5的前面如果是偶数，则舍5不进 */ double roundex(double val, dou
Math.Round 四舍六入 五取偶（奇进偶不进）
chencong2005100的博客
03-11 2814
Math.Round(1.565, 2, MidpointRounding.AwayFromZero); 不加MidpointRounding.AwayFromZero参 得到的数是：1.56 加MidpointRounding.AwayFromZero=中国式的四舍五入法 得到：1.57 ...
//四舍六入 五 奇进偶舍
weixin_44178762的博客
05-25 1062
//四舍六入 五 奇进偶舍 num 表示要去约的数 n表示保留小数位 public double getint(double num ,int n) { double pow = Math.pow(10, n);//10n次方 double v = num * pow; String s = String.valueOf(v); String[] split = s.split("\\.");//通过.切割 if.
解决Python round函数，奇进偶不进的问题
qhjink的博客
07-04 1403
解决Python round函数，奇进偶不进的问题 def newRound(data,num): import math try: data = float(data) except : return "非数字不能处理" return int((data * math.pow(10,int(num)) + 0.5))/math.pow(10,int(num)) ...
逢五进一的RoundClassic函数，解决银行家ROUND算法——逢六进一，奇进偶不进。
doloopcn的博客
07-23 2974
记得前段时间有论坛有讨论过Round函数不能进一的问题，自己在项目中竟然也同样遇到了情况，查看了资料才发现，DELPHI用的Round竟然是银行家算法：奇进偶不进，逢六进一。 论坛上也有银行家算法的介绍：https://blog.csdn.net/gjtao1130/article/details/8118379 百般无奈，只能手工想办法修改了，写了一个RoundClassic函数，算法可能有点...
JavaScript奇进偶舍算法实现
在JavaScript中，`formatFloat`函数的主要任务是将一个数字按照指定的小数位数进行四舍五入，并遵循“奇进偶舍”的原则。这种方法常用于金融计算中，以避免因四舍五入导致的累积误差。下面是对`formatFloat`函数实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值