Java中BigDecimal类及8种舍入模式

最新推荐文章于 2024-01-11 17:04:30 发布
最新推荐文章于 2024-01-11 17:04:30 发布
阅读量222 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45283443/article/details/109057137
版权 
package com.fenxiang.social.mall.sellerbase;

/**
 * @Description TODO
 * @Date 2020/10/13 17:03
 * @Created by renchengpeng
 */

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class rcp {

    /** 默认的数据精度 , 采用比较常用的2位 */
    private static final int DEF_SCALE = 2;

    /** 正数样本 */
    private static final List<BigDecimal> BIG_DECIMAL_STREAM = Arrays.asList(
            new BigDecimal("1.230"),
            new BigDecimal("1.231"),
            new BigDecimal("1.234"),
            new BigDecimal("1.235"),
            new BigDecimal("1.236"),
            new BigDecimal("1.239"));

    /** 负数样本 */
    private static final List<BigDecimal> _BIG_DECIMAL_STREAM = BIG_DECIMAL_STREAM.stream().map(BigDecimal.ZERO::subtract).collect(Collectors.toList());

    public static void main(String[] args) throws Exception {
        /**
         *  1.230 > ROUND_CEILING >  1.23
         *  1.231 > ROUND_CEILING >  1.24
         *  1.234 > ROUND_CEILING >  1.24
         *  1.235 > ROUND_CEILING >  1.24
         *  1.236 > ROUND_CEILING >  1.24
         *  1.239 > ROUND_CEILING >  1.24
         *
         * -1.230 > ROUND_CEILING > -1.23
         * -1.231 > ROUND_CEILING > -1.23
         * -1.234 > ROUND_CEILING > -1.23
         * -1.235 > ROUND_CEILING > -1.23
         * -1.236 > ROUND_CEILING > -1.23
         * -1.239 > ROUND_CEILING > -1.23
         */
//        ROUND_CEILING();//向上进位 (接近正无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;如果为负，则舍入行为与 ROUND_DOWN 相同。)

        /**
         *  1.230 > ROUND_FLOOR >  1.23
         *  1.231 > ROUND_FLOOR >  1.23
         *  1.234 > ROUND_FLOOR >  1.23
         *  1.235 > ROUND_FLOOR >  1.23
         *  1.236 > ROUND_FLOOR >  1.23
         *  1.239 > ROUND_FLOOR >  1.23
         *
         * -1.230 > ROUND_FLOOR > -1.23
         * -1.231 > ROUND_FLOOR > -1.24
         * -1.234 > ROUND_FLOOR > -1.24
         * -1.235 > ROUND_FLOOR > -1.24
         * -1.236 > ROUND_FLOOR > -1.24
         * -1.239 > ROUND_FLOOR > -1.24
         */
        ROUND_FLOOR();//向下舍位 (接近负无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;如果为负，则舍入行为与 ROUND_UP 相同。)

        /**
         *  1.230 > ROUND_HALF_UP >  1.23
         *  1.231 > ROUND_HALF_UP >  1.23
         *  1.234 > ROUND_HALF_UP >  1.23
         *  1.235 > ROUND_HALF_UP >  1.24
         *  1.236 > ROUND_HALF_UP >  1.24
         *  1.239 > ROUND_HALF_UP >  1.24
         *
         * -1.230 > ROUND_HALF_UP > -1.23
         * -1.231 > ROUND_HALF_UP > -1.23
         * -1.234 > ROUND_HALF_UP > -1.23
         * -1.235 > ROUND_HALF_UP > -1.24
         * -1.236 > ROUND_HALF_UP > -1.24
         * -1.239 > ROUND_HALF_UP > -1.24
         */
//        ROUND_HALF_UP();//四舍五入

        /**
         *  1.230 > ROUND_HALF_DOWN >  1.23
         *  1.231 > ROUND_HALF_DOWN >  1.23
         *  1.234 > ROUND_HALF_DOWN >  1.23
         *  1.235 > ROUND_HALF_DOWN >  1.23
         *  1.236 > ROUND_HALF_DOWN >  1.24
         *  1.239 > ROUND_HALF_DOWN >  1.24
         *
         * -1.230 > ROUND_HALF_DOWN > -1.23
         * -1.231 > ROUND_HALF_DOWN > -1.23
         * -1.234 > ROUND_HALF_DOWN > -1.23
         * -1.235 > ROUND_HALF_DOWN > -1.23
         * -1.236 > ROUND_HALF_DOWN > -1.24
         * -1.239 > ROUND_HALF_DOWN > -1.24
         */
//        ROUND_HALF_DOWN();//五舍六入


        /**
         *  1.230 > ROUND_UP >  1.23
         *  1.231 > ROUND_UP >  1.24
         *  1.234 > ROUND_UP >  1.24
         *  1.235 > ROUND_UP >  1.24
         *  1.236 > ROUND_UP >  1.24
         *  1.239 > ROUND_UP >  1.24
         *
         * -1.230 > ROUND_UP > -1.23
         * -1.231 > ROUND_UP > -1.24
         * -1.234 > ROUND_UP > -1.24
         * -1.235 > ROUND_UP > -1.24
         * -1.236 > ROUND_UP > -1.24
         * -1.239 > ROUND_UP > -1.24
         */
//        ROUND_UP();//绝对值向上进位(舍入远离零的舍入模式。在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。)

        /**
         *  1.230 > ROUND_DOWN >  1.23
         *  1.231 > ROUND_DOWN >  1.23
         *  1.234 > ROUND_DOWN >  1.23
         *  1.235 > ROUND_DOWN >  1.23
         *  1.236 > ROUND_DOWN >  1.23
         *  1.239 > ROUND_DOWN >  1.23
         *
         * -1.230 > ROUND_DOWN > -1.23
         * -1.231 > ROUND_DOWN > -1.23
         * -1.234 > ROUND_DOWN > -1.23
         * -1.235 > ROUND_DOWN > -1.23
         * -1.236 > ROUND_DOWN > -1.23
         * -1.239 > ROUND_DOWN > -1.23
         */
//        ROUND_DOWN();//绝对值向下舍位(接近零的舍入模式。在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1，即截短)。)

//        ROUND_HALF_EVEN();//银行家算法 四舍六入 五看前数 奇进偶舍

        /**
         *  1.230 > UNNECESSARY >  1.230
         *  1.231 > UNNECESSARY >  1.231
         *  1.234 > UNNECESSARY >  1.234
         *  1.235 > UNNECESSARY >  1.235
         *  1.236 > UNNECESSARY >  1.236
         *  1.239 > UNNECESSARY >  1.239
         *
         * -1.230 > UNNECESSARY > -1.230
         * -1.231 > UNNECESSARY > -1.231
         * -1.234 > UNNECESSARY > -1.234
         * -1.235 > UNNECESSARY > -1.235
         * -1.236 > UNNECESSARY > -1.236
         * -1.239 > UNNECESSARY > -1.239
         */
//        ROUND_UNNECESSARY();//不舍位 , 精度位数小于小数位数会抛出异常
    }

    /**
     * BigDecimal.ROUND_CEILING 向上进位 .
     *      若当前精度位后一位数字不为0 , 则向上进位
     *      数字更大
     */
    private static void ROUND_CEILING() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_CEILING >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_CEILING)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_CEILING > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_CEILING)));
    }

    /**
     * BigDecimal.ROUND_FLOOR 向下舍位 .
     *      若当前精度位后一位数字不为0 , 则向下舍位
     *      数字更小
     */
    private static void ROUND_FLOOR() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_FLOOR >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_FLOOR)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_FLOOR > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_FLOOR)));
    }

    /**
     * BigDecimal.ROUND_HALF_UP , 4舍5入 .
     *      正数4舍5进 , 负数4舍5退(-1.234 -> -1.23 ; -1.235 -> -1.24)
     */
    public static void ROUND_HALF_UP() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_HALF_UP >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_UP)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_HALF_UP > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_UP)));
    }

    /**
     * BigDecimal.ROUND_HALF_DOWN , 5舍6入
     *      正数5舍6进 , 负数5舍6退(-1.235 -> -1.23 ; -1.236 -> -1.24)
     */
    public static void ROUND_HALF_DOWN() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_HALF_DOWN >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_DOWN)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_HALF_DOWN > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_DOWN)));
    }

    /**
     * BigDecimal.ROUND_HALF_EVEN , 银行家算法 . 4舍6入 , 5看前数  , 奇进偶舍
     *      正数4舍6进 , 5看前一位数字 , 若为奇数则进位 , 若为偶数则舍位
     *      负数5舍6退(-1.235 -> -1.23 ; -1.236 -> -1.24)
     */
    public static void ROUND_HALF_EVEN() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_HALF_EVEN >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_EVEN)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_HALF_EVEN > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_EVEN)));
        System.out.println();
        BigDecimal bd = new BigDecimal("0.01");
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal.add(bd) + " > ROUND_HALF_EVEN >  " + bigDecimal.add(bd).setScale(DEF_SCALE, BigDecimal.ROUND_HALF_EVEN)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal.add(bd) + " > ROUND_HALF_EVEN > " + bigDecimal.add(bd).setScale(DEF_SCALE, BigDecimal.ROUND_HALF_EVEN)));
    }

    /**
     * BigDecimal.ROUND_UP , 绝对值向上进位 .
     *      若当前精度位后一位数字不为0 , 则绝对值向上进位
     *      正数更大 , 负数更小
     */
    public static void ROUND_UP() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_UP >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_UP)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_UP > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_UP)));
    }

    /**
     * BigDecimal.ROUND_DOWN , 绝对值向下舍位 .
     *      若当前精度位后一位数字不为0 , 则绝对值向下舍位
     *      正数更小 , 负数更大
     */
    public static void ROUND_DOWN() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > ROUND_DOWN >  " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_DOWN)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > ROUND_DOWN > " + bigDecimal.setScale(DEF_SCALE, BigDecimal.ROUND_DOWN)));
    }

    /**
     * BigDecimal.ROUND_UNNECESSARY , 不舍位 . 精度位数小于小数位数会抛出异常
     */
    public static void ROUND_UNNECESSARY() {
        BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(" " + bigDecimal + " > UNNECESSARY >  " + bigDecimal.setScale(3, BigDecimal.ROUND_UNNECESSARY)));
        System.out.println();
        _BIG_DECIMAL_STREAM.forEach(bigDecimal -> System.out.println(bigDecimal + " > UNNECESSARY > " + bigDecimal.setScale(3, BigDecimal.ROUND_UNNECESSARY)));
    }
}
任程鹏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
介绍Java的大数类(BigDecimal)和八种舍入模式
09-01
BigDecimal提供了八种舍入模式，用于在进行尺度调整时决定如何处理超出范围的数字： - ROUND_UP：远离零的方向舍入，即“向上”舍入。 - ROUND_DOWN：接近零的方向舍入，即“向下”截断。 - ROUND_CEILING：向...
浅谈java中BigDecimal类的简单用法
08-18
在Java编程语言中，`BigDecimal` 类位于 `java.math` 包中，是用于执行高精度和任意精度的十进制算术运算的关键类。它主要用于处理需要精确数值计算的场景，例如金融或会计领域，因为传统的 `float` 和 `double` ...
BigDecimal使用介绍
一个想法
06-09 664
111
BigDecimal的运算
一缕南风的博客
11-28 305
BigDecimal类有3个toString方法，分别是toEngineeringString、toPlainString和toString。
BigDecimal的四则运算
最新发布
qq_45110186的博客
01-11 658
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double最多可以处理16位有效数，BigDecimal一般用于对小数点有精确要求的地方，比如涉及钱的计算过程一般就不用double。下面是介绍BigDecimal的一些基础运算。BigDecimal bigDecimal = new BigDecimal(数值类型或者字符串类型);
关于BigDecimal 的加减乘除计算
zhu2000zhu的博客
03-28 368
因为不是所有的浮点数都能够被精确的表示成一个double 类型值，有些浮点数值不能够被精确的表示成 double 类型值，因此它会被表示成与它最接近的 double 类型的值。向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同;向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。四舍六入，五分两种情况。
BigDecimal-常见运算用法
qq_50120946的博客
05-29 403
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Big Decimal是什么？二、了解Big Decimal类型使用1.它不支持“+，-，*，/”，有自己的运算方式。2.常用方法（“加，减，乘，除”）。2.其他方法。 提示：以下是本篇文章正文内容，下面案例可供参考 一、Big Decimal是什么？ Big Decimal ：位于 java.math.BigDecimal。用于进行高精度的运算（）。在实际中常用，而float和double只能用来做科学计算。 二、了解Bi.
Java中BigDecimal类的简单用法
09-04
此外，BigDecimal类还支持舍入模式（RoundingMode），在进行除法运算时，如果需要四舍五入或者按照特定规则处理余数，可以通过setScale(int newScale, RoundingMode roundingMode)方法来实现。总之，Java中的...
Java中BigDecimal类与int、Integer使用总结
08-25
如果需要四舍五入，可以使用`setScale(int, RoundingMode)`方法先设置小数位数和舍入模式，然后再调用`intValue()`。 在实际应用中，为了确保商业运算的精确性，建议始终使用`BigDecimal(String)`构造器来创建`...
Java BigDecimal类用法详解
09-02
Java中的`BigDecimal`类是用来表示任意精度的十进制数，尤其适合于需要精确计算的商业和财务场景。它的核心概念包括非标度值（unscaled value）和标度（scale），非标度值是一个任意精度的整数，标度则是小数点后的...
java中BigDecimal的操作方法
09-04
在Java编程语言中，BigDecimal是用于处理高精度和可配置精度的十进制数的类。在进行商业计算时，由于浮点数(double和float)存在精度问题，不能保证准确的结果，因此通常推荐使用BigDecimal来确保计算的精确性。本文...
java中BigDecimal进行加减乘除的基本用法
09-01
在Java编程语言中，`BigDecimal` 类位于 `java.math` 包下，它提供了一种进行高精度和任意精度的十进制算术运算的方法。`BigDecimal` 是为那些需要精确数值计算的场景设计的，比如金融计算或会计应用，因为普通的 `...
详谈Java中BigDecimal的一个除法异常
08-28
在Java编程中，`BigDecimal` 类是用于进行高精度浮点数运算的，它解决了`float`和`double`类型在处理大数或精确计算时存在的精度问题。然而，在使用`BigDecimal`进行除法操作时，如果不进行特殊处理，可能会遇到`...
Java BigDecimal使用及基本运算(推荐)
09-07
BigDecimal 类在 Java 中是用于处理高精度和大数值计算的，它确保了在计算过程中不会因为浮点数的精度问题而导致结果错误。由于 double 和 float 类型在处理大数或需要绝对精确计算的场景下存在精度损失，因此 ...
Java BigDecimal类的使用和注意事项
09-02
Java中的`BigDecimal`类是用来处理高精度和任意精度的十进制数值的，它主要用于金融或者科学计算中，需要精确的浮点数运算。在Java的`java.math`包下，`BigDecimal`提供了丰富的算术操作，确保了计算的准确性。 `...
BigDecimal的使用---BigDecimal 加减乘除
Gavin的博客
08-20 560
java.math.BigDecimal。Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是...
常用算数类--Bigdecimal详解
M_azed的博客
07-25 660
在金融中，处理金额，基本类型往往不能满足对金额的操作，而Bigdecimal不仅包含了加减乘除等运算操作、比较操作，还有丰富的进位操作。 现在，我们就从0开始，逐渐深入，了解它的一些常用方法 //构造 BigDecimal(int) 创建一个具有参数所指定整数值的对象。 BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 BigDecimal(long)...
BigDecimal舍入模式总结及运用场景分析
独码乐，不如众码乐，乐享其中
08-14 1405
数字舍入模式setScale()常见的共7种： ROUND_UP：从零舍入。始终在非零丢弃分数之前增加数字。 ROUND_DOWN：向零舍入。 ROUND_HALF_UP：向“最近的邻居”舍入，除非两个邻居是等距的，此时向上舍入。 ROUND_HALF_DOWN：向“最近的邻居”舍入，除非两个邻居是等距的，此时向下舍入。 ROUND_HALF_EVEN：向“最近的邻居”舍入，除非两个邻居是等距的，向偶数邻居舍入。 ROUND_CEILING：向正无穷大舍入。 ROUND_FLOOR：向负无穷大舍入。....
Big Decimal学习笔记
weixin_39573047的博客
12-05 386
Java中浮点数运算会出现损失精度的问题，且对数的长度也有一定的限制，所以对小数运算和大数运算都不够友好。在商业计算，例如银行交易中，可以使用BigDecimal类进行运算。java.math.BigDecimal BigDecimal (Java Platform SE 8 )
javabigdecimal四舍五入
09-06
在Java中，可以使用`BigDecimal`类来进行精确的数值计算，并且可以选择四舍五入操作。要对一个`BigDecimal`对象进行四舍五入，可以使用`setScale()`方法来设置小数位数，并指定舍入模式。 以下是一个示例代码，展示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值