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 ;
 }
}
相關文章
相關標籤/搜索