中綴表示式一般是先轉換為字尾表示式，然後再計算的，其實我們可以邊轉換邊計算。

/*Infix.java
使用兩個棧直接求解中綴表示式，一個棧儲存運算子S，一個棧儲存運算元D。
例子：
a+b*c
  D:a,b S:+
    D:a,b,c S:+,*
    D:a,bc  S:+ <-- 每次取一個運算子，彈兩個運算元
    D:a+bc  S:

a*b/c+d
  D: a,b S:*
   D: a*b S:/ <-- 清空優先順序大於等於除號的運算子
     D:a*b/c S:+
      D:a*b/c+d S:
a^b^c
  D:a,b S:^
    D:a,b,c S:^,^ <-- 清空棧優先順序大於等於冪號掃描優先順序的運算子
    D:a,b^c S:^
    D:a^b^c S:

a*(b+c)
  D:a  S:*(
    D:a,b S:*(+
	  D:a,b,c S:*(+)
      D:a,b+c S:* <-- 清空操作符直到(
      D:a*(b+c) S:

這幾種情形，通過賦予運算子適當的優先順序，可統一為：
  清空棧優先順序大於等於掃描優先順序的運算子 (R0)

這裡只是為了說明棧的應用，因此簡單假設運算元是一位數字，並且沒有空格，
如果擴充套件成BigDecimal應該不困難。
中綴表示式的計算規則，從左到右掃描一遍，在掃描過程中：
  R1 如果遇到數字，則壓入運算元棧D；
  R2 如果遇到操作符，則根據R0彈出S中的操作符；
  R3 每彈出一個操作符，就彈出D中兩個運算元，並把結果壓入D。

掃描結束時，可能S不為空，按規則R3。最終D中僅有的一個是結果，S 應該為空。

author: ludi 2014.04
*/
import java.util.Stack;
public class Infix
{
	public static int eval(int a, int b, char op)
	{
		  int ret = 0;
			switch(op){
				case '+': ret = a + b; break; 
				case '-': ret = a - b; break;
				case '*': ret = a * b; break;
				case '/': ret = a / b; break;
				case '%': ret = a % b; break;
				case '^': {
					ret = 1;
					while(b-- > 0){
						ret *= a;
					}			
				}break;
				default: System.out.println("error op " + op); break;
			}
		 return ret;
	  }

	public static int evaluate(String infix)
	{
		Stack<Integer> d = new Stack<Integer>();
		Stack<Symbol> s = new Stack<Symbol>();
		int i, a, b;
		char ch;
		Symbol op, op2;

		for(i = 0; i < infix.length(); ++i){
			ch = infix.charAt(i);
			if (Character.isDigit(ch)){
				d.push(ch - '0');
			}else {
				op = new Symbol(ch);
				while(!s.empty() && (s.peek().compareTo(op) >= 0)){
					op2 = s.pop();
					b = d.pop();
					a = d.pop();
					d.push(eval(a, b,op2.op));
				}
				if(ch == ')'){
					s.pop(); /*彈出'('*/
				}else s.push(op);
			}
		}

		while(!s.empty()){
			op2 = s.pop();
			b = d.pop();
			a = d.pop();
			d.push(eval(a, b, op2.op));
		}

		System.out.printf("%s = %d d.size %d s.size %d%n", infix, d.peek(), d.size(), s.size());
		return d.pop();
	}
	
	public static void main(String[] arg)
	{
		evaluate("1+2*3");
		evaluate("2*(3+4)");
		evaluate("2*3/2+1");
		evaluate("2^3^2");
		evaluate("(2^3)^2");
		evaluate("(2^3)^2+2^3^2+2*3/2+1+2*(3+4)");
		evaluate("2^(2*(3+4))");
	}
}

 class Symbol implements Comparable<Symbol>
{
      char op; 
      int inputPrec; /*正在被掃描的操作符的優先順序*/
      int stackPrec; /*棧優先順序：值越小停留在棧中時間越長*/ 

      public Symbol (char ch){
         op = ch; 
         switch(op){
            case '+':
            case '-':inputPrec = stackPrec = 1;
                break;

            case '*':
            case '%':
            case '/':   inputPrec = 2;
                     	stackPrec = 2;
                     	break;

            case '^':
					inputPrec = 4;
                    stackPrec = 3; /*右結合的操作符掃描大於棧優先順序*/
                    break;

            case '(':   
					inputPrec = 5; 
                    stackPrec = -1; /*最高的掃描優先順序，最低的棧優先順序*/
                    break;

            case ')':   
					inputPrec = 0;
                    stackPrec = 0;
                    break;
         }
      }

      public int compareTo(Symbol item)
      {
         int result;
         if (stackPrec < item.inputPrec)
            result = -1;
         else if (stackPrec == item.inputPrec)
            result = 0;
         else
            result = 1;

         return result;
      }

      public char getOp()
      { return op; }
}

/*
 
[email protected] ~/java
$ javac -encoding UTF-8 Infix.java  && java Infix
1+2*3 = 7 d.size 1 s.size 0
2*(3+4) = 14 d.size 1 s.size 0
2*3/2+1 = 4 d.size 1 s.size 0
2^3^2 = 512 d.size 1 s.size 0
(2^3)^2 = 64 d.size 1 s.size 0
(2^3)^2+2^3^2+2*3/2+1+2*(3+4) = 594 d.size 1 s.size 0
2^(2*(3+4)) = 16384 d.size 1 s.size 0

 
[email protected] ~/java
*/

這裡面為了簡明起見，沒有做錯誤處理。

很好奇編譯器是怎麼計算常量表達式的，不知道是不是這樣子呢。

附：

一些與棧有關的有意思的話題：