问题：
给定字符串String str = "7*2-5*3-3+6/3"， 求出字符串里面表达式的结果？
像javascript有自带的eval()方法，可以直接计算。但java或其它语言，API并没有提供直接计算的方法(可能是我孤陋寡闻)，这时就需要我们自己写方法实现了。
栈：
要实现上述功能，需要用到堆栈的概念，
栈是一种特殊的串行形式的数据结构，它的特殊在于，只能在队列的一端进行输入和输出，因此按照"先入后出"的原理运行。就像一个盒子，先放进的东西在下面，后面放进的东西反而在上面。如上图，栈可以看成是一个"倒立的数组"。有一个top索引，永远指向最上面一个节点。当加入一个元素时，top往上移一位。取走一个元素时，top往下移一位。当栈为空时，top指向栈的下方，top=-1.
根据上面的结构，我们可以自定义一个栈，并实现入栈(push)和弹栈(pop)两个方法：
1.入栈：将数据放入堆栈的顶端，top索引+1.
2.弹栈：将栈顶数据输出，top索引-1.
/**
* 使用数组模拟栈
* @author SCOTT
*
*/
public class MyStack { private int top = -1; //指向栈顶的索引
private int maxSize = 100; //栈所能存储的最大个数
private Object[] array = new Object[maxSize]; //数组 /**
* 加入一个元素
* @param val
*/
public void push(Object val){
if(top == maxSize - 1){
System.out.println("栈满");
return;
}
array[++top] = val;
} /**
* 弹出一个元素
* @return
*/
public Object pop(){
if(top == -1){
System.out.println("栈空");
return null;
}
return array[top--];
} /**
* 遍历
*/
public void toList(){
for(int i=top;i>-1;i--){
System.out.println(i+"="+array[i]);
}
} /**
* 判断栈是否为空
* @return
*/
public boolean isEmpty(){
if(top == -1)
return true;
return false;
} /**
* 获取栈顶的元素，跟pop()方法的区别在于：pop()方法的top索引会减1，而getTop不会
*/
public Object getTop(){
if(top == -1)
return null;
return array[top];
}
}
对栈有了了解之后，就可以计算：String str = "7*2-5*3-3+6/3".
思路：
1.初始化两个栈，一个数栈(存放表达式中的数字)，一个符号栈(用来存储表达式中的符号).
2.遍历字符串str，将字符一个个取出进行判断，假定用ch存储取出的字符.
2.1.如果ch为数字，直接将数字放入数栈(这是一种抽象的说法，如果存在像700这种两位以上的数字，需要自己拼接，然后再一起入栈，只占一个位置).
2.2.如果ch为符号.
2.2.1.如果符号栈为空，就直接将符号放入符号栈.
2.2.2.如果符号栈不为空， 就判断当前符号(ch)的运算级别跟符号栈栈顶的符号(放在符号栈最上面的一个运算符)运算级别谁大谁小?
2.2.2.1 循环判断，如果当前符号(ch)的优先级<=符号栈栈顶运算符的优先级，则进行计算。计算方式：从数栈中弹出两个数，和符号栈弹出一个符号，进行计算并得到结果res，将res再放入数栈。直到当前运算符的优先级>符号栈栈顶运算符的优先级为止。
2.2.2.2 将当前符号(ch)加入符号栈.
3.到此，已经将字符串str遍历完毕。然后再将数栈和符号栈的数据取出进行计算。计算的方式：先从数栈取出两个数，再从符号栈弹出符号，计算并得到结果res，然后将res放入数栈。依次循环，直到符号栈为空为止。
4.计算完毕后，在数栈会存在一个唯一的值，这个值就是我们需要的结果。
具体实现：
/**
* 计算字符串表达式
* @author SCOTT
*
*/
public class StackApp { public static void main(String[] args) { String str = "7*2-5*3-3+6/3";
//str的索引，默认指向第一位
int index = 0;
//用于拼接连续数字
String tempStr = "";
//数栈
MyStack numStatck = new MyStack();
//符号栈
MyStack operStatck = new MyStack(); while(true){
char ch = str.charAt(index);
if(isNum(ch)){
//先进行拼接，满足条件，在放入数栈
tempStr += ch;
//如果到了字符串末尾，或者下一位是符号，则放入数栈
if(index == str.length() - 1 || !isNum(str.charAt(index+1))){
numStatck.push(tempStr);
}
}else{
tempStr = "";
if(operStatck.isEmpty()){
//如果符号栈为空，则直接将运算符放入符号栈
operStatck.push(ch);
}else{
//循环判断：如果当前运算符的级别<=栈顶运算符的级别，则计算
while(!operStatck.isEmpty() && getLevel(ch+"") <= getLevel(operStatck.getTop().toString())){
int res = calculate(numStatck, operStatck);
//将res入数栈
numStatck.push(res);
}
//将符号放入符号栈
operStatck.push(ch);
}
} index++;
//判断条件，break
if(index == str.length())
break;
} //遍历完成后，进行计算
while(!operStatck.isEmpty()){
int res = calculate(numStatck, operStatck);
//将运算结果放入数栈
numStatck.push(res);
} //最后在数栈肯定会存在唯一的结果
System.out.println(numStatck.pop());//-2 } /**
* 判断截取位，是否是数字
* @param ch
* @return
*/
public static boolean isNum(char ch){
if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
return false;
return true;
} /**
* *和/级别为1，+和-级别为0
* @return
*/
public static int getLevel(String oper){
if("*".equals(oper) || "/".equals(oper))
return 1;
return 0;
} /**
* 计算结果：//从数栈中取出两位，从符号栈中取出一位
* @param numStatck
* @param operStatck
* @return
*/
public static int calculate(MyStack numStatck, MyStack operStatck){
int num1 = 0;
if(numStatck.getTop() != null)
num1 = Integer.parseInt(numStatck.pop().toString());
int num2 = 0;
if(numStatck.getTop() != null){
num2 = Integer.parseInt(numStatck.pop().toString());
}
String str = "";
if(operStatck.getTop() != null){
str = operStatck.pop().toString();
} int res = 0;
switch (str.charAt(0)) {
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;//注意顺序，栈是先入后出的结构
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;//注意顺序，栈是先入后出的结构
break;
default:
throw new RuntimeException("运算符不正确");
} return res;
}
}
上面的步骤，并没有实现带有()、[]、{}的复杂运算，还有待后续研究.
