使用栈来实现，可以处理运算优先级。
使用自然四则运算表达式即可，如：4+(3*(3-1)+2)/2。无需把表达式先转换为逆波兰等形式。
package com.joshua.cal;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
public class Calculator {
private final Stack numStack = new Stack();
private final Stack opStack = new Stack();
private char currentOperator;
private char opStackTop;
private int i;
private String expression;
@SuppressWarnings("rawtypes")
public void exec(String expression) {
try {
clean();
if (expression == null || expression.isEmpty()) {
throw new IllegalArgumentException("Blank Expression!");
}
this.expression = expression;
opStack.push(TERMINATE_TOKENS.START_END_MARK);
List tokens = TOKENIZER.exec(expression
+ TERMINATE_TOKENS.START_END_MARK);
for (; i < tokens.size(); i++) {
final Object token = tokens.get(i);
if (token instanceof Double) {
processOperand((double) token);
} else {
processOperator((char) token);
}
}
} catch (Throwable e) {
System.err.println(String.format(
"Incorret Expression: %s\nError: %s", expression,
e.getMessage()));
}
}
private void processOperand(final double operand) {
numStack.push(operand);
}
private void processOperator(final char currentOperator) {
this.currentOperator = currentOperator;
this.opStackTop = opStack.peek();
char calMode = CALCULATE_MODE.getRule(currentOperator, opStackTop);
switch (calMode) {
case '>':
processStackHigerPriorityOperator();
break;
case '
processStackLowerPriorityOperator();
break;
case '=':
processStackEqualPriorityOperator();
break;
default:
break;
}
}
private void processStackLowerPriorityOperator() {
opStack.push(currentOperator);
}
private void processStackHigerPriorityOperator() {
numStack.push(CALCULATE.exec(opStack.pop(), numStack.pop(),
numStack.pop()));
--i; // pointer back to the previous operator.
}
private void processStackEqualPriorityOperator() {
if (TERMINATE_TOKENS.START_END_MARK == currentOperator) {
System.out.println(expression + " = " + numStack.peek());
} else if (')' == currentOperator) {
opStack.pop();
}
}
public void clean() {
numStack.clear();
opStack.clear();
i = 0;
}
public static void main(String[] args) {
Calculator cal = new Calculator();
cal.exec("4+(3*(3-1)+2)/2"); // = 8
cal.exec("4 + (-3 * ( 3 - 1 ) + 2)"); // = 0
cal.exec("4 +-/ (-3 * ( 3 - 1 ) + 2)"); // incorrect expression!
cal.exec("4.5+(3.2+3)/2"); // = 7.6
cal.exec("4.5+(3.2:3)/2"); // incorrect expression!
cal.exec("-4.5+(3.2-3)/2"); // = -4.4
}
}
enum CALCULATE {
INSTANCE;
public static double exec(final char operator, final double right,
final double left) {
switch (operator) {
case '+':
return left + right;
case '-':
return left - right;
case '*':
return left * right;
case '/':
return left / right;
default:
throw new IllegalArgumentException("Unsupported operator: "
+ operator);
}
}
}
enum TERMINATE_TOKENS {
INSTANCE;
public static final char START_END_MARK = '#';
private static final Map TOKENs = new HashMap();
static {
// token, token id
TOKENs.put('+', 0);
TOKENs.put('-', 1);
TOKENs.put('*', 2);
TOKENs.put('/', 3);
TOKENs.put('(', 4);
TOKENs.put(')', 5);
TOKENs.put(START_END_MARK, 6);
}
private static Set NEGATIVE_NUM_SENSITIVE = new HashSet();
public static synchronized Set getNegativeNumSensitiveToken() {
if (NEGATIVE_NUM_SENSITIVE.size() == 0) {
NEGATIVE_NUM_SENSITIVE.addAll(TOKENs.keySet());
NEGATIVE_NUM_SENSITIVE.remove(')');
}
return NEGATIVE_NUM_SENSITIVE;
}
public static boolean isTerminateToken(final char token) {
Set keys = TOKENs.keySet();
return keys.contains(token);
}
public static int getTokenId(final char token) {
return TOKENs.get(token) == null ? -1 : TOKENs.get(token);
}
public static int getTokenSize() {
return TOKENs.size();
}
}
enum CALCULATE_MODE {
INSTANCE;
private static char[][] RULES = {
// + - * / ( ) #
{ '>', '>', '', '>' }, // +
{ '>', '>', '', '>' }, // -
{ '>', '>', '>', '>', '', '>' }, // *
{ '>', '>', '>', '>', '', '>' }, // /
{ '
{ '>', '>', '>', '>', 'o', '>', '>' }, // )
{ '
};
static {
if (RULES.length != TERMINATE_TOKENS.getTokenSize() || RULES.length < 1
|| RULES[0].length != TERMINATE_TOKENS.getTokenSize()) {
throw new IllegalArgumentException("Rules matrix is incorrect!");
}
}
public static char getRule(final char currentOperator, final char opStackTop) {
try {
return RULES[TERMINATE_TOKENS.getTokenId(opStackTop)][TERMINATE_TOKENS
.getTokenId(currentOperator)];
} catch (Throwable e) {
throw new RuntimeException("No rules were defined for some token!");
}
}
}
enum TOKENIZER {
INSTANCE;
private static final StringBuilder BUFFER = new StringBuilder();
private static String clearExpression(String expression) {
return expression.replaceAll(" ", "");
}
private static Character PREVIOUS_CHAR;
private static void clean() {
BUFFER.delete(0, BUFFER.length());
PREVIOUS_CHAR = null;
}
private static boolean processNegativeNumbers(final String exp,
final int index) {
char c = exp.charAt(index);
if (('+' == c || '-' == c)
&& (PREVIOUS_CHAR == null || TERMINATE_TOKENS
.getNegativeNumSensitiveToken().contains(PREVIOUS_CHAR))
&& !TERMINATE_TOKENS.isTerminateToken(exp.charAt(index + 1))) {
BUFFER.append(c);
return true;
}
return false;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public static List> exec(final String expression) {
clean();
String exp = clearExpression(expression);
List result = new LinkedList();
for (int i = 0; i < exp.length(); i++) {
char c = exp.charAt(i);
if (TERMINATE_TOKENS.isTerminateToken(c)) {
if (processNegativeNumbers(exp, i))
continue;
if (BUFFER.length() > 0) {
result.add(Double.valueOf(BUFFER.toString()));
BUFFER.delete(0, BUFFER.length());
}
result.add(c);
} else {
BUFFER.append(c);
}
PREVIOUS_CHAR = c;
}
return Collections.unmodifiableList(result);
}
}
