BigDecimal
一、BigDecimal概述
Java在java.math包中提供的API类BigDecimal,用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数,但在实际应用中,可能需要对更大或者更小的数进行运算和处理。一般情况下,对于那些不需要准确计算精度的数字,我们可以直接使用Float和Double处理,但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中,如果我们需要精确计算的结果,则必须使用BigDecimal类来操作。
BigDecimal所创建的是对象,故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算,而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法,专门用来创建对象,特别是带有参数的对象。
二、BigDecimal常用构造函数
2.1、常用构造函数
BigDecimal(int)
创建一个具有参数所指定整数值的对象
BigDecimal(double)
创建一个具有参数所指定双精度值的对象
BigDecimal(long)
创建一个具有参数所指定长整数值的对象
BigDecimal(String)
创建一个具有参数所指定以字符串表示的数值的对象
2.2、使用问题分析
使用示例:
System.out.println("a values is:"+a);
System.out.println("=====================");
BigDecimal b =new BigDecimal("0.1").
System.out.println("b values is:"+b);
结果示例:
a values is:0.1000000000000000055511151231257827021181583404541015625
=====================
b values is:0.1
原因分析:
1)参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1(非标度值 1,其标度为 1),但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double(或者说对于该情况,不能表示为任何有限长度的二进制小数)。这样,传入到构造方法的值不会正好等于 0.1(虽然表面上等于该值)。
2)String 构造方法是完全可预知的:写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal,它正好等于预期的 0.1。因此,比较而言, 通常建议优先使用String构造方法。
3)当double必须用作BigDecimal的源时,请注意,此构造方法提供了一个准确转换;它不提供与以下操作相同的结果:先使用Double.toString(double)方法,然后使用BigDecimal(String)构造方法,将double转换为String。要获取该结果,请使用static valueOf(double)方法。
BigDecimal bDouble1 = BigDecimal.valueOf(2.3);
BigDecimal bDouble2 = new BigDecimal(Double.toString(2.3));
System.out.println("bDouble1=" + bDouble1);
System.out.println("bDouble2=" + bDouble2);
bDouble1=2.3
bDouble2=2.3
三、BigDecimal常用方法详解
3.1、常用方法
add(BigDecimal)
BigDecimal对象中的值相加,返回BigDecimal对象
subtract(BigDecimal)
BigDecimal对象中的值相减,返回BigDecimal对象
multiply(BigDecimal)
BigDecimal对象中的值相乘,返回BigDecimal对象
divide(BigDecimal)
BigDecimal对象中的值相除,返回BigDecimal对象
toString()
将BigDecimal对象中的值转换成字符串
doubleValue()
将BigDecimal对象中的值转换成双精度数
floatValue()
将BigDecimal对象中的值转换成单精度数
longValue()
将BigDecimal对象中的值转换成长整数
intValue()
将BigDecimal对象中的值转换成整数
3.2、BigDecimal大小比较
java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法
BigDecimal a =new BigDecimal("0.2");
BigDecimal b =new BigDecimal("0.1");
int c = a.compareTo(b);
System.out.println(c);
返回结果分析:
a = -1,表示bigdemical小于bigdemical2;
a = 0,表示bigdemical等于bigdemical2;
a = 1,表示bigdemical大于bigdemical2;
1.1 浮点运算精度丢失陷阱
public class BigDecimalDemo {
public static void main(String[] args) {
float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
System.out.println("a= "+a);
System.out.println("b= "+b);
}
}
//输出结果
a= 0.100000024
b= 0.099999964
1.2 浮点数等值判断陷阱
① 基本类型与包装类型判断浮点数是否相等
public class BigDecimalDemo {
public static void main(String[] args) {
float a = 1.0F - 0.9F;
float b = 0.9F - 0.8F;
System.out.println("通过==判断a与b是否相等:"+ (a == b));
Float x = Float.valueOf(a);
Float y = Float.valueOf(b);
System.out.println("通过equals方法判断x与y是否相等:"+ x.equals(y));
}
}
//输出结果
通过==判断a与b是否相等false
通过equals方法判断x y是否相等false
②BigDecimal类通过equals 方法判断是否相等
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("2");
BigDecimal b = new BigDecimal("2.0");
System.out.println(a.equals(b));
}
}
//输出结果
false
1.3 BigDecimal 构造方法中的陷阱
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(0.1f);
System.out.println("a= "+ a);
}
}
//输出结果
a= 0.100000001490116119384765625
1.4 BigDecimal 除法陷阱
如果两数相除无法除尽,抛出 ArithmeticException 异常
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.2");
BigDecimal b = new BigDecimal("0.3");
System.out.println(a.divide(b));
}
}
//输出结果
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.math.BigDecimal.divide(BigDecimal.java:1693)
at com.xiezhr.BigDecimalDemo.main(BigDecimalDemo.java:17)
二、避免陷阱
2.1 浮点数运算避坑
① 我们先来看看为什么浮点数(也就是float 和double 关键字定义的数) 运算的时候精度会丢失?
我们直到计算机是以二进制的方式进行数据存储的,在表示一个数字时,宽度时有限的。
十进制的 0.1 转为二进制,得到一个无限循环小数:0.00011… (看不懂的自觉点回去翻一翻大一的《计算机基础》课本)
无限循环的小数存储在计算机时,只能被截断,所以就会导致小数精度发生损失的情况。
这就是为什么浮点数没有办法用二进制精确表示。
②我们怎么来填1.1 中的坑呢?
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.9");
BigDecimal d = new BigDecimal("0.8");
System.out.println("a-b = "+a.subtract(b));
System.out.println("c-d = "+c.subtract(d));
}
}
//输出结果
a-b = 0.1
c-d = 0.1
2.2 浮点数等值判断避坑
日常开发中肯定时免不了比较两个浮点数大小的,这里呢就把1.2中的坑给填上
① 指定一个误差范围,若两个浮点数的差值在误差范围内,则认为两个浮点数时相等的
public class BigDecimalDemo {
public static void main(String[] args) {
float a = 1.0F - 0.9F;
float b = 0.9F - 0.8F;
//表示10的-6次方
float diff = 1e-6f;
if (Math.abs(a - b )< diff) {
System.out.println("a与b相等");
}
}
}
//输出结果
a与b相等
② 使用BigDecimal定义值,再进行运算操作,最后使用compareTo 方法比较
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
if(x.compareTo(y)==0){
System.out.println("x与y相等");
}
}
}
//输出结果
x与y相等
2.4 BigDecimal 除法避坑
我们使用带有3个参数的divide 方法来填1.4中的坑
BigDecimal.divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 方法的具体使用我们再下一小节中再详细说
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.2");
BigDecimal b = new BigDecimal("0.3");
//这里就简单的看作四舍五入就行了
System.out.println("a除以b等于:"+ a.divide(b, 2, RoundingMode.HALF_UP));
}
}
//输出结果
a除以b等于:0.67
三、BigDecimal 常用方法
3.1 加法运算 add
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(Double.toString(0.1));
BigDecimal b = BigDecimal.valueOf(0.2);
System.out.println("a + b ="+a.add(b));
}
}
//输出结果
a + b =0.3
3.2 减法运算 subtract
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(Double.toString(3.5));
BigDecimal b = BigDecimal.valueOf(2.1);
System.out.println("a - b ="+a.subtract(b));
}
}
//输出结果
a - b =1.4
3.3 乘法运算 multiply
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(Double.toString(2.5));
BigDecimal b = BigDecimal.valueOf(3.26);
System.out.println("a * b ="+a.multiply(b));
}
}
//输出结果
a * b =8.150
3.4 除法运算 divide
BigDecimal除法可能出现不能整除的情况,比如 1.2/1.3,
这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
这个之前也说过,这里呢再详细说说divide 方法
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
divisor : 表示除数
scale: 表示小数点后保留位数
roundingMode: 表示舍入模式。roundingMode是一个枚举类,有八种舍入模式
我们以0.333 和-0.333保留2位小数为例,采用不同模式后得结果为
--模式 | --模式说明 | 图形说明 |
---|---|---|
UP | 远离0的舍入模式【0.333-->0.34 -0.333 -->-0.34】 | ![]() |
---- | ---- | ---- |
DOWN | 接近0的舍入模式【0.333-->0.33 -0.333 -->-0.33】 | ![]() |
---- | ---- | ---- |
CEILING | CEILING英文是天花板的意思,可以理解为向”大“舍入【0.333-->0.34 -0.333 -->-0.33】 | ![]() |
---- | ---- | ---- |
FLOOR | FLOOR有地板的意思,可以理解为向”小“舍入【0.333-->0.33 -0.333 -->-0.34】 | ![]() |
---- | ---- | ---- |
HALF_UP | 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为向上舍入的舍入其实就是四舍五入【>=0.5 入,<0.5的舍去】 | |
---- | ---- | ---- |
HALF_DOWN | 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为上舍入的舍入,其实就是五舍六入 【>0.5 的入,<=0.5 的舍去】 | |
---- | ---- | ---- |
HALF_EVEN | 向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则向相邻的偶数舍入【0.135-->0.14 0.125-->0.12】 | |
---- | ---- | ---- |
UNNECESSARY | 断言请求的操作具有精确的结果,因此不需要舍入 | |
---- | ---- | ---- |
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal numA = new BigDecimal("1");
BigDecimal numB = new BigDecimal("-1");
BigDecimal numC = new BigDecimal("3");
// 保留两位小数,舍入模式为UP
System.out.println("1/3保留两位小数(UP) = " + numA.divide(numC, 2, RoundingMode.UP));
System.out.println("-1/3保留两位小数(UP) = " + numB.divide(numC, 2, RoundingMode.UP));
// 保留两位小数,舍入模式为DOWN
System.out.println("1/3保留两位小数(DOWN) = " + numA.divide(numC, 2, RoundingMode.DOWN));
System.out.println("-1/3保留两位小数(DOWN) = " + numB.divide(numC, 2, RoundingMode.DOWN));
// 保留两位小数,舍入模式为CEILING
System.out.println("1/3保留两位小数(CEILING) = " + numA.divide(numC, 2, RoundingMode.CEILING));
System.out.println("-1/3保留两位小数(CEILING) = " + numB.divide(numC, 2, RoundingMode.CEILING));
// 保留两位小数,舍入模式为FLOOR
System.out.println("1/3保留两位小数(FLOOR) = " + numA.divide(numC, 2, RoundingMode.FLOOR));
System.out.println("-1/3保留两位小数(FLOOR) = " + numB.divide(numC, 2, RoundingMode.FLOOR));
BigDecimal numD = new BigDecimal("1");
BigDecimal numE = new BigDecimal("-1");
BigDecimal numF = new BigDecimal("8");
// 保留两位小数,舍入模式为HALF_UP
System.out.println("1/8(=0.125)保留两位小数(HALF_UP) = " + numD.divide(numF, 2, RoundingMode.HALF_UP));
System.out.println("-1/8(=0.125)保留两位小数(HALF_UP) = " + numE.divide(numF, 2, RoundingMode.HALF_UP));
// 保留两位小数,舍入模式为HALF_DOWN
System.out.println("1/8(=0.125)保留两位小数(HALF_DOWN) = " + numD.divide(numF, 2, RoundingMode.HALF_DOWN));
System.out.println("-1/8(=0.125)保留两位小数(HALF_DOWN) = " + numE.divide(numF, 2, RoundingMode.HALF_DOWN));
// 保留两位小数,舍入模式为HALF_EVEN
System.out.println("0.54/4(=0.135)保留两位小数(HALF_EVEN) = " + new BigDecimal("0.54").divide(new BigDecimal("4"), 2, RoundingMode.HALF_EVEN));
System.out.println("1/8(=0.125)保留两位小数(HALF_EVEN) = " + numE.divide(numF, 2, RoundingMode.HALF_EVEN));
//UNNECESSARY,会报异常
System.out.println("1/8(=0.125) = " + numE.divide(numF, RoundingMode.UNNECESSARY));
}
}
//输出结果
1/3保留两位小数(UP) = 0.34
-1/3保留两位小数(UP) = -0.34
1/3保留两位小数(DOWN) = 0.33
-1/3保留两位小数(DOWN) = -0.33
1/3保留两位小数(CEILING) = 0.34
-1/3保留两位小数(CEILING) = -0.33
1/3保留两位小数(FLOOR) = 0.33
-1/3保留两位小数(FLOOR) = -0.34
1/8(=0.125)保留两位小数(HALF_UP) = 0.13
-1/8(=0.125)保留两位小数(HALF_UP) = -0.13
1/8(=0.125)保留两位小数(HALF_DOWN) = 0.12
-1/8(=0.125)保留两位小数(HALF_DOWN) = -0.12
0.54/4(=0.135)保留两位小数(HALF_EVEN) = 0.14
1/8(=0.125)保留两位小数(HALF_EVEN) = -0.12
Exception in thread "main" java.lang.ArithmeticException: Rounding necessary
3.5 值转换
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(Double.toString(2.3));
BigDecimal b = new BigDecimal(10200000);
System.out.println("BigDecimal转字符串:"+a.toString());
System.out.println("BigDecimal转double:"+a.doubleValue());
System.out.println("BigDecimal转float:"+a.floatValue());
System.out.println("BigDecimal转长整型:"+b.longValue());
System.out.println("BigDecimal转int:"+b.intValue());
}
}
//输出结果
BigDecimal转字符串:2.3
BigDecimal转double:2.3
BigDecimal转float:2.3
BigDecimal转长整型:10200000
BigDecimal转int:10200000
3.6 绝对值 abs
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(Double.toString(2.35));
BigDecimal b = BigDecimal.valueOf(-2.35);
System.out.println("a的绝对值是:" + a.abs());
System.out.println("b的绝对值是:" + b.abs());
}
}
//输出结果
a的绝对值是:2.35
b的绝对值是:2.35
四、BigDecimal格式化
NumberFormat类的format()方法可以使用BigDecimal对象作为参数,
可以对超出16位有效数字的货币值,百分值,以及一般数值进行格式化控制
public class BigDecimalDemo {
public static void main(String[] args) {
NumberFormat money = 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("贷款金额:" + money.format(loanAmount));
System.out.println("利率:" + percent.format(interestRate));
System.out.println("利息:" + money.format(interest));
}
}
//输出结果
贷款金额:¥15,000.48
利率:0.8%
利息:¥120.00
五、BigDecimal 工具类
为了更加方便的使用BigDecimal 我们可以将其常用方法封装成工具类
package com.xiezhr.util;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* 简化BigDecimal计算的小工具类
*/
public class BigDecimalUtil {
/**
* 默认除法运算精度
*/
private static final int DEF_DIV_SCALE = 10;
private BigDecimalUtil() {
}
/**
* 提供精确的加法运算。
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double subtract(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double multiply(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.multiply(b2).doubleValue();
}
/**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到
* 小数点以后10位,以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double divide(double v1, double v2) {
return divide(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指
* 定精度,以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double divide(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
*
* @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 = BigDecimal.valueOf(v);
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
}
/**
* 提供精确的类型转换(Float)
*
* @param v 需要被转换的数字
* @return 返回转换结果
*/
public static float convertToFloat(double v) {
BigDecimal b = new BigDecimal(v);
return b.floatValue();
}
/**
* 提供精确的类型转换(Int)不进行四舍五入
*
* @param v 需要被转换的数字
* @return 返回转换结果
*/
public static int convertsToInt(double v) {
BigDecimal b = new BigDecimal(v);
return b.intValue();
}
/**
* 提供精确的类型转换(Long)
*
* @param v 需要被转换的数字
* @return 返回转换结果
*/
public static long convertsToLong(double v) {
BigDecimal b = new BigDecimal(v);
return b.longValue();
}
/**
* 返回两个数中大的一个值
*
* @param v1 需要被对比的第一个数
* @param v2 需要被对比的第二个数
* @return 返回两个数中大的一个值
*/
public static double returnMax(double v1, double v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.max(b2).doubleValue();
}
/**
* 返回两个数中小的一个值
*
* @param v1 需要被对比的第一个数
* @param v2 需要被对比的第二个数
* @return 返回两个数中小的一个值
*/
public static double returnMin(double v1, double v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.min(b2).doubleValue();
}
/**
* 精确对比两个数字
*
* @param v1 需要被对比的第一个数
* @param v2 需要被对比的第二个数
* @return 如果两个数一样则返回0,如果第一个数比第二个数大则返回1,反之返回-1
*/
public static int compareTo(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.compareTo(b2);
}
}
六、避坑小结
商业计算使用BigDecimal
尽量使用参数类型为String的构造函数
BigDecimal都是不可变的,在进行每一步运算时,都会产生一个新的对象,所以在做加减乘除运算时千万要保存操作后的值。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战