Java基础知识之BigDecimal

深碍√TFBOYSˉ_ 2023-07-19 12:03 16阅读 0赞

**一BigDecimal概述**  
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。  
 BigDecimal所创建的是对象，故我们不能使用传统的+、-、\*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

**二BigDecimal常用方法**  
**①add(BigDecimal)**  
BigDecimal对象中的值相加，返回BigDecimal对象  
**②subtract(BigDecimal)**  
BigDecimal对象中的值相减，返回BigDecimal对象  
**③multiply(BigDecimal)**  
BigDecimal对象中的值相乘，返回BigDecimal对象  
\*\*④divide(BigDecimal)\*\*应设置精度  
BigDecimal对象中的值相除，返回BigDecimal对象  
注意:返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。  
**⑤toString()**  
将BigDecimal对象中的值转换成字符串  
**⑥doubleValue()**  
将BigDecimal对象中的值转换成双精度数  
**⑦floatValue()**  
将BigDecimal对象中的值转换成单精度数  
**⑧longValue()**  
将BigDecimal对象中的值转换成长整数  
**⑨intValue()**  
将BigDecimal对象中的值转换成整数

**三.两个bigdecimal的数比较大小**  
compareTo(BigDecimal val)  
将此 BigDecimal 与指定的 BigDecimal 比较  
返回：  
当此 BigDecimal 在数字上小于、等于或大于 val 时，返回 -1、0 或 1。

四.BigDecimal格式化  
由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。

public static void main(String[] args) { 
         NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
        NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
            percent.setMaximumFractionDigits(3); //百分比小数点最多3位
            BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
            BigDecimal interestRate = new BigDecimal("0.008"); //利率
            BigDecimal interest = loanAmount.multiply(interestRate); //相乘
           System.out.println("贷款金额:\t" + currency.format(loanAmount));//￥15,000.48
           System.out.println("利率:\t" + percent.format(interestRate));//利率: 0.8%
           System.out.println("利息:\t" + currency.format(interest));//利息: ￥120.00
        }

五.BigDecimal格式化保留2为小数，不足则补0：

public class BigdecimalDemo2 { 
        public static void main(String[] s){ 
            System.out.println(formatToNumber(new BigDecimal("3.435")));//3.44
            System.out.println(formatToNumber(new BigDecimal(0)));//0.00
            System.out.println(formatToNumber(new BigDecimal("0.00")));//0.00
            System.out.println(formatToNumber(new BigDecimal("0.001")));//0.00
            System.out.println(formatToNumber(new BigDecimal("0.006")));//0.00
            System.out.println(formatToNumber(new BigDecimal("0.206")));//0.21
        }
        /** * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。 * 2.传入的参数等于0，则直接返回字符串"0.00" * 3.大于1的小数，直接格式化返回字符串 * @param * @return */
        public static String formatToNumber(BigDecimal obj) { 
            DecimalFormat df = new DecimalFormat("#.00");
            if(obj.compareTo(BigDecimal.ZERO)==0) { 
                return "0.00";
            }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){ 
                return "0"+df.format(obj).toString();
            }else { 
                return df.format(obj).toString();
            }
        }
    }

六.工具类推荐

public class ArithmeticUtils { 
        //默认除法运算精度
        private static final int DEF_DIV_SCALE = 10;
    
        /** * 提供精确的加法运算 * * @param v1 被加数 * @param v2 加数 * @return 两个参数的和 */
    
        public static double add(double v1, double v2) { 
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }
    
        /** * 提供精确的加法运算 * * @param v1 被加数 * @param v2 加数 * @return 两个参数的和 */
        public static BigDecimal add(String v1, String v2) { 
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.add(b2);
        }
    
        /** * 提供精确的加法运算 * * @param v1 被加数 * @param v2 加数 * @param scale 保留scale 位小数 * @return 两个参数的和 */
        public static String add(String v1, String v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 提供精确的减法运算 * * @param v1 被减数 * @param v2 减数 * @return 两个参数的差 */
        public static double sub(double v1, double v2) { 
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }
    
        /** * 提供精确的减法运算。 * * @param v1 被减数 * @param v2 减数 * @return 两个参数的差 */
        public static BigDecimal sub(String v1, String v2) { 
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.subtract(b2);
        }
    
        /** * 提供精确的减法运算 * * @param v1 被减数 * @param v2 减数 * @param scale 保留scale 位小数 * @return 两个参数的差 */
        public static String sub(String v1, String v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 提供精确的乘法运算 * * @param v1 被乘数 * @param v2 乘数 * @return 两个参数的积 */
        public static double mul(double v1, double v2) { 
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }
    
        /** * 提供精确的乘法运算 * * @param v1 被乘数 * @param v2 乘数 * @return 两个参数的积 */
        public static BigDecimal mul(String v1, String v2) { 
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.multiply(b2);
        }
    
        /** * 提供精确的乘法运算 * * @param v1 被乘数 * @param v2 乘数 * @param scale 保留scale 位小数 * @return 两个参数的积 */
        public static double mul(double v1, double v2, int scale) { 
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return round(b1.multiply(b2).doubleValue(), scale);
        }
    
        /** * 提供精确的乘法运算 * * @param v1 被乘数 * @param v2 乘数 * @param scale 保留scale 位小数 * @return 两个参数的积 */
        public static String mul(String v1, String v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 * 小数点以后10位，以后的数字四舍五入 * * @param v1 被除数 * @param v2 除数 * @return 两个参数的商 */
    
        public static double div(double v1, double v2) { 
            return div(v1, v2, DEF_DIV_SCALE);
        }
    
        /** * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 * 定精度，以后的数字四舍五入 * * @param v1 被除数 * @param v2 除数 * @param scale 表示表示需要精确到小数点以后几位。 * @return 两个参数的商 */
        public static double div(double v1, double v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /** * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 * 定精度，以后的数字四舍五入 * * @param v1 被除数 * @param v2 除数 * @param scale 表示需要精确到小数点以后几位 * @return 两个参数的商 */
        public static String div(String v1, String v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v1);
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 提供精确的小数位四舍五入处理 * * @param v 需要四舍五入的数字 * @param scale 小数点后保留几位 * @return 四舍五入后的结果 */
        public static double round(double v, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b = new BigDecimal(Double.toString(v));
            return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /** * 提供精确的小数位四舍五入处理 * * @param v 需要四舍五入的数字 * @param scale 小数点后保留几位 * @return 四舍五入后的结果 */
        public static String round(String v, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b = new BigDecimal(v);
            return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 取余数 * * @param v1 被除数 * @param v2 除数 * @param scale 小数点后保留几位 * @return 余数 */
        public static String remainder(String v1, String v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    
        /** * 取余数 BigDecimal * * @param v1 被除数 * @param v2 除数 * @param scale 小数点后保留几位 * @return 余数 */
        public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) { 
            if (scale < 0) { 
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
        }
    
        /** * 比较大小 * * @param v1 被比较数 * @param v2 比较数 * @return 如果v1 大于v2 则 返回true 否则false */
        public static boolean compare(String v1, String v2) { 
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            int bj = b1.compareTo(b2);
            boolean res;
            if (bj > 0)
                res = true;
            else
                res = false;
            return res;
        }
    }