精确计算工具类，提供加减乘除的计算

原文地址：http://www.cnblogs.com/linjiqin/p/5550760.html

package com.system.util;

import java.math.BigDecimal;

/**
* 精确计算工具类，提供加减乘除的计算
*
* @author jqlin
*/
public class CompuUtils {
/**小数点后保留的位数*/
public static final int SCALE = 5;
/** 0 */
public static final int ZERO = 0;

/**
* BigDecimal大小比较
*
* @param a
* @param b
* @return 返回1， 表示a大于b <br/>
* 返回0 ，表示a等于b <br/>
* 返回-1，表示a小于b
* @author jqlin
*/
public static int compareTo(BigDecimal a, BigDecimal b){
return a.compareTo(b);
}

/**
* double大小比较
*
* @param a
* @param b
* @return 返回1， 表示a大于b <br/>
* 返回0 ，表示a等于b <br/>
* 返回-1，表示a小于b
* @author jqlin
*/
public static int compareTo(double a, double b){
return compareTo(String.valueOf(a), String.valueOf(b));
}

/**
* float大小比较
*
* @param a
* @param b
* @return 返回1， 表示a大于b <br/>
* 返回0 ，表示a等于b <br/>
* 返回-1，表示a小于b
* @author jqlin
*/
public static int compareTo(float a, float b){
return compareTo(String.valueOf(a), String.valueOf(b));
}

/**
* 数值大小比较
*
* @param a
* @param b
* @return 返回1， 表示a大于b <br/>
* 返回0 ，表示a等于b <br/>
* 返回-1，表示a小于b
* @author jqlin
*/
public static int compareTo(String a, String b){
return compareTo(new BigDecimal(a), new BigDecimal(b));
}

/**
* 累加运算
*
* @param scale
* @param vals 小数点后保留几位
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal add(int scale, BigDecimal... vals) {
if(vals == null || vals.length <= 0){
return null;
}

BigDecimal sum = new BigDecimal("0");
for(BigDecimal val : vals){
sum = sum.add(val);
}

return sum.setScale(scale, BigDecimal.ROUND_HALF_UP);
}

/**
* 累加运算
*
* @param vals
* @return
* @author jqlin
*/
public static int add(int... vals) {
if(vals == null || vals.length <= 0){
return 0;
}

int sum = 0;
for(int val : vals){
sum = sum + val;
}

return sum;
}

/**
* 累加运算
*
* @param scale
* @param vals 小数点后保留几位
* @return 四舍五入后的结果
* @author jqlin
*/
public static double add(int scale, double... vals) {
if(vals == null || vals.length <= 0){
return 0;
}

BigDecimal sum = new BigDecimal("0");
for(double val : vals){
sum = sum.add(new BigDecimal(val));
}

return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}

/**
* 累加运算
*
* @param scale
* @param vals 小数点后保留几位
* @return 四舍五入后的结果
* @author jqlin
*/
public static float add(int scale, float... vals) {
if(vals == null || vals.length <= 0){
return 0;
}

BigDecimal sum = new BigDecimal("0");
for(float val : vals){
sum = sum.add(new BigDecimal(val));
}

return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).floatValue();
}

/**
* 加法运算
*
* @param a 被加数
* @param b 加数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal add(BigDecimal a, BigDecimal b, int scale) {
if(scale < 0){
scale = SCALE;
}
return a.add(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
}

/**
* 加法运算
*
* @param a 被加数
* @param b 加数
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal add(BigDecimal a, BigDecimal b) {
return add(a, b, SCALE);
}

/**
* 加法运算
*
* @param a 被加数
* @param b 加数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static double add(double a, double b, int scale) {
if(scale < 0){
scale = SCALE;
}

return add(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
}

/**
* 加法运算
*
* @param a 被加数
* @param b 加数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static double add(double a, double b) {
return add(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
}

/**
* 减法运算
*
* @param a 被减数
* @param b 减数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal subtract(BigDecimal a, BigDecimal b, int scale) {
if(scale < 0){
scale = SCALE;
}
return a.subtract(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
}

/**
* 减法运算
*
* @param a 被减数
* @param b 减数
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal subtract(BigDecimal a, BigDecimal b) {
return subtract(a, b, SCALE);
}

/**
* 减法运算
*
* @param a 被减数
* @param b 减数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static double subtract(double a, double b, int scale) {
if(scale < 0){
scale = SCALE;
}

return subtract(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
}

/**
* 减法运算
*
* @param a 被减数
* @param b 减数
* @return 四舍五入后的结果
* @author jqlin
*/
public static double subtract(double a, double b) {
return subtract(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
}

/**
* 乘法运算
*
* @param a 被乘数
* @param b 乘数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal multiply(BigDecimal a, BigDecimal b, int scale) {
if(scale < 0){
scale = SCALE;
}
return a.multiply(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
}

/**
* 乘法运算
*
* @param a 被乘数
* @param b 乘数
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal multiply(BigDecimal a, BigDecimal b) {
return multiply(a, b, SCALE);
}

/**
* 乘法运算
*
* @param a 被乘数
* @param b 乘数
* @param scale 小数点后保留几位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static double multiply(double a, double b, int scale) {
if(scale < 0){
scale = SCALE;
}

return multiply(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
}

/**
* 乘法运算
*
* @param a 被乘数
* @param b 乘数
* @return 四舍五入后的结果
* @author jqlin
*/
public static double multiply(double a, double b) {
return multiply(a, b, SCALE);
}

/**
* 除法运算
*
* @param a 被除数
* @param b 除数
* @param scale 保留小数点后多少位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal divide(BigDecimal a, BigDecimal b, int scale) {
if(scale < 0){
scale = SCALE;
}

return a.divide(b, scale, BigDecimal.ROUND_HALF_UP);
}

/**
* 除法运算，默认保留5位小数点
*
* @param a 被除数
* @param b 除数
* @return 四舍五入后的结果
* @author jqlin
*/
public static BigDecimal divide(BigDecimal a, BigDecimal b) {
return divide(a, b, SCALE);
}

/**
* 除法运算
*
* @param a 被除数
* @param b 除数
* @param scale 保留小数点后多少位, 默认保留5位小数点
* @return 四舍五入后的结果
* @author jqlin
*/
public static double divide(double a, double b, int scale) {
if(scale < 0){
scale = SCALE;
}

return divide(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
}

/**
* 除法运算，默认保留5位小数点
*
* @param a 被除数
* @param b 除数
* @return 四舍五入后的结果
* @author jqlin
*/
public static double divide(double a, double b) {
return divide(a, b, SCALE);
}

public static void main(String[] args) {
System.out.println(compareTo(new BigDecimal("1.000000000000000000000001"), new BigDecimal("1.000000000000000000000002")));
System.out.println(compareTo("1.000000000000000000000001", "1.000000000000000000000002"));
System.out.println(compareTo(1.0100010001D, 1.0100010002D));
System.out.println(compareTo(1.010001F, 1.010002F));

}
}