Double加减乘除运算

package com.sicilon.provider.config;
 
import java.math.BigDecimal;
import java.text.NumberFormat;
 
public class DoubleUtils {
	private static final int DEF_DIV_SCALE = 10;  
	  
	/** 
	* * 两个Double数相加 * 
	*  
	* @param v1 * 
	* @param v2 * 
	* @return Double 
	*/  
	public static Double add(Double v1, Double v2) {  
	   BigDecimal b1 = new BigDecimal(v1.toString());  
	   BigDecimal b2 = new BigDecimal(v2.toString());  
	   return new Double(b1.add(b2).doubleValue());  
	}  
	  
	/** 
	* * 两个Double数相减 * 
	*  
	* @param v1 * 
	* @param v2 * 
	* @return Double 
	*/  
	public static Double sub(Double v1, Double v2) {  
	   BigDecimal b1 = new BigDecimal(v1.toString());  
	   BigDecimal b2 = new BigDecimal(v2.toString());  
	   return new Double(b1.subtract(b2).doubleValue());  
	}  
	  
	/** 
	* * 两个Double数相乘 * 
	*  
	* @param v1 * 
	* @param v2 * 
	* @return Double 
	*/  
	public static Double mul(Double v1, Double v2) {  
	   BigDecimal b1 = new BigDecimal(v1.toString());  
	   BigDecimal b2 = new BigDecimal(v2.toString());  
	   return new Double(b1.multiply(b2).doubleValue());  
	}  
	  
	/** 
	* * 两个Double数相除 * 
	*  
	* @param v1 * 
	* @param v2 * 
	* @return Double 
	*/  
	public static Double div(Double v1, Double v2) {  
	   BigDecimal b1 = new BigDecimal(v1.toString());  
	   BigDecimal b2 = new BigDecimal(v2.toString());  
	   return new Double(b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP)  
	     .doubleValue());  
	}  
	  
	/** 
	* * 两个Double数相除，并保留scale位小数 * 
	*  
	* @param v1 * 
	* @param v2 * 
	* @param scale * 
	* @return Double 
	*/  
	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(v1.toString());  
	   BigDecimal b2 = new BigDecimal(v2.toString());  
	   return new Double(b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue());  
	}  
	  public static String doubleToStr(Double d) {
	        if (d == null) {
	            return "";
	        }
	        NumberFormat nf = NumberFormat.getInstance();
	        nf.setGroupingUsed(false);
	        return (nf.format(d));
	    }
	  
	  public static String doubleToStr(String d) {
	        if (d == null) {
	            return "";
	        }
	        NumberFormat nf = NumberFormat.getInstance();
	        nf.setGroupingUsed(false);
	        return (nf.format(d));
	    }
 
}

public class DoubleCompare {
    private static final int DEF_DIV_SCALE = 10;
    /**
     * 相等
     * 
     * @param d1
     *            左数
     * @param d2
     *            右数
     * @param digit
     *            小数位
     * @return
     */
    final static public boolean isEqual(double d1, double d2, int digit) {
        return Arith.compare(formatDoubleValue(d1, digit), formatDoubleValue(d2, digit)) == 0;
    }
    
    
    /**
     * 判断浮点数相等
     * 
     * @param d1
     *            左数
     * @param d2
     *            右数
     * @param e
     *            无穷小
     * @return
     */
    final static public boolean doubleEqual(double d1, double d2, double e) {
        return Math.abs(d1-d2) < e;
    }

    /**
     * 小于
     * 
     * @param d1
     *            左数
     * @param d2
     *            右数
     * @param digit
     *            小数位
     * @return
     */
    final static public boolean less(double d1, double d2, int digit) {
        return formatDoubleValue(d1, digit) < formatDoubleValue(d2, digit);
    }
    /**
     * 大于 例： DoubleCompare.large(1,0,2) 表示 1 > 0
     * 
     * @param d1
     *            左数
     * @param d2
     *            右数
     * @param digit
     *            小数位
     * @return
     */
    final static public boolean large(double d1, double d2, int digit) {
        return formatDoubleValue(d1, digit) > formatDoubleValue(d2, digit);
    }

    /**
     * 小于等于
     * 
     * @param d1
     *            左数
     * @param d2
     *            右数
     * @param digit
     *            小数位
     * @return
     */
    final static public boolean lessEqual(double d1, double d2, int digit) {
        return formatDoubleValue(d1, digit) <= formatDoubleValue(d2, digit);
    }

    /**
     * 格式化Double类型数据
     * @param d
     * @param digit
     * @return
     */
    static public double formatDoubleValue(double d, int digit) {
        BigDecimal b = BigDecimal.valueOf(d);
        b = b.setScale(digit, BigDecimal.ROUND_HALF_UP);
        return b.doubleValue();
    }
    
    /**
     * 格式化Double类型数据
     * @param d
     * @param digit
     * @return
     */
    static public BigDecimal formatDoubleValueToBigDecimal(double d, int digit) {
        BigDecimal b = BigDecimal.valueOf(d);
        b = b.setScale(digit, BigDecimal.ROUND_HALF_UP);
        return b;
    }
    
    /**
     * 方法描述：得到计算后的金额 d2的基础上进行d1的计算
     * 创建人：syc
     * 创建：2012-7-2 下午05:22:35  
     * 备注：
     * @param d1
     * @param d2
     * @param type 1:加法，2：减法，3：乘法
     * @return
     */
    static public double getCalculateSum(double d1,double d2,int type){
       BigDecimal oldSumBig = new BigDecimal(Double.toString(d1));
       BigDecimal newSumBig = new BigDecimal(Double.toString(d2));
       //加法
       if(type==1){
          newSumBig = newSumBig.add(oldSumBig); 
       } else if(type==2){
           //减法
          newSumBig = newSumBig.subtract(oldSumBig);
       } else if(type==3){
           //乘法
          newSumBig = newSumBig.multiply(oldSumBig);
        }
       return newSumBig.doubleValue();
   }
    /**
     * 方法描述：得到计算后的金额 d2的基础上进行d1的计算（避免空的值导致转换异常）
     * 创建人：syc
     * 创建：2014-6-28 下午05:22:35  
     * 备注：
     * @param d1
     * @param d2
     * @param type 1:加法，2：减法，3：乘法
     * @return
     */
    static public double getCalculateObjSum(Double d1,Double d2,int type){
        double d1Tmp=0.0;
        if(d1 != null) {
            d1Tmp = d1.doubleValue();
        }else{
           d1Tmp = 0.0 ;
        }
        double d2Tmp=0.0;
        if(d2 != null) {
            d2Tmp = d2.doubleValue();
        }else{
           d2Tmp = 0.0 ;
        }
        BigDecimal oldSumBig = new BigDecimal(Double.toString(d1Tmp));
        BigDecimal newSumBig = new BigDecimal(Double.toString(d2Tmp));
        //加法
        if(type==1){
            newSumBig = newSumBig.add(oldSumBig); 
        } else if(type==2){
            //减法
            newSumBig = newSumBig.subtract(oldSumBig);
        } else if(type==3){
            //乘法
            newSumBig = newSumBig.multiply(oldSumBig);
        }
        return newSumBig.doubleValue();
    }
    /**
     * 处理SAP金额字段,负数时格式是：123.45-
     *
     * @param doubleStr 金额字段字符串
     * @return
     */
    public static final Double getValueFromSap(String doubleStr) {
        if (StringUtils.isBlank(doubleStr)) {
            return 0.0d;
        }
        if (doubleStr.endsWith("-")) {
            String replaceDoubleStr = doubleStr.replace("-", "");
            return - Double.parseDouble(replaceDoubleStr);
        }else {
            return Double.parseDouble(doubleStr);
        }
    }
    /**
     * 两个Double数相加
     * @param v1
     * @param v2
     * @return Double
     */
    final static public Double add(Double v1,Double v2){
        BigDecimal b1 = new BigDecimal(v1.toString());
        BigDecimal b2 = new BigDecimal(v2.toString());
        return b1.add(b2).doubleValue();
    }

    /**
     * 两个Double数相减
     * @param v1
     * @param v2
     * @return Double
     */
    final static public Double sub(Double v1,Double v2){
        BigDecimal b1 = new BigDecimal(v1.toString());
        BigDecimal b2 = new BigDecimal(v2.toString());
        return b1.subtract(b2).doubleValue();
    }
    /**
     * * 两个Double数相除 *
     *
     * @param v1 *
     * @param v2 *
     * @return Double
     */
    public static Double div(Double v1, Double v2) {
        BigDecimal b1 = new BigDecimal(v1.toString());
        BigDecimal b2 = new BigDecimal(v2.toString());
        return new Double(b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue());
    }

    /**
     * * 两个Double数相除，并保留scale位小数 *
     *
     * @param v1 *
     * @param v2 *
     * @param scale *
     * @return Double
     */
    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(v1.toString());
        BigDecimal b2 = new BigDecimal(v2.toString());
        return new Double(b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue());
    }

    public static String doubleToStr(Double d) {
        if (d == null) {
            return "";
        }
        NumberFormat nf = NumberFormat.getInstance();
        nf.setGroupingUsed(false);
        return (nf.format(d));
    }

    public static String doubleToStr(String d) {
        if (d == null) {
            return "";
        }
        NumberFormat nf = NumberFormat.getInstance();
        nf.setGroupingUsed(false);
        return (nf.format(d));
    }

}