中缀表达式 --> 后缀表达式,转换过程中同时计算
操作符堆栈(OperatorHeap):
import java.util.Arrays;

public class OperatorHeap

...{
private char[] data;
private int size;
public OperatorHeap()

...{
this(10);
}
public OperatorHeap(int size)

...{
data = new char[size];
initHeap();
}
public void initHeap()

...{
data[size++] = '#';
}
//栈顶
public char top()

...{
return data[size-1];
}
//入栈
public void push(char c)

...{
ensureCapacity(size + 1);
data[size++] = c;
}
//出栈
public char pop()

...{
return data[--size];
}
//扩展容量
public void ensureCapacity(int minSize)

...{
int oldCapacity = data.length;

if (minSize > oldCapacity) ...{
int newCapacity = (oldCapacity * 3 / 2 + 1) > minSize ?
oldCapacity * 3 / 2 + 1 : minSize;
data = (char[]) Arrays.copyOf(data, newCapacity);
}
}
}
操作数堆栈(NumHeap):
import java.util.Arrays;

public class NumHeap

...{
private double[] data;
private int size;
public NumHeap()

...{
this(10);
}
public NumHeap(int size)

...{
data = new double[size];
}
//栈顶
public double top()

...{
return data[size-1];
}
//入栈
public void push(double c)

...{
ensureCapacity(size + 1);
data[size++] = c;
}
//出栈
public double pop()

...{
return data[--size];
}
//扩展容量
public void ensureCapacity(int minSize)

...{
int oldCapacity = data.length;

if (minSize > oldCapacity) ...{
int newCapacity = (oldCapacity * 3 / 2 + 1) > minSize ?
oldCapacity * 3 / 2 + 1 : minSize;
data = (double[]) Arrays.copyOf(data, newCapacity);
}
}
}
Eval类,提供了一个静态的eval方法,用于计算表达式值:

/** *//**
* 计算表达式的值,如 3+(2+9*7)/5
* @author Liw
* @time 2007-6
*/

public class Eval

...{
public static double eval(String str)

...{
str = str + "#"; //设置"#"优先级最低,保证opHeap里的运算符能够全部退栈
String[] words = str.split("(?<!^-?|[+/*()-]-)((?<=[+/*()-])|(?=[+/*()-]))"); //分割表达式
OperatorHeap opHeap = new OperatorHeap(); //操作符堆栈
NumHeap numHeap = new NumHeap(); //操作数堆栈

for (int i = 0; i < words.length; i++) ...{

if (words[i].matches("-?//d+|-?//d+//.//d+")) ...{ //操作数
numHeap.push(Double.parseDouble(words[i])); //操作数入栈
}

else ...{ //操作符
char op_top = opHeap.top(), op_cur = words[i].toCharArray()[0]; //栈顶操作符&当前读取的操作符

while (compare(op_top, op_cur)) ...{ //若当前操作符op_cur优先级低于栈顶,退栈,直到op_cur优先级大于栈顶

if ((op_top == '(' && op_cur == ')') || (op_top == '#' && op_cur == '#')) ...{
opHeap.pop(); //弹出"(" or "#"
break;
}

else ...{ //弹出一运算符
double a = numHeap.pop(), b = numHeap.pop(); //弹出两个数字用于计算
numHeap.push(eval2(b, a, opHeap.pop())); //弹出一运算符,计算两个数的值,结果入栈
op_top = opHeap.top(); //新的栈顶
}
}

if (op_cur != ')') ...{
opHeap.push(op_cur); //操作符op_cur入栈
}
}
}
return numHeap.top();
}
private static double eval2(double a, double b, char op)

...{
switch (op)

...{
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
return a / b;
default:
return -1;
}
}
//返回两个运算符之间的优先级,若op1>op2,返回true
private static boolean compare(char op1, char op2)

...{
return !(op1 == '(' && op2 == '(') //连续两括号 <-- false
&& (getOpLevel(op1) == getOpLevel(op2)) //相同运算符 <-- true
|| !(op1 == '(' || op2 == '(' || op1 == '#') //括号 <-- false
&& getOpLevel(op1) > getOpLevel(op2); //普通优先级比较
}
//忽略括号时的优先级
private static int getOpLevel(char op)

...{
switch(op)

...{
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '(':
case ')':
return 0;
default:
return -1; //"#"
}
}
}
如下使用:
public class Test

...{
public static void main(String[] args)

...{
System.out.println(Eval.eval("3+(2+9*7)/5"));
}
}