求表达式的值

利用栈求表达式的值，用Java实现如下所示：

//栈的定义
public class ArrayStack {
    //栈的大小
    private int SIZE = 0;
    //一维数组
    int[] arrayStack;
    //栈顶指针
    private int top = -1;       //等于-1时表示栈中没有任何数据

    //初始化栈的大小
    public ArrayStack(int size) {
        this.SIZE = size;
        arrayStack = new int[size];
    }

    //默认构造方法
    public ArrayStack(){
        this.SIZE = 100;
        arrayStack = new int[this.SIZE];
    }

    //判断是否满栈
    public boolean isFullStack() {
        return this.top == SIZE - 1;
    }

    //判断栈是否为空
    public boolean isEmpty() {
        return this.top == -1;
    }

    //压栈操作
    public void addStack(int value) {
        if (isFullStack()) {
            throw new RuntimeException("此栈已满!");
        }
        //栈顶指针自增
        this.top++;
        arrayStack[top] = value;
    }

    //弹栈
    public int popStack() {
        //如果栈为空，则抛出异常
        if (isEmpty()) {
            throw new RuntimeException("栈为空!");
        }
        int value = arrayStack[top];
        this.top--;
        return value;
    }

    //获取栈顶的数据
    public int getTop(){
        return arrayStack[top];
    }

    //查看栈中的所有数据
    public void showStack() {
        //如果栈为空，则抛出异常
        if (isEmpty()) {
            throw new RuntimeException("栈为空!");
        }
        for (int i = 0; i < this.top; i++) {
            System.out.print(arrayStack[i] + "\t");
        }
    }

    //获取栈中的数据个数
    public int getNum() {
        return this.top + 1;
    }

    //获取栈容量大小
    public int getSize(){
        return this.SIZE;
    }

}

//Calculator类
public class Calculator {
    //构造方法
    public Calculator() {

    }

    //判断是否为运算符
    public boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }

    //判断优先级
    public int priority(char c) {
        if (c == '*' || c == '/') {
            return 1;
        } else if (c == '+' || c == '-') {
            return 2;
        }
        return -1;      //如果是其它情况就返回-1
    }

    //计算结果的方法
    public int result(int num1, int num2, char operator) {
        switch (operator) {
            case '+':
                return num1 + num2;
            case '-':
                return num2 - num1;     //这里需要注意，我们在出栈的时候的数据是逆序了的，所以我们在进行减或者除的操作的时候需要把顺序换回来
            case '*':
                return num1 * num2;
            case '/':
                return num2 / num1;
            default:
                throw new RuntimeException("运算符有误!");      //如果传入的符号有误，直接抛出一个异常
        }
    }
    
}


/**
 * 用栈实现表达式的计算
 * */

import java.util.Scanner;

/**
 * 实现思路：
 *      如果符号栈为空，则符号直接入栈，如果即将压栈的符号的优先级小于等于栈顶元素的优先级，则：
 *      符号栈先出栈，然后数字栈出栈进行运算，并且将运算结果压入数字栈，然后再进行判断，知道即将压入的符号优先级大于栈顶元素，则入栈
 * */

public class Test3 {
    public static void main(String[] args) {
        //创建符号栈和数字栈
        ArrayStack numStack = new ArrayStack(10);           //数字栈
        ArrayStack symbleStack = new ArrayStack(10);        //符号栈

        //创建Calculator的对象
        Calculator calculator = new Calculator();

        //让用户输入表达式
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入运算表达式:");
        String expression = sc.next();
        sc.close();

        //遍历字符串
        int lenth = expression.length();
        String value = "";
        for (int i = 0; i < lenth; i++) {
            final char c = expression.charAt(i);
            //判断是否为运算符
            if(calculator.isOperator(c)){
                //判断符号栈是否为空
                if(symbleStack.isEmpty()){
                    //符号直接入栈
                    symbleStack.addStack(c);
                }else {     //否则就需要对优先级进行判断
                    //如果即将入栈的符号优先级小于等于栈顶元素，则符号出栈，并且取出数字栈的两个栈顶元素，并且计算后将计算结果压入数字栈中
                    if(calculator.priority(c) >= calculator.priority((char)symbleStack.getTop())){
                        //获取符号栈的栈顶元素
                        final char sym = (char)symbleStack.popStack();
                        //取出数字栈中的两个元素
                        final int num1 = numStack.popStack();
                        final int num2 = numStack.popStack();
                        //然后计算结果
                        final int result = calculator.result(num1, num2, sym);
                        //将结果压入数字栈中
                        numStack.addStack(result);
                        //i--，用于让当前运算符再次和栈顶元素进行优先级的判断
                        i--;
                    }else {   //否则就直接压入符号栈
                        symbleStack.addStack(c);
                    }

                }
            }else {     //是数字的情况
                value += c;             //让字符串进行拼接
                if(i == lenth - 1){     //如果长度等于lenth-1，则说明已经遍历完毕，需要压栈
                    numStack.addStack(Integer.parseInt(value));
                }else {
                    //获取当前字符后面的那个字符，判断是否为运算符
                    final char data = expression.substring(i + 1, i + 2).charAt(0);
                    //判断是否为运算符，如果为运算符，则将数字压入栈
                    if(calculator.isOperator(data)){
                        numStack.addStack(Integer.parseInt(value));
                        //将value置空
                        value = "";
                    }
                }
            }
        }

        //数字栈和符号栈入完之后，我们需要对栈中的数据进行计算
        while (true){
            if(symbleStack.isEmpty()){
                break;
            }else{
                final char sym = (char)symbleStack.popStack();
                final int num1 = numStack.popStack();
                final int num2 = numStack.popStack();
                //然后计算结果
                final int result = calculator.result(num1, num2, sym);
                //将结果压入数字栈中
                numStack.addStack(result);
            }
        }
        //最后的结果
        int res = numStack.popStack();
        System.out.println("该表达式的结果为:" + res);

    }
}

注意：上面的运算只考虑了计算加减乘除，并没有考虑有小括号的情况！！！！