BigDecimal 小数位的处理（RoundingMode）

于 2024-06-23 20:55:27 发布
阅读量349 收藏 10
点赞数 4
分类专栏： 【随笔--杂记】 文章标签： Java RoundingMode 小数位处理 BigDecmial
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118323/article/details/139855442
版权

前言：

在日常项目开发中，接触小数是常有的事情，而产品对于小数的处理，在不同的业务中有不同的定义，比如四舍五入、截取、向上舍位、向下舍位等等场景，面对如此多的场景，你是否会束手无策？或者说自己去研究怎么实现？其实 Java 已经给我们提供了一个枚举类 RoundingMode，RoundingMode 共有 8 种舍位方式，本篇我们来逐个分析。

RoundingMode 枚举类源码如下：

package java.math;

/**
 *
 * @see     BigDecimal
 * @see     MathContext
 * @author  Josh Bloch
 * @author  Mike Cowlishaw
 * @author  Joseph D. Darcy
 * @since 1.5
 */
public enum RoundingMode {

        /**
         * Rounding mode to round away from zero.  Always increments the
         * digit prior to a non-zero discarded fraction.  Note that this
         * rounding mode never decreases the magnitude of the calculated
         * value.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode UP Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code UP} rounding
         *<tr align=right><td>5.5</td>  <td>6</td>
         *<tr align=right><td>2.5</td>  <td>3</td>
         *<tr align=right><td>1.6</td>  <td>2</td>
         *<tr align=right><td>1.1</td>  <td>2</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-2</td>
         *<tr align=right><td>-1.6</td> <td>-2</td>
         *<tr align=right><td>-2.5</td> <td>-3</td>
         *<tr align=right><td>-5.5</td> <td>-6</td>
         *</table>
         */
    UP(BigDecimal.ROUND_UP),

        /**
         * Rounding mode to round towards zero.  Never increments the digit
         * prior to a discarded fraction (i.e., truncates).  Note that this
         * rounding mode never increases the magnitude of the calculated value.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode DOWN Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code DOWN} rounding
         *<tr align=right><td>5.5</td>  <td>5</td>
         *<tr align=right><td>2.5</td>  <td>2</td>
         *<tr align=right><td>1.6</td>  <td>1</td>
         *<tr align=right><td>1.1</td>  <td>1</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-1</td>
         *<tr align=right><td>-1.6</td> <td>-1</td>
         *<tr align=right><td>-2.5</td> <td>-2</td>
         *<tr align=right><td>-5.5</td> <td>-5</td>
         *</table>
         */
    DOWN(BigDecimal.ROUND_DOWN),

        /**
         * Rounding mode to round towards positive infinity.  If the
         * result is positive, behaves as for {@code RoundingMode.UP};
         * if negative, behaves as for {@code RoundingMode.DOWN}.  Note
         * that this rounding mode never decreases the calculated value.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode CEILING Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code CEILING} rounding
         *<tr align=right><td>5.5</td>  <td>6</td>
         *<tr align=right><td>2.5</td>  <td>3</td>
         *<tr align=right><td>1.6</td>  <td>2</td>
         *<tr align=right><td>1.1</td>  <td>2</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-1</td>
         *<tr align=right><td>-1.6</td> <td>-1</td>
         *<tr align=right><td>-2.5</td> <td>-2</td>
         *<tr align=right><td>-5.5</td> <td>-5</td>
         *</table>
         */
    CEILING(BigDecimal.ROUND_CEILING),

        /**
         * Rounding mode to round towards negative infinity.  If the
         * result is positive, behave as for {@code RoundingMode.DOWN};
         * if negative, behave as for {@code RoundingMode.UP}.  Note that
         * this rounding mode never increases the calculated value.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode FLOOR Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code FLOOR} rounding
         *<tr align=right><td>5.5</td>  <td>5</td>
         *<tr align=right><td>2.5</td>  <td>2</td>
         *<tr align=right><td>1.6</td>  <td>1</td>
         *<tr align=right><td>1.1</td>  <td>1</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-2</td>
         *<tr align=right><td>-1.6</td> <td>-2</td>
         *<tr align=right><td>-2.5</td> <td>-3</td>
         *<tr align=right><td>-5.5</td> <td>-6</td>
         *</table>
         */
    FLOOR(BigDecimal.ROUND_FLOOR),

        /**
         * Rounding mode to round towards {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case round up.
         * Behaves as for {@code RoundingMode.UP} if the discarded
         * fraction is &ge; 0.5; otherwise, behaves as for
         * {@code RoundingMode.DOWN}.  Note that this is the rounding
         * mode commonly taught at school.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode HALF_UP Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code HALF_UP} rounding
         *<tr align=right><td>5.5</td>  <td>6</td>
         *<tr align=right><td>2.5</td>  <td>3</td>
         *<tr align=right><td>1.6</td>  <td>2</td>
         *<tr align=right><td>1.1</td>  <td>1</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-1</td>
         *<tr align=right><td>-1.6</td> <td>-2</td>
         *<tr align=right><td>-2.5</td> <td>-3</td>
         *<tr align=right><td>-5.5</td> <td>-6</td>
         *</table>
         */
    HALF_UP(BigDecimal.ROUND_HALF_UP),

        /**
         * Rounding mode to round towards {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case round
         * down.  Behaves as for {@code RoundingMode.UP} if the discarded
         * fraction is &gt; 0.5; otherwise, behaves as for
         * {@code RoundingMode.DOWN}.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode HALF_DOWN Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code HALF_DOWN} rounding
         *<tr align=right><td>5.5</td>  <td>5</td>
         *<tr align=right><td>2.5</td>  <td>2</td>
         *<tr align=right><td>1.6</td>  <td>2</td>
         *<tr align=right><td>1.1</td>  <td>1</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-1</td>
         *<tr align=right><td>-1.6</td> <td>-2</td>
         *<tr align=right><td>-2.5</td> <td>-2</td>
         *<tr align=right><td>-5.5</td> <td>-5</td>
         *</table>
         */
    HALF_DOWN(BigDecimal.ROUND_HALF_DOWN),

        /**
         * Rounding mode to round towards the {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case, round
         * towards the even neighbor.  Behaves as for
         * {@code RoundingMode.HALF_UP} if the digit to the left of the
         * discarded fraction is odd; behaves as for
         * {@code RoundingMode.HALF_DOWN} if it's even.  Note that this
         * is the rounding mode that statistically minimizes cumulative
         * error when applied repeatedly over a sequence of calculations.
         * It is sometimes known as {@literal "Banker's rounding,"} and is
         * chiefly used in the USA.  This rounding mode is analogous to
         * the rounding policy used for {@code float} and {@code double}
         * arithmetic in Java.
         *
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode HALF_EVEN Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code HALF_EVEN} rounding
         *<tr align=right><td>5.5</td>  <td>6</td>
         *<tr align=right><td>2.5</td>  <td>2</td>
         *<tr align=right><td>1.6</td>  <td>2</td>
         *<tr align=right><td>1.1</td>  <td>1</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>-1</td>
         *<tr align=right><td>-1.6</td> <td>-2</td>
         *<tr align=right><td>-2.5</td> <td>-2</td>
         *<tr align=right><td>-5.5</td> <td>-6</td>
         *</table>
         */
    HALF_EVEN(BigDecimal.ROUND_HALF_EVEN),

        /**
         * Rounding mode to assert that the requested operation has an exact
         * result, hence no rounding is necessary.  If this rounding mode is
         * specified on an operation that yields an inexact result, an
         * {@code ArithmeticException} is thrown.
         *<p>Example:
         *<table border>
         * <caption><b>Rounding mode UNNECESSARY Examples</b></caption>
         *<tr valign=top><th>Input Number</th>
         *    <th>Input rounded to one digit<br> with {@code UNNECESSARY} rounding
         *<tr align=right><td>5.5</td>  <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>2.5</td>  <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>1.6</td>  <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>1.1</td>  <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>1.0</td>  <td>1</td>
         *<tr align=right><td>-1.0</td> <td>-1</td>
         *<tr align=right><td>-1.1</td> <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>-1.6</td> <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>-2.5</td> <td>throw {@code ArithmeticException}</td>
         *<tr align=right><td>-5.5</td> <td>throw {@code ArithmeticException}</td>
         *</table>
         */
    UNNECESSARY(BigDecimal.ROUND_UNNECESSARY);

    // Corresponding BigDecimal rounding constant
    final int oldMode;

    /**
     * Constructor
     *
     * @param oldMode The {@code BigDecimal} constant corresponding to
     *        this mode
     */
    private RoundingMode(int oldMode) {
        this.oldMode = oldMode;
    }

    /**
     * Returns the {@code RoundingMode} object corresponding to a
     * legacy integer rounding mode constant in {@link BigDecimal}.
     *
     * @param  rm legacy integer rounding mode to convert
     * @return {@code RoundingMode} corresponding to the given integer.
     * @throws IllegalArgumentException integer is out of range
     */
    public static RoundingMode valueOf(int rm) {
        switch(rm) {

        case BigDecimal.ROUND_UP:
            return UP;

        case BigDecimal.ROUND_DOWN:
            return DOWN;

        case BigDecimal.ROUND_CEILING:
            return CEILING;

        case BigDecimal.ROUND_FLOOR:
            return FLOOR;

        case BigDecimal.ROUND_HALF_UP:
            return HALF_UP;

        case BigDecimal.ROUND_HALF_DOWN:
            return HALF_DOWN;

        case BigDecimal.ROUND_HALF_EVEN:
            return HALF_EVEN;

        case BigDecimal.ROUND_UNNECESSARY:
            return UNNECESSARY;

        default:
            throw new IllegalArgumentException("argument out of range");
        }
    }
}

8种舍位模式含义解析：

  • RoundingMode.UP：正数向上舍位，负数向下舍位。
  • RoundingMode.DOWN：直接保留指定位数数字，可以理解为截取。
  • RoundingMode.CEILING：直译是天花板的意思，正数的效果如同 RoundingMode.UP，负数的效果如同 RoundingMode.DOWN。
  • RoundingMode.FLOOR：直译是地板的意思，和 RoundingMode.CEILING 刚好相反，正数的效果如同 RoundingMode.DOWN，负数的效果如同 RoundingMode.UP。
  • RoundingMode.HALF_UP：就是比较常见的四舍五入。
  • RoundingMode.HALF_DOWN：五舍六入。
  • RoundingMode.HALF_EVEN：指定位数后面的小数是5，且5后面有数字且这些数字不全部为0，则进一位，否则看5前面的一位，如果是奇数就进一位，如果是偶数则不进位，其他情况四舍五入。
  • RoundingMode.UNNECESSARY：指定位数后没有数字或者全部是0，否则会抛出异常。

RoundingMode.UP 验证：

BigDecimal bigDecimal1 = new BigDecimal("1.235");
BigDecimal up1 = bigDecimal1.setScale(2, RoundingMode.UP);
BigDecimal bigDecimal2 = new BigDecimal("-1.233");
BigDecimal up2 = bigDecimal2.setScale(2, RoundingMode.UP);
System.out.println("up1:" + up1);
System.out.println("up2:" + up2);

执行结果：

up1:1.24
up2:-1.24

正数向上舍位，负数向下舍位，符合预期。

RoundingMode.HALF_DOWN 验证：

BigDecimal down = new BigDecimal("1.235").setScale(2, RoundingMode.DOWN);
System.out.println("down:" + down);

执行结果：

down:1.23

截取直接保留指定位数数字，符合预期。

RoundingMode.CEILING 验证：

BigDecimal ceilingOne = new BigDecimal("1.235").setScale(2, RoundingMode.CEILING);
BigDecimal ceilingTwo = new BigDecimal("-1.235").setScale(2, RoundingMode.CEILING);
System.out.println("ceilingOne:" + ceilingOne);
System.out.println("ceilingTwo:" + ceilingTwo);

执行结果：

ceilingOne:1.24
ceilingTwo:-1.23

正数向上舍位，负数直接截取，符合预期。

RoundingMode.FLOOR 验证：

BigDecimal floorOne = new BigDecimal("1.235").setScale(2, RoundingMode.FLOOR);
BigDecimal floorTwo = new BigDecimal("-1.235").setScale(2, RoundingMode.FLOOR);
System.out.println("floorOne:" + floorOne);
System.out.println("floorTwo:" + floorTwo);

执行结果：

floorOne:1.23
floorTwo:-1.24

正数截取，负数向下舍位，符合预期。

RoundingMode.HALF_UP 验证：

BigDecimal halfUpOne = new BigDecimal("1.235").setScale(2, RoundingMode.HALF_UP);
BigDecimal halfUpTwo = new BigDecimal("1.234").setScale(2, RoundingMode.HALF_UP);
System.out.println("halfUpOne:" + halfUpOne);
System.out.println("halfUpTwo:" + halfUpTwo);

执行结果：

halfUpOne:1.24
halfUpTwo:1.23

四舍五入，符合预期。

RoundingMode.HALF_EVEN 验证：

BigDecimal halfEvenOne = new BigDecimal("1.2351").setScale(2, RoundingMode.HALF_EVEN);
BigDecimal halfEvenTwo = new BigDecimal("1.2250").setScale(2, RoundingMode.HALF_EVEN);
BigDecimal halfEvenThree = new BigDecimal("1.2350").setScale(2, RoundingMode.HALF_EVEN);
BigDecimal halfEvenFour = new BigDecimal("1.2450").setScale(2, RoundingMode.HALF_EVEN);
BigDecimal halfEvenFive = new BigDecimal("1.244").setScale(2, RoundingMode.HALF_EVEN);
BigDecimal halfEvenSix = new BigDecimal("1.246").setScale(2, RoundingMode.HALF_EVEN);
System.out.println("halfEvenOne:" + halfEvenOne);
System.out.println("halfEvenTwo:" + halfEvenTwo);
System.out.println("halfEvenThree:" + halfEvenThree);
System.out.println("halfEvenFour:" + halfEvenFour);
System.out.println("halfEvenFive:" + halfEvenFive);
System.out.println("halfEvenSix:" + halfEvenSix);

执行结果：

halfEvenOne:1.24
halfEvenTwo:1.22
halfEvenThree:1.24
halfEvenFour:1.24
halfEvenFive:1.24
halfEvenSix:1.25

符合预期。

RoundingMode.HALF_EVEN 验证：

BigDecimal unnecessaryOne = new BigDecimal("1.240").setScale(2, RoundingMode.UNNECESSARY);
System.out.println("unnecessaryOne:" + unnecessaryOne);
BigDecimal unnecessaryTwo = new BigDecimal("1.2401").setScale(2, RoundingMode.UNNECESSARY);
System.out.println("unnecessaryTwo:" + unnecessaryTwo);

执行结果：

unnecessaryOne:1.24
Exception in thread "main" java.lang.ArithmeticException: Rounding necessary
	at java.math.BigDecimal.commonNeedIncrement(BigDecimal.java:4148)
	at java.math.BigDecimal.needIncrement(BigDecimal.java:4204)
	at java.math.BigDecimal.divideAndRound(BigDecimal.java:4112)
	at java.math.BigDecimal.setScale(BigDecimal.java:2452)
	at java.math.BigDecimal.setScale(BigDecimal.java:2386)
	at com.zt.dc.portal.admin.web.service.impl.satisfaction.SatisfactionEvaluationServiceImpl.main(SatisfactionEvaluationServiceImpl.java:262)

一个正常输出，一个抛出异常，符合预期。

总结：本文对 RoundingMode 共有 8 种舍位方式进行了详细分析验证，希望可以帮助到有需要的小伙伴。

欢迎提出建议及对错误的地方指出纠正。

码农爱java
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BigDecimal.roundingMode
hungteshun的专栏
06-10 1351
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode){}; 一、roundingMode一共有七种模式 ROUND_UP=0;//（远离零方向舍入） ROUND_DOWN=1;//（向零方向舍入） ROUND_CEILING=2;//（向正无限大方向舍入） ROUND_FLOOR=3;//（向负无限大方向舍入） ROUND_HALF_UP=4;//（四舍五入：向最接近的数字方向舍入，如果与两个相邻数字的距离.
BigDecimal 8种保留小数的RoundingMode
最新发布
ugo
01-27 2300
BigDecimal通常可以用来金额保存，或者经常用来带有小数位的数学计算。不懂8种保留小数？本文带你熟悉。
Java BigDecimal 的舍入模式（RoundingMode）详解
热门推荐
龙哥盟
08-05 3万+
BigDecimal.divide方法中必须设置roundingMode，不然会报错。 ROUND_UP：向正无穷方向对齐（转换为正无穷方向最接近的所需数值） ROUND_DOWN：向负无穷方向对齐 ROUND_CEILING：向原点的反方向对齐 ROUND_FLOOR：向原点方向对齐 ROUND_HALF_UP：“四舍五入”，如果舍弃部分的最高位大于等于 5，向正无穷方向对齐，否则向负无穷方向对齐 ROUND_HALF_DOWN：“五舍六入”，如果舍弃部分的最高位大于 5，向正无穷方向对齐，否则向负无穷
BigDecimal 的舍入模式
忧郁王子的专栏
06-30 6775
eg:BigDecimal x1b = new BigDecimal(54D);BigDecimal x2b = new BigDecimal(20D);double x = ((x1b.add(x2b)).divide(new BigDecimal("2"),6,RoundingMode.HALF_UP)).doubleValue();即:商=被除数.devide(除数，保留小数位数
BigDecimal 八种舍入模式介绍
LX2016341134的博客
04-29 6281
BigDecimal 八种舍入模式介绍 一、BigDecimal 简介 二、BigDecimal 的舍入模式 ROUND_UP ROUND_DOWN ROUND_CEILING ROUND_FLOOR ROUND_HALF_UP ROUND_HALF_DOWN ROUND_HALF_EVEN ROUND_UNNECESSARY 三、BigDecimal 常用方法
java中BigDecimal类的几种舍入模式的详细介绍
jiangbb8686的博客
09-04 566
舍入模式将小数部分舍入到两位小数。由于舍弃部分的第三位数字为1，小于5，且舍弃部分左边的数字为4（偶数），所以直接舍弃，得到结果。类中常用的几种舍入模式，每种模式都有不同的舍入规则。舍入模式将小数部分舍入到两位小数。由于小数部分的第三位数字大于等于5，所以舍弃部分前面的数字加1，得到结果。舍入模式将小数部分舍入到两位小数。由于舍弃部分的第三位数字为1，小于5，所以直接舍弃，得到结果。舍入模式将小数部分舍入到两位小数。由于舍弃部分的第三位数字为1，小于5，所以直接舍弃，得到结果。直接舍弃小数部分，得到结果。
java中如何截取一个数的有效位
u010141286的专栏
04-26 1477
Java code ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import java.math.BigDecimal; import java.math.RoundingMode;   public class S
RoundingMode 参数详解
hantangduhey的博客
10-29 1万+
RoundingMode的几种模式，具体是什么舍入行为呢？看API完全没看懂，还好有人总结过了： https://blog.csdn.net/alanzyy/article/details/8465098 下面是我对这篇文章的图形理解，个人感觉比较好记，具体的示例可以看上边的原文： UP 正数向右边靠，负数向左边靠 DOWN 和up正好相反，正数向左边靠，负数向右边靠 CEI...
RoundingMode模式
零零落落的博客
12-22 1739
小数位取舍模式
RoundingMode 几个参数详解
WGH100817的博客
11-20 1879
第一版 java.math.RoundingMode 几个参数详解 java.math.RoundingMode里面有几个参数搞得我有点晕，现以个人理解对其一一进行总结： 为了能更好理解，我们可以画一个XY轴 RoundingMode.CEILING：取右边最近的整数 RoundingMode.DOWN：去掉小数部分取整，也就是正数取...
一次性搞懂RoundingMode
liulizhu_pp的博客
08-30 414
大白话讲清楚数据取整RoudingMode
Java中BigDecimal除法保留小数位
yuanwxcsdn的博客
03-07 3万+
计算除法，并进行小数位的保留（结果四舍五入、向上取整、向下取整等）的格式： BigDecimal result= 被除数.divide(除数,保留小数位, RoundingMode.结果处理); 说明：1、保留小数位填写Integer类型 2、结果处理（四舍五入、向上取整、向下取整等）通过RoundingMode中枚举来实现，常用的： RoundingMode.UP:直接进位，比如1.22222...
Java使用DecimalFormat进行保留截取固定小数点
卟在徊头的博客
03-07 2128
本文主要是介绍如何使用DecimalFormat进行四舍五入和非四舍五入截取小数点。PS：文章来源（正好博主在对接高德逆地理编码API接口，但是接口参数对经纬度有要求：经纬度小数点后不要超过 6 位。没办法的是正常经纬度小数点后面都会超过6位数，所以只能对经纬度小数点进行截取） public static void main(String[] args) { // 经度 ...
Java的RoundingMode()方法
Lazy
04-21 2749
java.math.RoundingMode：这是一种枚举类型，它定义了8种数据的舍入模式。 英文：Rounding ；中文：舍入模式 大概就是数学上的四舍五入：数值0-4舍去；数值5-9进位。 1、ROUND_UP：向远离零的方向舍入。 若舍入位为非零，则对舍入部分的前一位数字加1；若舍入位为零，则直接舍弃。即为向外取整模式。 2、ROUND_DOWN：向接近零的方向舍入。 不论舍入...
理解 BigDecimal 的 RoundingMode
Jitwxs
05-08 1万+
在金融等对数据精度计算要求较高的领域，传统 double 运算无法满足要求， BigDecimal 类应运而生。实际使用中，RoundingMode 这个枚举类控制着小数的舍位原则，本文对该枚举类进行介绍。 一、RoundingMode.DOWN 等价枚举： BigDecimal.ROUND_DOWN 舍位原则： 粗暴截断舍弃位，不考虑任何进位舍位操作 例： Scale = 2 Origin：3....
bigdecimal 两位小数
04-28
BigDecimal result = number.setScale(2, RoundingMode.HALF_UP); ``` 其中，setScale方法需要传入两个参数。第一个参数用于指定要保留的小数位数，这里为2；第二个参数用于指定舍入的方式，这里使用常用的四舍五入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值