字符串四则运算

解析字符串形式的表达式，求解四则运算

要求：

所有数字都是1-9的个位数

运算符包括+、-、*、/、（、和）

运算中间结果和最终结果为double类型

解题思路：

1、常规解法（利用栈）：中缀转后缀，再求解；

2、分治法（利用正则匹配）：

1）只有加减运算时，从左往右算即可

2）只有乘除运算时，从左往右算即可

3）既有乘除也有加减时，按照“+”和“-”拆分，把乘除运算表达式看做一个整体（当做一个操作数，通过情形 2）算出）

4）有括号时，先求解括号里面的表达式（按照情形 3）求解）；

5）有括号嵌套时，从里向外循环求解（每一层都是情形 4））；

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

public class Arithmetic {

/**
* 分治法
**/
private final String plusMinusRegex = "[\\+\\-]";

// 9-(1+2*3)*4-(4+1)
public double calcute(final String expression) throws Exception {
StringBuilder expressionBuilder = new StringBuilder(expression);
Pattern pattern = Pattern.compile("\\([\\d\\+\\-\\*/\\.]+\\)");
Matcher matcher = pattern.matcher(expression);

while(matcher.find()) {
int start = matcher.start();
int end = matcher.end();
double r = calWithoutBracket(expressionBuilder.toString().substring(start+1,end-1));
expressionBuilder.replace(start, end, String.valueOf(r));
matcher = pattern.matcher(expressionBuilder.toString());
}

return calWithoutBracket(expressionBuilder.toString());
}

// 4+2*3-5*2
public double calWithoutBracket(final String expression) throws Exception {

double result = 0;

String[] numberStrings = expression.split(plusMinusRegex);

if(numberStrings[0].contains("*") || numberStrings[0].contains("/")) {
result = multiplyAndDivide(numberStrings[0]);
} else {
result = Double.valueOf(numberStrings[0]);
}

int index = 1;
Pattern pattern = Pattern.compile(plusMinusRegex);
Matcher matcher = pattern.matcher(expression);
while(matcher.find()) {
String next = numberStrings[index];
double nextNumber = (next.contains("*") || next.contains("/")) ? multiplyAndDivide(next) : Double.valueOf(next);

String op = matcher.group();
if(op.equals("+")) {
result += nextNumber;
} else if(op.equals("-")) {
result -= nextNumber;
}
index++;
}
return result;
}

// 3.5/2.3*4.1
public double multiplyAndDivide(String expression) {
double result = 1;
String pString = "[\\*\\/]";

String[] numberStrings = expression.split(pString);
if (numberStrings.length > 0) {
result = Double.valueOf(numberStrings[0]);
}

int index = 1;
Pattern pattern = Pattern.compile(pString);
Matcher matcher = pattern.matcher(expression);

while (matcher.find()) {
String op = matcher.group();
if (op.equals("*")) {
result *= Double.valueOf(numberStrings[index]);
} else if (op.equals("/")) {
result /= Double.valueOf(numberStrings[index]);
}
index++;
}
return result;
}

// 1.5-2.8+3
public double plusAndMinus(String expression) {

double result = 0;
String pString = "[\\+\\-]";

String[] numberStrings = expression.split(pString);
if (numberStrings.length > 0) {
result = Double.valueOf(numberStrings[0]);
}

int index = 1;
Pattern pattern = Pattern.compile(pString);
Matcher matcher = pattern.matcher(expression);

while (matcher.find()) {

String op = matcher.group();
if (op.equals("+")) {
result += Double.valueOf(numberStrings[index]);
} else if (op.equals("-")) {
result -= Double.valueOf(numberStrings[index]);
}
index++;
}
return result;
}

public boolean isNumber(char ch) {
return '0' <= ch && '9' >= ch;
}

public int charNumToInt(char num) {
if (num < '0' || num > '9')
throw new IllegalArgumentException(
"argument is not a char of decimal number");
return num - '0';
}
/**
* 中缀转后缀法
**/
public double calcute2(final String expression) {

final String suffixExpression = getSuffixExpression(expression);

Stack<String> stack = new Stack<String>();
for(int i=0; i<suffixExpression.length(); i++) {
char ch = suffixExpression.charAt(i);
if(isNumber(ch)) {
stack.push(String.valueOf(ch));
} else {
double rightOperand = Double.valueOf(stack.pop());
double leftOperand = Double.valueOf(stack.pop());
if(ch == '+') {
stack.push(String.valueOf(leftOperand + rightOperand));
} else if(ch == '-') {
stack.push(String.valueOf(leftOperand - rightOperand));
} else if(ch == '*') {
stack.push(String.valueOf(leftOperand * rightOperand));
} else if(ch == '/') {
stack.push(String.valueOf(leftOperand / rightOperand));
}
}
}
return Double.valueOf(stack.pop());
}

public String getSuffixExpression(final String expression) {
StringBuilder suffixExpression = new StringBuilder();
Stack<Character> operatorStack = new Stack<Character>();
for(int i = 0;i < expression.length(); i++) {
char ch = expression.charAt(i);
if(isNumber(ch)) {
suffixExpression.append(ch);

} else if(ch == '(') {
operatorStack.push(ch);

} else if(ch == ')') {
char topOp;
while((topOp = operatorStack.pop()) != '(') {
suffixExpression.append(topOp);
}
} else {
if(!operatorStack.empty()) {
char topOp = operatorStack.peek();
while(getPriority(topOp) >= getPriority(ch)) {
suffixExpression.append(operatorStack.pop());
if(operatorStack.empty()) {
break;
}
topOp = operatorStack.peek();
}
}
operatorStack.push(ch);
}
}
while(!operatorStack.empty()) {
suffixExpression.append(operatorStack.pop());
}

return suffixExpression.toString();
}

public int getPriority(char operator) {
switch (operator) {
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
default:
return -1;
}
}
}

测试代码：

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;

public class ArithmeticTest {
private Arithmetic arithmetic;

@Before
public void setUp() throws Exception {
arithmetic = new Arithmetic();
}
@Test
public void testIsNumber() throws Exception {
assertTrue(arithmetic.isNumber('0'));
assertTrue(arithmetic.isNumber('9'));
assertTrue(arithmetic.isNumber('2'));
assertFalse(arithmetic.isNumber('+'));
}

@Test
public void testCharNumToInt() throws IllegalArgumentException{
assertTrue(arithmetic.charNumToInt('2') == 2);
try {
arithmetic.charNumToInt('+');
assertTrue(false);
} catch (IllegalArgumentException e) {
assertTrue(true);
}
}

@Test
public void testPlusAndMinus() throws Exception {
assertTrue(arithmetic.plusAndMinus("8.5-3.2+2") == 7.3);
}

@Test
public void testMultiplyAndDivide() throws Exception {
assertTrue(arithmetic.multiplyAndDivide("4.0/2*4.1") == 8.2);
}

@Test
public void testCalWithoutBracket() throws Exception {
assertTrue(arithmetic.calWithoutBracket("4") == 4.0);
}
@Test
public void testCalcute() throws Exception {
assertTrue(arithmetic.calcute("(((5+2)*2)-(5+3))/2") == 3.0);

}

@Test
public void testGetSuffixExpression() throws Exception {
assertEquals(arithmetic.getSuffixExpression("9+7*4-(4+1)"),"974*+41+-");
}

@Test
public void testCalcute2() throws Exception {
assertTrue(arithmetic.calcute2("(2*(4+1))") == 10.0);
}
}