double浮点类型计算工具类

package com.minxinloan.utils;
import java.math.BigDecimal;
public class DoubleUtil {
/*
* 默认小数位
*
*/
private static final int DEF_DIV_SCALE = 2;

/*****************加法计算***************************
* 多个double参数相加
* 默认保留两位小数
* @param values传递的参数值，依次相加
* 例如：a,b,c 计算方式为 a+b+c
* @return 计算结果 返回小数位为2
* @author
*/
public static double add(Double ...values){
return add(DEF_DIV_SCALE,values);
}
/**
* 多个double参数相加
* @param scale 保留的小数位数
* @param values 传递的参数值，依次相加
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double add(int scale,Double ...values){
BigDecimal temp = null ;
double result  = 0 ;
for(Double d  : values){
if(d == null ){
d = 0.00 ;
}
if(temp == null ){
temp = new BigDecimal(Double.toString(d));
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(Double.toString(d));
result = temp.add(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/**
* 多个double参数相加
* 默认保留两位小数
* @param values传递的参数值，依次相加
* 例如：a,b,c 计算方式为 a+b+c
* @return 计算结果 返回小数位为2
* @author
*/
public static double add(String ...values){
return add(DEF_DIV_SCALE,values);
}
/**
* 多个double参数相加
* @param scale 保留的小数位数
* @param values 传递的参数值，依次相加
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double add(int scale,String ...values){
BigDecimal temp = null ;
double result  = 0 ;
for(String d  : values){
if(d == null){
d ="0.00";
}
if(temp == null ){
temp = new BigDecimal(d);
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(d);
result = temp.add(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/*****************减法计算***************************
* 多个数的减法运算
* @param values 按照传入的参数顺序，依次相减
* 例如：a,b,c 计算方式为 a-b-c
* @return 计算结果，返回小数位为2
* @author
*/
public static double sub(Double ...values) {
return sub(DEF_DIV_SCALE, values);
}
/**
* 多个数的减法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相减
* 例如：a,b,c 计算方式为 a-b-c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double sub(int scale,Double ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(Double d  : values){
if(d == null ){
d = 0.00 ;
}
if(temp == null ){
temp = new BigDecimal(Double.toString(d));
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(Double.toString(d));
result = temp.subtract(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/**
* 多个数的减法运算
* @param values 按照传入的参数顺序，依次相减
* 例如：a,b,c 计算方式为 a-b-c
* @return 计算结果，返回小数位为2
* @author
*/
public static double sub(String ...values) {
return sub(DEF_DIV_SCALE, values);
}
/**
* 多个数的减法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相减
* 例如：a,b,c 计算方式为 a-b-c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double sub(int scale,String ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(String d  : values){
if(d == null){
d="0.00";
}
if(temp == null ){
temp = new BigDecimal(d);
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(d);
result = temp.subtract(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/*****************乘法计算***************************
* 多个数的乘法法运算
* @param values 按照传入的参数顺序，依次相乘
* 例如：a,b,c 计算方式为 a*b*c
* @return 计算结果，返回小数位为2
* @author
*/
public static double mul(Double ...values) {
return mul(DEF_DIV_SCALE,values);
}
/**
* 多个数的乘法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相乘
* 例如：a,b,c 计算方式为 a*b*c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double mul(int scale,Double ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(Double d  : values){
if(d == null ){
d = 0.00 ;
}
if(temp == null ){
temp = new BigDecimal(Double.toString(d));
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(Double.toString(d));
result = temp.multiply(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/**
* 多个数的乘法法运算
* @param values 按照传入的参数顺序，依次相乘
* 例如：a,b,c 计算方式为 a*b*c
* @return 计算结果，返回小数位为2
* @author
*/
public static double mul(String ...values) {
return mul(DEF_DIV_SCALE,values);
}
/**
* 多个数的乘法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相乘
* 例如：a,b,c 计算方式为 a*b*c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double mul(int scale,String ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(String d  : values){
if(d == null){
d = "0.00" ;
}
if(temp == null ){
temp = new BigDecimal(d);
result = temp.doubleValue();
}else{
temp = new BigDecimal(result);
BigDecimal b2 = new BigDecimal(d);
result = temp.multiply(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/*********************除法计算***************************
* 多个数的除法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相除
* 例如：a,b,c 计算方式为 a/b/c
* @return 计算结果 返回小数位为2
* @author
*/
public static double div(Double ...values) {
return div(DEF_DIV_SCALE,values);
}

/**
* 多个数的除法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相除
* 例如：a,b,c 计算方式为 a/b/c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double div(int scale,Double ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(Double d  : values){
if(d == null ){
d = 0.00 ;
}
if(temp == null ){
temp = new BigDecimal(Double.toString(d));
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(Double.toString(d));
result = temp.divide(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}
/**
* 多个数的除法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相除
* 例如：a,b,c 计算方式为 a/b/c
* @return 计算结果 返回小数位为2
* @author
*/
public static double div(String ...values) {
return div(DEF_DIV_SCALE,values);
}
/**
* 多个数的除法运算
* @param scale 保留的小数位数
* @param values 按照传入的参数顺序，依次相除
* 例如：a,b,c 计算方式为 a/b/c
* @return 计算结果 返回小数位为输入值
* @author
*/
public static double div(int scale,String ...values) {
BigDecimal temp = null ;
double result  = 0 ;
for(String d  : values){
if(d == null){
d = "0.00";
}
if(temp == null ){
temp = new BigDecimal(d);
result = temp.doubleValue();
}else{
temp = new BigDecimal(Double.toString(result));
BigDecimal b2 = new BigDecimal(d);
result = temp.divide(b2).doubleValue();
}
}
if(temp != null ){
return round(result,scale);
}
return  0.00;
}

/********************四色五入**********************************
* 提供精确的小数位四舍五入处理。
* @param value 需要四舍五入的数字
* @return 四舍五入后的结果,默认两位
* @author
*/
public static double round(double value) {
return round(value,DEF_DIV_SCALE);
}
/**
* 提供精确的小数位四舍五入处理。
* @param value 需要四舍五入的数字
* @param scale小数点后保留几位
* @return 四舍五入后的结果
* @author
*/
public static double round(double value, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"输入小数位错误，输入的小数位为："+scale);
}
BigDecimal b = new BigDecimal(Double.toString(value));
BigDecimal init = new BigDecimal("1");
return b.divide(init, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}

public static double string2Double(String value,int scale){
if(value == null){
value = "0.00" ;
}
BigDecimal b = new BigDecimal(value);
return round(b.doubleValue(), scale);
}

public static double string2Double(String value){
if(value == null || "".equals(value)){
value="0";
}
BigDecimal b = new BigDecimal(value);
return round(b.doubleValue(), DEF_DIV_SCALE);
}

public static double null2Double(Double d){
if(d == null ){
return 0.00d;
}
return d ;
}
}