Java-精確計算工具類

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 精確計算工具類(加，減，乘，除，返回較大值，返回較小值)
 */
public class CalculationUtil {

    /**
     * 提供精確加法計算的add方法
     */
    public static String add(String value1, String value2) {
        return add(value1, value2, 0, 0);
    }

    /**
     * 提供精確加法計算的add方法(默認四捨五入)
     * @param value1 被加數
     * @param value2 加數
     * @param scale 精確范圍(小數點后幾位)
     */
    public static String add(String value1, String value2, int scale) {
        return add(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 提供精確加法計算的add方法
     * @param value1 被加數
     * @param value2 加數
     * @param scale 精確范圍(小數點后幾位)
     * @param roundingMode 精確模式
     */
    public static String add(String value1, String value2, int scale, int mode) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        BigDecimal result = b1.add(b2);
        // mode為0，則不需要精確
        if (mode != 0) {
            result = result.setScale(scale, mode);
        }
        return result.toString();
    }

    public static int compareTo(String value1, String value2, int scale, int mode) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        BigDecimal result = b1.subtract(b2);
        // mode為0，則不需要精確
        if (mode != 0) {
            result = result.setScale(scale, mode);
        }
        return result.compareTo(BigDecimal.ZERO);
    }

    /**
     * 提供精確的除法運算方法divide
     * @param value1 被除數
     * @param value2 除數
     */
    public static String divide(String value1, String value2) throws IllegalAccessException {
        return divide(value1, value2, 0, null);
    }

    /**
     * 提供精確的除法運算方法divide(默認四捨五入)
     * @param value1 被除數
     * @param value2 除數
     * @param scale 精確范圍(小數點后幾位)
     */
    public static String divide(String value1, String value2, int scale) throws IllegalAccessException {
        return divide(value1, value2, scale, RoundingMode.HALF_UP);
    }

    /**
     * 提供精確的除法運算方法divide
     * 
     * @param value1 被除數
     * @param value2 除數
     * @param scale 精確范圍(小數點后幾位)
     * @param roundingMode 精確模式
     */
    public static String divide(String value1, String value2, int scale, RoundingMode roundingMode)
            throws IllegalAccessException {
        // 如果精確范圍小於0，拋出異常信息
        if (scale < 0) {
            throw new IllegalAccessException("精確度不能小於0");
        }
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        // roundingMode為null，則不需要精確
        if (roundingMode != null) {
            return new Double(b1.divide(b2, scale, roundingMode).doubleValue()).toString();
        } else {
            return new Double(b1.divide(b2).doubleValue()).toString();
        }
    }

    /**
     * 比較大小 ：返回較大的那個
     */
    public static String getMax(String value1, String value2) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        return new Double(b1.max(b2).doubleValue()).toString();
    }

    /**
     * 比較大小 ：返回較小的那個
     */
    public static String getMin(String value1, String value2) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        return new Double(b1.min(b2).doubleValue()).toString();
    }


    /**
     *
     * 提供精確乘法運算的multiply方法
     * @param value1 被乘數
     * @param value2 乘數
     * @return 兩個參數的積
     */
    public static String multiply(String value1, String value2) {
        return multiply(value1, value2, 0, 0);
    }

    /**
     * 提供精確乘法運算的multiply方法(默認四捨五入)
     * @param value1 被乘數
     * @param value2 乘數
     * @param scale 精確范圍(小數點后幾位)
     */
    public static String multiply(String value1, String value2, int scale) {
        return multiply(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 提供精確乘法運算的multiply方法
     * @param value1 被乘數
     * @param value2 乘數
     * @param scale 精確范圍(小數點后幾位)
     * @param roundingMode 精確模式
     */
    public static String multiply(String value1, String value2, int scale, int mode) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        BigDecimal result = b1.multiply(b2);
        // mode為0，則不需要精確
        if (mode != 0) {
            result = result.setScale(scale, mode);
        }
        return result.toString();
    }

    /**
     * 提供精確減法運算的subtract方法
     * @param value1 被減數
     * @param value2 減數
     * @return 兩個參數的差
     */
    public static String subtract(String value1, String value2) {
        return subtract(value1, value2, 0, 0);
    }

    /**
     * 提供精確減法運算的subtract方法(默認四捨五入)
     * @param value1 被減數
     * @param value2 減數
     * @param scale 精確范圍(小數點后幾位)
     */
    public static String subtract(String value1, String value2, int scale) {
        return subtract(value1, value2, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 提供精確減法運算的subtract方法
     * @param value1 被減數
     * @param value2 減數
     * @param scale 精確范圍(小數點后幾位)
     * @param roundingMode 精確模式
     */
    public static String subtract(String value1, String value2, int scale, int mode) {
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));
        BigDecimal result = b1.subtract(b2);
        // mode為0，則不需要精確
        if (mode != 0) {
            result = result.setScale(scale, mode);
        }
        return result.toString();
    }
}