說明

• 本程序只實(shí)現(xiàn)了基本的四則運(yùn)算，即加減乘除，不能有括號(hào)
• 本程序使用了基本的數(shù)據(jù)結(jié)構(gòu)之一——棧

源代碼

Calculator 這個(gè)類是主類，其中用到的ArrayStack 是自定義的類，源代碼在后面

public class Calculator {

    public static void main(String[] args) {
        
        // 表達(dá)式字符串，需要替換成你用的
        String exp = "700-400+20*60-40/2*2";
        // 數(shù)棧和符號(hào)棧
        ArrayStack numStack = new ArrayStack(20);
        ArrayStack operStack = new ArrayStack(20);
        
        int index = 0;
        // 運(yùn)算數(shù)和運(yùn)算符
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        // 中間結(jié)果
        int result = 0;
        char ch = ' ';
        // 多位數(shù)字字符串
        String num="";
        
        // 遍歷表達(dá)式
        while(index < exp.length()) {
            // 截取字符
            ch = exp.substring(index, index+1).charAt(0);
            // 判斷該字符是數(shù)字還是運(yùn)算符
            if(operStack.isOper(ch)) {
                // 判斷符號(hào)棧是否為空
                if(!operStack.isEmpty()) {
                    // 如果當(dāng)前運(yùn)算符的優(yōu)先級(jí) <= 棧頂運(yùn)算符的優(yōu)先級(jí)
                    if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        // 取出數(shù)棧最上面的兩個(gè)數(shù)
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        // 取出符號(hào)棧的棧頂運(yùn)算符
                        oper = operStack.pop();
                        // 進(jìn)行運(yùn)算
                        result = numStack.cal(num1, num2, oper);
                        // 運(yùn)算結(jié)果入數(shù)棧
                        numStack.push(result);
                        // 當(dāng)前運(yùn)算符入符號(hào)棧
                        operStack.push(ch);
                        
                    }else {
                        // 如果當(dāng)前運(yùn)算符的優(yōu)先級(jí) > 棧頂運(yùn)算符，直接入棧
                        operStack.push(ch);
                    }
                }else {
                    // 如果當(dāng)前符號(hào)棧為空，直接入棧
                    operStack.push(ch);
                }
            }else {
                // 如果是數(shù)字，不能直接入棧，因?yàn)樗赡懿恢挂晃?                // 拼接字符
                num += ch;
                
                // 如果是最后一位數(shù)字，就沒必要判斷了，直接入棧好了
                if(index == exp.length()-1) {
                    numStack.push(Integer.parseInt(num));
                }else {
                    // 判斷當(dāng)前位置的下一位是不是數(shù)字，如果是運(yùn)算符，就可以入棧了；否則繼續(xù)循環(huán)
                    if( operStack.isOper(exp.substring(index+1,index+2).charAt(0) ) ){
                        numStack.push(Integer.parseInt(num));
                        // 然后把字符串清空
                        num = "";
                    }
                }
                
            }
            
            index++;
        }   // 表達(dá)式遍歷結(jié)束
        
        // 順序從數(shù)棧和符號(hào)棧取出 運(yùn)算數(shù)和運(yùn)算符進(jìn)行運(yùn)算，最終符號(hào)棧為空，數(shù)棧中只剩下最終結(jié)果
        while(true) {
            if(operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            result = numStack.cal(num1, num2, oper);
            numStack.push(result);
        }
        
        // 輸出最終結(jié)果
        System.out.printf("%s = %d\n", exp, numStack.pop());
    }   // 主方法結(jié)束

}   // 類結(jié)束

這是ArrayStack 類的源代碼

public class ArrayStack{
    // 棧的大小 
    private int maxSize;
    // 利用數(shù)組模擬棧
    private int[] stack;
    // 棧頂指針 
    private int top = -1;
    
    // 構(gòu)造函數(shù)
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    // 判斷棧滿
    public boolean isFull() {
        return top == this.maxSize-1;
    }
    // 判斷?？?    public boolean isEmpty() {
        return top == -1;
    }
    // 入棧dea
    public void push(int ele) {
        if(isFull()) {
            return;
        }
        top++;
        stack[top] = ele;
    }
    // 出棧
    public int pop() {
        if(isEmpty()) {
            throw new RuntimeException("棧為空！");
        }
        int value = stack[top];
        top--;
        return value;
    }
    // 查看棧頂元素 
    public int peek() {
        if(isEmpty()) {
            throw new RuntimeException("棧為空！");
        }
        return stack[top];      
    }
    // 遍歷棧
    public void list() {
        if(isEmpty()) {
            System.out.println("棧為空！");
            return;
        }
        for(int i=top; i>=0; i--) {
            System.out.printf("stack[%d]=%d\n", i,stack[i]);
        }
    }
    // 返回運(yùn)算符優(yōu)先級(jí)
    public int priority(int oper) {
        if(oper == '*' || oper == '/') {
            return 1;
        }else if(oper == '+' || oper == '-') {
            return 0;
        }else {
            // 表示非法字符
            return -1;
        }
    }
    // 判斷是否為運(yùn)算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }
    // 計(jì)算
    public int cal(int num1,int num2,int oper) {
        int result = 0;
        switch(oper) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num2 - num1;   // 注意出棧的順序與實(shí)際順序是反著的
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            result = num2 / num1;
            break;
        }
        
        return result;
    }
    
}

運(yùn)行結(jié)果

運(yùn)行結(jié)果