java 公式计算

package com.icss.assessment.util;


import java.math.BigDecimal;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 数据计算公式
 * 
 * @author zhangSen
 * 
 */
public class MathEvalUtil {


public static char PLUS = '+';
public static char MINUS = '-';
public static char MULTI = '*';
public static char DEVIDE = '/';


public static char BRACKET_LEFT = '(';
public static char BRACKET_RIGHT = ')';


/**
* 计算带小括号的公式
* 
* @param line
* @return
*/
public static BigDecimal eval(String line) {
while (line.indexOf(BRACKET_LEFT) != -1) {
// 查找小括号正则表达式
Pattern pattern = Pattern.compile("\\(([^\\(\\)]*?)\\)");
Matcher matcher = pattern.matcher(line);
while (matcher.find()) {
BigDecimal result = simpleEval(matcher.group(1));
line = line.replace(matcher.group(), result + "");
}
}
return simpleEval(line);
}


/**
* 计算不带括号的公式
* 
* @param line
* @return
*/
@SuppressWarnings("unchecked")
public static BigDecimal simpleEval(String line) {
Stack<BigDecimal> valueStack = new Stack<BigDecimal>();// 保存值的堆栈
Stack<Character> markStack = new Stack<Character>();// 保存符号的堆栈


char ch[] = line.toCharArray();


// 计算乘除操作
String tmpValue = "";
boolean isOper = false;
for (int i = 0; i < ch.length; i++) {
if (ch[i] == PLUS || ch[i] == MINUS || ch[i] == MULTI
|| ch[i] == DEVIDE) {
if (tmpValue.indexOf("%") > 0) {
tmpValue = Double.valueOf(tmpValue.replace("%", ""))
.doubleValue() / 100 + "";
}
BigDecimal dv = new BigDecimal(tmpValue);
if (isOper) {
BigDecimal dv1 = valueStack.pop();
char op = markStack.pop();
BigDecimal result = simpleTwoEval(op, dv1, dv);
dv = result;
}
valueStack.push(dv);
markStack.push(ch[i]);
tmpValue = "";
isOper = false;
if (ch[i] == MULTI || ch[i] == DEVIDE)
isOper = true;
} else {
tmpValue += ch[i] + "";


if (i == ch.length - 1) {
if (tmpValue.indexOf("%") > 0) {
tmpValue = Double.valueOf(tmpValue.replace("%", ""))
.doubleValue() / 100 + "";
}
BigDecimal dv = new BigDecimal(tmpValue);
if (isOper) {
BigDecimal dv1 = valueStack.pop();
char op = markStack.pop();
BigDecimal result = simpleTwoEval(op, dv1, dv);
dv = result;
}
valueStack.push(dv);
}
}
}


// 计算加减操作
valueStack = (Stack<BigDecimal>) reverseStack(valueStack);
markStack = (Stack<Character>) reverseStack(markStack);
while (valueStack.size() > 1) {
BigDecimal v1 = valueStack.pop();
BigDecimal v2 = valueStack.pop();
char op = markStack.pop();
BigDecimal result = simpleTwoEval(op, v1, v2);
valueStack.push(result);
}
return valueStack.get(0);
}


/**
* 把整个堆栈翻转
* 
* @param stack
* @return
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
private static Stack<?> reverseStack(Stack<?> stack) {
Stack reverse = new Stack();
int stackSize = stack.size();
for (int i = 0; i < stackSize; i++) {
reverse.push(stack.pop());
}
return reverse;
}


/**
* 只计算简单的两个数结果
* 
* @param op
* @param value1
* @param value2
* @return
*/
private static BigDecimal simpleTwoEval(char op, BigDecimal value1, BigDecimal value2) {
if (op == PLUS) {
return value1.add(value2);
} else if (op == MINUS) {
return value1.subtract(value2);
} else if (op == MULTI) {
return value1.multiply(value2);
} else if (op == DEVIDE) {
return value1.divide(value2);
}
return new BigDecimal(0);
}


public static void main(String[] args) {
BigDecimal result = MathEvalUtil.eval("500*(1-0.2)*0.2-2000").setScale(2,BigDecimal.ROUND_HALF_UP);
System.out.println();
System.out.println(result);
}
}