通过右运算表达试来计算结果

可以使用双Stack来实现以下的功能(一个存数字，一个算运算符)，但是用单stack比较简单，上课听老师说电脑的运算也只是用一个Stack来实现算法的,然后自己就做了一下：

所谓的右运算表达式如：30-5*(3/7-20) =  30 5 3 7 / 20 - * - 

package three;

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

public class CalcStack {

	public static void main(String[] args) {
		String content = "30-5*(3/7-20)";
		String content1 = "1 + 5 * 6 + 3 * (2 + 3*2+2-1+3*3) + 10/5 - 6*1";
		String content2 = "3 * ( 2+ 3*2+2-1+3*3)";
		
		System.out.println(calc(postfixExpression(content)));
		System.out.println(calc(postfixExpression(content1)));
		System.out.println(calc(postfixExpression(content2)));
	}

	public static String postfixExpression(String content) {


		// 用于存储操作符的栈
		Stack<String> stack = new Stack<String>();
		// 将传入的表达式通过+-*/()分割,后面的true参数是保留分割符
		StringTokenizer s = new StringTokenizer(content.replace(" ", ""), "+-*/()", true);
		String result = "";


		while (s.hasMoreElements()) {
			char[] current = (s.nextToken()).toCharArray();
			String next = "";


			switch (current[0]) {
			case '+':
				if (!stack.isEmpty())
					// 如果上一个操作符是+或-号，则上一操作符出栈并记录于result中
					if (!stack.isEmpty()
							&& (stack.peek().equals("+") || stack.peek()
									.equals("-"))) {
						result += " " + stack.pop();
					}
				// 当前操作符入栈
				stack.push(String.valueOf(current));
				break;
			case '-':
				if (!stack.isEmpty())
					// 如果上一个操作符是+或-号，则上一操作符出栈并记录于result中
					if (stack.peek().equals("+") || stack.peek().equals("-")) {
						result += " " + stack.pop();
					}
				// 当前操作符入栈
				stack.push(String.valueOf(current));
				break;
			case '*':
				next = s.nextToken(); // 取下一个待处理的串
				// 如果下一个操作符不是左括号，则执行以下操作
				if (!next.equals("(")) {
					result += " " + next + " *";
				} else { // 否则当前操作符*和(入栈
					stack.push(String.valueOf(current));
					stack.push(next);
				}
				break;
			case '/':
				next = s.nextToken(); // 取下一个待处理的串
				// 如果下一个操作符不是左括号，则执行以下操作
				if (!next.equals("(")) {
					result += " " + next + " /";
				} else {// 否则当前操作符/和(入栈
					stack.push(String.valueOf(current));
					stack.push(next);
				}
				break;
			case '(':
				// 否则当前)入栈
				stack.push(String.valueOf(current));
				break;
			case ')':
				if(stack.size()>=2) {
					result += " " + stack.pop(); // 上一操作符出栈
					stack.pop(); // 左括号出栈
				}
				while (!stack.isEmpty()) {
					String t = stack.pop();
					if(t.equals("(")) {  //如果是内括号的左括号，则停止输出栈内的运算符
						stack.push(t);
						break;
					}
					result += " " + t;
				}
				break;
			default:
				// 当前的字符串是数字直接输出
				result += " " + String.valueOf(current);
				break;
			}
		}


		// 如果栈不为空,则输出剩下的操作符
		while (!stack.isEmpty()) {
			result += " " + stack.pop();
		}
		return result;
	}

	public static int calc(String s) {
		Stack<Integer> stack = new Stack<Integer>();
		String[] expression = s.split(" ");
		
		for (int i = 1; i < expression.length; i++) {
			if(isInt(expression[i])) {   //如果是整数的话，则入栈
				stack.push(Integer.parseInt(expression[i]));
			} else {   //如果是运算符，则从栈中取出两个数,然后在switch里执行，再把结果放入栈中
				char[] current = expression[i].toCharArray();
				int result = 0;
				int preview = 0;
				switch(current[0]) {
				case '+':
					preview = stack.pop();
				    result =  stack.pop() + preview;
					break;
				case '-':
					preview = stack.pop();
					result =  stack.pop() - preview;
					break;
				case '*':
					preview = stack.pop();
					result =  stack.pop() * preview;
					break;
				case '/':
					preview = stack.pop();
					result =  stack.pop() / preview;
					break;
				}
				stack.push(result);
			}
		}
		return stack.peek();   //剩下的一个栈顶元素则是结果
	}
	
	public static boolean isInt(String num) {
		try {
			Integer.parseInt(num);
			return true;
		} catch(Exception e) {
			return false;
		}
	}
}

结果：
130
73
54