承接昨天的“重走Java路-基本数据类型”,在讲到浮点数为什么不精确的时候提到了,要进行精确计算需要使用BigDecimal类。因为在工作中也确实没怎么使用该类,昨天写完博客之后发现自己视乎不太了解该类。于是今天就和大家一起学习一下BigDecimal类的使用,以及浮点数进行运行的时候如何进行四舍五入保留n位小数。
BigDecimal类
BigDecimal类位于java.math包中,用于对小数的精确计算,至于为什么进行精确计算是需要使用BigDecimal类,前面以及说过了并不是所有的十进制小数都可用二进制小数来表示。
BigDecimal类中的常用构造方法
-
BigDecimal(int)
创建一个整数值的对象
-
BigDecimal(BigInteger)
创建一个大数值的对象
-
BigDecimal(double)
创建一个双精度浮点的对象
-
BigDecimal(long)
创建一个长整数值的对象
-
BigDecimal(String)
创建一个字符串数值的对象
这些构造函数中建议使用BigDecimal(String),因为BigDecimal(String)构造的BigDecimal对象是精确的,如果你使用BigDecimal(double)构造函数即使通过BigDecimal对象进行运算也没法保证计算结果的精确性。
BigDecimal类中的常用方法
-
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对象中的值转换成整数
BigDecimal对象的大小比较
//使用compareTo进行BigDecimal对象的大小比较
BigDecimal bigDecimal1 = new BigDecimal("1.1");
BigDecimal bigDecimal2 = new BigDecimal("1.2");
//bigDecimal1 < bigDecimal2 返回 -1
System.out.println(bigDecimal1.compareTo(bigDecimal2));
//bigDecimal2 > bigDecimal1 返回 1
System.out.println(bigDecimal2.compareTo(bigDecimal1));
//bigDecimal1 = bigDecimal1 返回 -1
System.out.println(bigDecimal1.compareTo(bigDecimal1));
输出
-1
1
0
BigDecimal对象保留n位小数
//保留有限位数
BigDecimal bigDecimal3 = new BigDecimal("1.234567");
//进一法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_UP));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_CEILING));
//去尾法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_DOWN));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_FLOOR));
//四舍五入法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_UP));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_UP));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_DOWN));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_DOWN));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_EVEN));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_EVEN));
输出
1.24
1.24
1.23
1.23
1.23
1.235
1.23
1.235
1.23
1.235
BigDecimal格式化
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));
System.out.println("利率:\t" + percent.format(interestRate));
System.out.println("利息:\t" + currency.format(interest));
输出:
贷款金额: ¥15,000.48
利率: 0.8%
利息: ¥120.00
自定义工具
package com.founder.util;
import java.math.BigDecimal;
public class MyBigDecimalUtil {
//默认除法运算精度
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;
}
}
Math类
常用方法:
1、 xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2 、 compareTo()
将number对象与参数比较。
3 、 equals()
判断number对象是否与参数相等。
4 、 valueOf()
返回一个 Number 对象指定的内置数据类型
5、 toString()
以字符串形式返回值。
6、 parseInt()
将字符串解析为int类型。
7、 abs()
返回参数的绝对值。
8、 ceil()
返回大于等于( >= )给定参数的的最小整数,类型为双精度浮点型。
9、 floor()
返回小于等于(<=)给定参数的最大整数 。
10 、 rint()
返回与参数最接近的整数。返回类型为double。
11、 round()
它表示四舍五入,算法为 Math.floor(x+0.5),即将原来的数字加上 0.5 后再向下取整,所以,Math.round(11.5) 的结果为12,Math.round(-11.5) 的结果为-11。
12、 min()
返回两个参数中的最小值。
13、 max()
返回两个参数中的最大值。
14、 exp()
返回自然数底数e的参数次方。
15、 log()
返回参数的自然数底数的对数值。
16 、 pow()
返回第一个参数的第二个参数次方。
17、 sqrt()
求参数的算术平方根。
18、 sin()
求指定double类型参数的正弦值。
19 cos()
求指定double类型参数的余弦值。
20、 tan()
求指定double类型参数的正切值。
21、 asin()
求指定double类型参数的反正弦值。
22、 acos()
求指定double类型参数的反余弦值。
23、 atan()
求指定double类型参数的反正切值。
24、 atan2()
将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25、 toDegrees()
将参数转化为角度。
26、 toRadians()
将角度转换为弧度。
27、 random()
返回一个随机数。
总结:BigDecimal类用于进行浮点数的精确计算,其本质是一个引用数据类型对象(类)。我们在进行精确计算+、-、×、÷时不在调用常用的+、-、×、÷等数学运算符,而是调用对象的操作函数add()、subtract()、multiply()、divide()其本质也是Java面向对象的体现。我们将double、float浮点运算不精确的计算过程进行封装,转换成对象行为的调用(方法)而实现数据的精确计算。
今天浮点运行的补充到此结束,欲知详情请听下回分解-“重走Java路-基本数据类型包装类”。