Java中BigDecimal类及8种舍入模式

92 阅读 0 评论 61 点赞
我是靠谱客的博主孝顺豆芽，最近开发中收集的这篇文章主要介绍Java中BigDecimal类及8种舍入模式，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述

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)));
    }
}