Java金额帮助类——数字的转换（加减乘除）——取舍方式
作者：互联网
货币金额的转换。
针对金额的数学方法，和格式转换
import java.math.BigDecimal;
import java.text.NumberFormat;
/**
* MoneyHelper说明：
* 1，尽量不要使用本类提供的参数类型为double型的方法，你要使用这些方法的前提是：你传近来的double数值精度在double型提供的精度范围内，
* 如：double a= 999999999999999.999999,这值超出double的精度，他实际表示是10E15，那么调用这些方法可能的要意想不到的结果。
* 2，尽量不要运用divide（除）的方法，除非你的除运算不作为中间计算结果
* 如：MoneyHelper.multiply(MoneyHelper.divide("1","3"),"3")得不要结果1，
* 因为在除得时候他的结果作为中间结果，除运算结果保留小数点后10位，然后做精确乘，结果就为0.9999999999
*/
public class MoneyHelper {
//默认除法运算精度
private static final int DEFAULT_DIV_SCALE = 10;
//默认舍入模式
private static final int DEFAULT_ROUND_MODEL = BigDecimal.ROUND_HALF_UP;
//这个类不能实例化
private MoneyHelper(){
}
/**
舍入模式:
ROUND_CEILING 向正无穷方向舍入
ROUND_DOWN 向零方向舍入
ROUND_FLOOR 向负无穷方向舍入
ROUND_HALF_DOWN 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
ROUND_HALF_EVEN 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，则向相邻的偶数舍入
ROUND_HALF_UP 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
ROUND_UNNECESSARY 计算结果是精确的，不需要舍入模式
ROUND_UP 向远离0的方向舍入
*/
/**
* 提供精确的加法运算。
*
* @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 String add(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2).toString();
}
/**
* 提供精确的减法运算。
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double subtract(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 String subtract(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2).toString();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double multiply(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 String multiply(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2).toString();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_UP
*
* @param v1
* @param v2
* @return 两个参数的商
*/
public static double divide(double v1, double v2) {
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
*
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double divide(double v1, double v2, int scale) {
return divide(v1, v2, scale, DEFAULT_ROUND_MODEL);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
*
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商
*/
public static double divide(double v1, double v2, int scale, int round_mode) {
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, round_mode).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_UP
*
* @param v1
* @param v2
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2) {
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_UP
*
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale) {
return divide(v1, v2, scale, DEFAULT_ROUND_MODEL);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
*
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale, int round_mode) {
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.divide(b2, scale, round_mode).toString();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_UP
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale) {
return round(v, scale, DEFAULT_ROUND_MODEL);
}
/**
* 提供精确的小数位四舍五入处理
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果
*/
public static double round(double v, int scale, int round_mode) {
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, round_mode).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_UP
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale) {
return round(v, scale, DEFAULT_ROUND_MODEL);
}
/**
* 提供精确的小数位四舍五入处理
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale, int round_mode) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, round_mode).toString();
}
/**
* 取整数部分
*
* @param v 需要取整的数
* @return 截断小数点数字后的结果
*/
public static long getIntegerInstance(double v) {
BigDecimal b = new BigDecimal(Double.toString(v));
return b.setScale(0, BigDecimal.ROUND_DOWN).longValue();
}
/**
* 取整数部分
*
* @param v 需要取整的数
* @return 截断小数点数字后的结果
*/
public static String getIntegerInstance(String v) {
return round(v, 0, BigDecimal.ROUND_DOWN).toString();
}
/**
* 保留到小数点后面位数(截断需要保留小数位数后面的数值) eg:truncate(1.3456,3)=1.345
*
* @param v 需要保留的数
* @param scale 小数点后保留几位
* @return 截断后的结果
*/
public static double truncate(double v,int scale) {
return round(v, scale, BigDecimal.ROUND_DOWN);
}
/**
* 保留到小数点后面位数(截断需要保留小数位数后面的数值) eg:truncate("1.3456",3)=1.345
*
* @param v 需要保留的数
* @param scale 小数点后保留几位
* @return 截断后的结果
*/
public static String truncate(String v,int scale) {
return round(v, scale, BigDecimal.ROUND_DOWN).toString();
}
/**
* 转化为百分数的形式。如 getPercentInstance(63.25656,2)==>6,325.66%
*
* @param v
* @param scale 小数点后保留几位
* @return 返回
*/
public static String getPercentInstance(double v,int scale) {
NumberFormat percentFormat = NumberFormat.getPercentInstance();
percentFormat.setMinimumFractionDigits(scale);
return percentFormat.format(round(v,scale+2));
}
/**
* 转化为货币的形式,精确到分。如 getCurrencyInstance(6322.255,true)==>￥6,322.26
* @param v
* @param flag 是否显示￥ （ture显示）
* @return 返回货币的形式
* @return
*/
public static String getCurrencyInstance(double v, boolean flag) {
if (flag) {
NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
//return (currencyFormat.format(v)));错误
return (currencyFormat.format(round(v,2)));
} else {
NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMaximumFractionDigits(2);
//return (nf.format(v));错误
return (nf.format(round(v,2)));
}
}
/**
* 处理金额，使其有两位小数 如果传入的数小数位数大于2位，直接截断小数点2位后的数字，不考虑四舍五入
* @param str String
* @return String
*/
public static String dealMoneyFormat(String str) {
BigDecimal bd=new BigDecimal(MoneyHelper.getIntegerInstance(MoneyHelper.multiply(str,"100")));
return (bd.movePointLeft(2).toString());
}
public static String dealMoneyFormat(long amount) {
String str = Utils.divLongToString(amount);
BigDecimal bd=new BigDecimal(MoneyHelper.getIntegerInstance(MoneyHelper.multiply(str,"100")));
return (bd.movePointLeft(2).toString());
}
/**
* 处理金额数值问题
* @param str String
* @param n int
* @return String
*/
public static String shrRadixPoint(String str, int n) {
if ( (str == null) || (str == "") || ("null".equals(str))) {
return "0";
}
BigDecimal b1 = new BigDecimal(str);
return b1.movePointLeft(n).toString();
}
public static void main(String[] agrs){
double d1 = 1.23;
double d2 = 2.34;
//加法
System.out.println(MoneyHelper.add(d1,d2));
//减法
System.out.println(MoneyHelper.subtract(d2,d1));
//乘法
System.out.println(MoneyHelper.multiply(d1,100));
//除法
System.out.println(MoneyHelper.divide(d1,2));
System.out.println(MoneyHelper.multiply(MoneyHelper.divide("1","3"),"3"));
//四舍五入
System.out.println(MoneyHelper.round(d1,1));
//取整
System.out.println(MoneyHelper.getIntegerInstance(d1));
//百分号
System.out.println(MoneyHelper.getPercentInstance(63.25655,2));
//转化
System.out.println(MoneyHelper.getCurrencyInstance(333.145,false));
System.out.println(MoneyHelper.getCurrencyInstance(333.145,true));
//格式化数字
NumberFormat nnf = NumberFormat.getInstance();
nnf.setMaximumFractionDigits(0);
System.out.println(nnf.format(333.5145));
//保留分
System.out.println(MoneyHelper.dealMoneyFormat("0.006546546"));
//转小数
System.out.println(shrRadixPoint("300000",2));
}
}
结果：
3.57
1.11
123.0
0.615
0.9999999999
1.2
1
6,325.66%
333.15
￥333.15
334
0.00
3000.00
标签：scale,return,BigDecimal,取舍,param,String,v2,Java,加减乘除 来源： https://blog.csdn.net/qq_34955471/article/details/113522271