java 金额精度计算工具类

import java.math.BigDecimal;


public class PriceUtils {

    
    private static final int DEFAULT_DIV_SCALE = 10;

    
    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();
    }

    
    public static String add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).toString();
    }

    
    public static int compareTo(double value, double basevalue) {
        return MathUtils.compareTo(value, basevalue, 2);
    }

    
    public static int compareTo(double value, double basevalue, int scale) {
        BigDecimal v1 = new BigDecimal(value).setScale(scale, BigDecimal.ROUND_HALF_UP);
        BigDecimal v2 = new BigDecimal(basevalue).setScale(scale, BigDecimal.ROUND_HALF_UP);
        return v1.compareTo(v2);
    }

    
    public static int compareTo(String value, String basevalue) {
        return MathUtils.compareTo(value, basevalue, 2);
    }

    
    public static int compareTo(String value, String basevalue, int scale) {
        BigDecimal v1 = new BigDecimal(value).setScale(scale, BigDecimal.ROUND_HALF_UP);
        BigDecimal v2 = new BigDecimal(basevalue).setScale(scale, BigDecimal.ROUND_HALF_UP);
        return v1.compareTo(v2);
    }

    
    public static boolean compareWithZero(double value) {
        return MathUtils.isEqual(value, 0.00);
    }

    
    public static boolean compareWithZero(String value) {
        return MathUtils.isEqual(value, "0.00");
    }

    
    public static double divide(double v1, double v2) {
        return MathUtils.divide(v1, v2, MathUtils.DEFAULT_DIV_SCALE);
    }

    
    public static double divide(double v1, double v2, int scale) {
        return MathUtils.divide(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
    }

    
    public static double divide(double v1, double v2, int scale, int round_mode) {
        MathUtils.scaleCheck(scale);
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, round_mode).doublevalue();
    }

    
    public static String divide(String v1, String v2) {
        return MathUtils.divide(v1, v2, MathUtils.DEFAULT_DIV_SCALE);
    }

    
    public static String divide(String v1, String v2, int scale) {
        return MathUtils.divide(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
    }

    
    public static String divide(String v1, String v2, int scale, int round_mode) {
        MathUtils.scaleCheck(scale);
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2, scale, round_mode).toString();
    }

    
    public static boolean isEqual(double value, double basevalue) {
        return MathUtils.compareTo(value, basevalue) == 0;
    }

    
    public static boolean isEqual(String value, String basevalue) {
        return MathUtils.compareTo(value, basevalue) == 0;
    }

    
    public static boolean isLessThan(double value, double basevalue) {
        return MathUtils.compareTo(value, basevalue) <= 0;
    }

    
    public static boolean isLessThan(String value, String basevalue) {
        return MathUtils.compareTo(value, basevalue) <= 0;
    }

    
    public static boolean isLessThanZero(double value) {
        return MathUtils.isLessThan(value, 0.00);
    }

    
    public static boolean isLessThanZero(String value) {
        return MathUtils.isLessThan(value, "0.00");
    }

    
    public static boolean isMoreThan(double value, double basevalue) {
        return MathUtils.compareTo(value, basevalue) >= 0;
    }

    
    public static boolean isMoreThan(String value, String basevalue) {
        return MathUtils.compareTo(value, basevalue) >= 0;
    }

    
    public static boolean isMoreThanOne(double value) {
        return MathUtils.isMoreThan(value, 0.01);
    }

    
    public static boolean isMoreThanOne(String value) {
        return MathUtils.isMoreThan(value, "0.01");
    }

    
    public static boolean isNotEqual(double value, double basevalue) {
        return MathUtils.compareTo(value, basevalue) != 0;
    }

    
    public static boolean isNotEqual(String value, String basevalue) {
        return MathUtils.compareTo(value, basevalue) != 0;
    }

    
    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();
    }

    
    public static String multiply(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

    
    public static Integer multiplyInt(String v1, String v2) {
        if (!org.apache.commons.lang3.math.NumberUtils.isNumber(v1)
            || !org.apache.commons.lang3.math.NumberUtils.isNumber(v2)) {
            return 0;
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return Integer.valueOf(b1.multiply(b2).toBigInteger().toString());
    }

    
    public static Long multiplyLong(String v1, String v2) {
        if (!org.apache.commons.lang3.math.NumberUtils.isNumber(v1)
            || !org.apache.commons.lang3.math.NumberUtils.isNumber(v2)) {
            return 0l;
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toBigInteger().longValue();
    }

    
    public static double round(double v, int scale) {
        return MathUtils.round(v, scale, BigDecimal.ROUND_HALF_UP);
    }

    
    public static double round(double v, int scale, int round_mode) {
        MathUtils.scaleCheck(scale);
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, round_mode).doublevalue();
    }

    
    public static String round(String v, int scale) {
        return MathUtils.round(v, scale, BigDecimal.ROUND_HALF_UP);
    }

    
    public static String round(String v, int scale, int round_mode) {
        if (v == null) {
            return null;
        }
        MathUtils.scaleCheck(scale);
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, round_mode).toString();
    }

    
    private static void scaleCheck(int scale) {
        if (scale < 0) {
            String msg = "The scale must be a positive integer or zero";
            throw new IllegalArgumentException(msg);
        }
    }

    
    public static int simpleCompareTo(double value, double basevalue) {
        BigDecimal v1 = new BigDecimal(value);
        BigDecimal v2 = new BigDecimal(basevalue);
        return v1.compareTo(v2);
    }

    
    public static int simpleCompareTo(String value, String basevalue) {
        BigDecimal v1 = new BigDecimal(value);
        BigDecimal v2 = new BigDecimal(basevalue);
        return v1.compareTo(v2);
    }

    
    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();
    }

    
    public static String subtract(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).toString();
    }
}