简单的表达式计算

import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;

public class count {
public static void main(String[] args) {
System.out.println("输入表达式");

Scanner in = new Scanner(System.in);

//输入的表达式
String expression = in.nextLine();

if(expression.length() < 1){
System.out.println("^-^");
}

else {

try{
System.out.println(solve(expression));
}
catch(Exception e){
System.out.println("对于你的表达式我无能为力:(");
}
}
}

/**
* 分解表达式，求解
* 情况：1.为空格 不管
*     2.+或- 判断前面有没有其他等待计算操作/+-*都可以
*     3.*或/ 判断前面有没有*或/的操作
*     4.括号 遇到反括号再去找前面的括号
*     5.操作数字 直接存了
*
* @param expression 表达式
* @return 计算结果
*/
private static int solve(String expression) {
//存数字的栈，操作数
Stack<Integer> operand = new Stack<Integer>();

//存操作符的栈
Stack<Character> operator = new Stack<Character>();

//分解表达式，把数字和操作符分开
//第一个参数：需要操作的字符串
//第二个参数：以什么为标准分割
//第三个参数：要不要保存作为分割标准的元素，在分割后结果里仍然保存
StringTokenizer tokens = new StringTokenizer(expression, "()+-*/", true);

while (tokens.hasMoreElements()) {
//.trim()方法是为了去除字符串前后的空格，因为不能以空格为分割标准然后保存空格
String thisToken = tokens.nextToken().trim();

//空格
if(thisToken.length() == 0){
//System.out.println("空格");
continue;
}

//是+或—（优先级要比*或/要低）
else if(thisToken.charAt(0) == '+' || thisToken.charAt(0) == '-'){
//System.out.println("是操作符  ： "+thisToken.charAt(0));

//看它之前有没有等待着的操作
while (!operator.isEmpty()){
if(operator.peek() == '+' ||operator.peek() == '-' ||
operator.peek() == '*' ||operator.peek() == '/' ) {
//计算
calculate(operand,operator);
//System.out.println(operand.peek() + "  这次计算结果");
}
else{
break;
}
}

//把这次的操作符放栈里
//System.out.println("把这次的操作符放栈里  ： "+thisToken);
operator.push(thisToken.charAt(0));
}

//是*或/
else if(thisToken.charAt(0) == '*' || thisToken.charAt(0) == '/'){
//System.out.println("是操作符  ： "+thisToken.charAt(0));

while (!operator.isEmpty()){
if(operator.peek() == '*' || operator.peek() == '/' ) {
//计算
calculate(operand,operator);
//System.out.println(operand.peek() + "：  这次计算结果");
}
else {
break;
}
}

//把这次的操作符放栈里
//System.out.println("把这次的操作符放栈里  ： "+thisToken.charAt(0));
operator.push(thisToken.charAt(0));
}

else if (thisToken.trim().charAt(0) == '(') {
//System.out.println("是（");
operator.push('(');
}
//反括号来啦，我们去找另一半括号^-^
else if (thisToken.trim().charAt(0) == ')') {
//System.out.println("是)");
while (operator.peek() != '(') {
//计算
calculate(operand, operator);
//System.out.println(operand.peek() + " ：  这次计算结果");
}
//去除'（'
operator.pop();
}
//是操作数
else {
//System.out.println("是操作数  ： "+thisToken);
operand.push(new Integer(thisToken));
}
}

while(!operator.empty()){
calculate(operand, operator);
}

return operand.pop();
}

/**
* 去除操作符和操作数直接计算
* @param operand 存操作数的栈
* @param operator 存操作符的栈
*/
private static void calculate(Stack<Integer> operand,
Stack<Character> operator) {

char symbol = operator.pop();//去出并删除栈顶的操作符
int num1 = operand.pop();
int num2 = operand.pop();

//注：表达式中先被读取的数字后被读出
if(symbol == '+'){
operand.push(num2 + num1);
}
else if(symbol == '-'){
operand.push(num2 - num1);
}
else if(symbol == '*'){
operand.push(num2 * num1);
}
else if(symbol == '/'){
if(num1 != 0)
operand.push(num2 / num1);
else{
System.out.println("似乎要报错了……除数不能为0");
}
}
}

}