java用棧實現計算器完整版

棧類

class Stack {
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public Stack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    // 返回棧頂元素
    public int peek() {
        return stack[top];
    }

    public void show() {
        if (isEmpty()) {
            System.out.println("棧空的");
            return;
        }
        for (int i = top; i >= 0; --i) {
            System.out.println("stack[" + i + "] ==> " + stack[i]);
        }
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("棧滿了");
            return;
        }
        // 插入資料
        stack[++top] = value;
    }

    public Integer pop() {
        if (isEmpty()) {
            System.out.println("棧是空的");
            return null;
        }
        // pop
        return stack[top--];
    }

    public boolean isFull() {
        return (top == maxSize - 1);
    }

    public boolean isEmpty() {
        return (top == -1);
    }

    /**
     * 運算子優先順序判斷
     */
    public int priority(int opera) {
        int priority = -1;
        char[] operas = {'*', '/', '+', '-'};
        if (opera == operas[0] || opera == operas[1]) {
            priority = 1;
        } else if (opera == operas[2] || opera == operas[3]) {
            priority = 0;
        }
        return priority;
    }

    /**
     * 判斷是不是一個運算子
     */
    public boolean isOpera(char val) {
        return ((val == '+') || (val == '-') || (val == '*') || (val == '/'));
    }

    public int cal(int num1, int num2, int opera) {
        int result = 0;
        switch (opera) {
            case '*':
                result = num1 * num2;
                break;
            case '/':
                result = num2 / num1;
                break;
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num2 - num1;
                break;
            default:
                break;
        }
        return result;
    }
}
 

測試類

public class CalculatorDemo {
    public static void main(String[] args) {
        String expression = "700+20*6-4";
        // 建立兩個棧
        Stack numStack = new Stack(10);
        Stack operaStack = new Stack(10);

        int index = 0;
        int num1;
        int num2;
        int oper;
        int result;
        char ch;
        StringBuilder keepNum = new StringBuilder();
        // 掃描
        while (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            // 判斷掃描的是什麼
            // 如果是符號
            if (operaStack.isOpera(ch)) {
                // 判斷符號棧裡有沒有元素
                if (!operaStack.isEmpty()) {
                    // 處理
                    // 拿到棧頂和新元素的優先順序
                    int topPriority = operaStack.priority(operaStack.peek());
                    int chPriority = operaStack.priority(ch);
                    // 比較
                    if (chPriority < topPriority) {
                        // 如果優先順序小於棧頂
                        // 先計算棧頂也就是
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operaStack.pop();

                        result = operaStack.cal(num1, num2, oper);
                        // 運算後把結果入數棧
                        numStack.push(result);
                        operaStack.push(ch);
                        keepNum.delete(0, keepNum.length());

                    } else {
                        // 如果小於直接入棧
                        operaStack.push(ch);
                    }
                } else {
                    // 直接入棧
                    operaStack.push(ch);
                }
            } else {
                // 如果是數字,直接入數棧，但是考慮到編碼問題，char轉int會增加48
                // 此時考慮多位數
                keepNum.append(ch);
                // 如果ch是expression的最後一位
                if (expression.length() - 1 == index) {
                    // 此時直接入棧
                    numStack.push(Integer.parseInt(keepNum.toString()));
                } else {
                    // 判斷下一個字元是不是符號
                    if (operaStack.isOpera(expression.substring(index + 1, index + 2).charAt(0))) {
                        //  下一位是運算子時push
                        numStack.push(Integer.parseInt(keepNum.toString()));
                        // 清空keepNum
                        keepNum.delete(0, keepNum.length());
                    }
                }
            }
            // index右移並判斷結束
            if (++index >= expression.length()) {
                break;
            }
        }
        // 迴圈執行完畢，順序的從兩個棧中取對應的元素進行運算
        while (true) {
            if (operaStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operaStack.pop();

            result = operaStack.cal(num1, num2, oper);
            // 運算後把結果入數棧
            numStack.push(result);
        }
        // 結束
        System.out.println("表示式" + expression + "的結果是 ==> " + numStack.pop());
    }
}