计算器GUI程序

╰+哭是因爲堅強的太久メ 2024-04-23 20:05 82阅读 0赞

#### 模拟计算器 ####

1.  问题描述  
    设计一个模拟计算器的程序，要求能对包含加、减、乘、除、求余、括号运算符及SQR和ABS函数的任意整型表达式进行求解。
2.  设计要求  
    （1）要检查相关运算的限制条件，并对错误的条件产生报警。  
    （2）有用户图形界面。

数据结构课程设计，我选用的是Java语言来实现一个GUI计算器程序，图形界面使用Java Swing进行开发，实现了基本运算，以及绝对值、开方、平方，支持浮点数以及大数运算。 涉及到的知识点有将中缀表达式转换为后缀表达式并进行计算，同时能够检查表达式是否合法。

##### 设计思路： #####

![在这里插入图片描述][0c8c949d99ec435b9f4f4300493630bc.png]

##### 用户交互界面 #####

![在这里插入图片描述][cc70a506ec7a43df83b5cf3e3b94c98f.png]

**表达式的合法判定**

import java.util.Stack;
    
    public class CheckExpression {
        
        // 判断是否是合法算术表达式
        public boolean isTrueExpression(String expression) {
        
            // 如果一开始就是点(.)肯定就不是合法的表达式  合法的算术表达式含有数字、小数点、括号、普通运算符
            if ("".equals(expression) || isOperator(expression.charAt(0)) || isOperator(expression.charAt(expression.length() - 1)) || isPoint(expression.charAt(0)) || isPoint(expression.charAt(expression.length() - 1))) {
        
                return false;
            } else {
        
                
                // 控制括号成对
                Stack<Character> stack = new Stack<>();
                
                // 循环判断表达式的每一个字符是符合法
                int i = 0;
                int leftCount = 0;// 记录 ( 的数量
                int rightCount = 0;// 记录 ) 的数量
                
                while (i < expression.length()) {
        
                    char ch = expression.charAt(i);
                    // 如果此字符不是数字、普通运算符、特殊运算符、小数点、括号、空格(习惯分开 比如：2 + 4) 那么就是不合法
                    if (isNumber(ch) || isOperator(ch) || isSpecialOperator(ch) || isPoint(ch) || isBracket(ch) || ch == ' ') {
        
                        //如果此字符是空格  那么如果他的前一个或后一个是小数点、前后都是数字或者元素字符，那么这个表达式就是不合法，
                        // 不过由于本计算器是用户点击按钮进行输入，所以不会出现多出多余空格的错误
                        // 此字符前后可能有多个空格，调用方法得到此字符的前/后一个的有效字符
                        int pre = getPreIndexOfNotBlankSpace(expression, i);
                        int next = getNextIndexOfNotBlankSpace(expression, i);
                        
                        if (ch == ' ') {
        
                            if (isPoint(expression.charAt(pre)) || isPoint(expression.charAt(next)) || (isNumber(expression.charAt(pre))) && isNumber(expression.charAt(next)) || (isOperator(expression.charAt(pre))) && isOperator(expression.charAt(next))) {
        
                                return false;
                            }
                        }
                        
                        // 如果是左括号( 那么下一个有效字符必须不能是小数点或者*、/、)、%
                        if (ch == '(') {
        
                            leftCount++;
                            if (isPoint(expression.charAt(next)) || expression.charAt(next) == '*' || expression.charAt(next) == '/' || expression.charAt(next) == ')' || expression.charAt(next) == '%') {
        
                                return false;
                            }
                            // 入栈
                            stack.push(ch);
                        }
                        // 如果是) 此时栈空则说明不合法 否则弹出一个(   )后面只可以是运算符或者)
                        if (ch == ')') {
        
                            rightCount++;
                            if (stack.empty() || (!isOperator(expression.charAt(next)) && expression.charAt(next) != ')')) {
        
                                return false;
                            } else {
        
                                stack.pop();
                            }
                        }
                        
                        // 如果是除号 后一个数是0就不合法 除数不能是0
                        if (ch == '/') {
        
                            if (expression.charAt(next) == '0') {
        
                                return false;
                            }
                        }
                        
                        // 如果是运算符，前一个或后一个不能是小数点、操作符
                        if (isOperator(ch) || isSpecialOperator(ch)) {
        
                            if (isPoint(expression.charAt(pre)) || isPoint(expression.charAt(next)) || expression.charAt(next) == ')' || isOperator(expression.charAt(next))) {
        
                                return false;
                            }
                        }
                        
                        // 如果是小数点，前后都必须是数字
                        if (isPoint(ch)) {
        
                            if (!isNumber(expression.charAt(pre)) || !isNumber(expression.charAt(next))) {
        
                                return false;
                            }
                        }
                        i++;
                    } else {
        
                        return false;
                    }
                }
                
                // 如果字符都合法最后判断括号是否成对：即(数量 和 )括号数量是否相等
                if (leftCount != rightCount) {
        
                    // 说明括号不是成对出现
                    return false;
                }
            }
            return true;
        }
        
        // 获取后一个有效字符下标
        public static int getPreIndexOfNotBlankSpace(String expression, int i) {
        
            // 如果下表是最后一个字符下标那么就返回最后一个字符下标
            if (i == 0) {
        
                return 0;
            } else if (i < 0 || i >= expression.length()) {
        
                throw new RuntimeException("error");
            } else {
        
                i--;
                while (expression.charAt(i) == ' ') {
        
                    i--;
                }
                return i;
            }
        }
        
        // 获取前一个有效字符的下标
        public static int getNextIndexOfNotBlankSpace(String expression, int i) {
        
            // 如果下标为0 那么前一个有效字符就是0
            if (i == expression.length() - 1) {
        
                return expression.length() - 1;
            } else if (i < 0 || i >= expression.length()) {
        
                throw new RuntimeException("error");
            } else {
        
                i++;
                while (expression.charAt(i) == ' ') {
        
                    i++;
                }
                return i;
            }
        }
        
        
        // 判断这个字符是不是数字
        public static boolean isNumber(char ch) {
        
            if (ch >= '0' && ch <= '9') {
        
                return true;
            } else {
        
                return false;
            }
        }
        
        // 判断这个字符是不是普通运算符
        public static boolean isOperator(char ch) {
        
            if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {
        
                return true;
            } else {
        
                return false;
            }
        }
        // 判断这个字符是不是普通运算符
        public static boolean isSpecialOperator(char ch) {
        
            if (ch == 'A' || ch == 'S' || ch == 'P') {
        
                return true;
            } else {
        
                return false;
            }
        }
        
        // 判断这个字符是不是小数点
        public static boolean isPoint(char ch) {
        
            return ch == '.';
        }
        
        // 判断这个字符是不是括号
        public static boolean isBracket(char ch) {
        
            return ch == '(' || ch == ')';
        }
    }

**将中缀表达式转换为后缀表达式**

//中缀表达式转后缀表达式
        //比如输入为1+5*7，转为后缀表达式为157*+
        private void Infix2Postfix() {
        
            // 依次扫描表达式eq1
            for(int i = 0;i < eq1.size();i++) {
        
                if(prio.get(eq1.get(i)) != null) {
         //对运算符进行处理
                    String c = eq1.get(i);
                    if(stk.empty() || c.equals("(")) {
         //如果栈为空或者是左括号，直接入栈。为什么左括号也要直接入栈？考虑到括号嵌套问题，如6+((1+2)*3+4)*5
                        stk.push(c);
                    } else if(c.equals(")")) {
         //遇到右括号，将栈顶元素一直出栈直到遇到左括号为止，并将该左括号出栈(右括号不入栈)
                        while(!stk.peek().equals("(")) {
        
                            //只要栈顶元素不为左括号，就将该运算符出栈并添加到列表中
                            eq2.add(stk.pop());
                        }
                        stk.pop(); //将左括号出栈
                    } else if(prio.get(c) > prio.get(stk.peek())) {
        
                        //如果当前运算符优先级高于栈顶运算符优先级,直接入栈
                        stk.push(c);
                    } else {
         //当前运算符优先级低于或等于栈顶运算符优先级，分四种情况
                        while(!stk.empty() && !stk.peek().equals("(") && prio.get(stk.peek()) >= prio.get(c)) {
        
                            eq2.add(stk.pop());
                        }
                        // 之后再把当前运算符入栈
                        stk.push(c);
                    }
                } else {
         //对参数数据进行处理，参数直接添加进列表
                    eq2.add(eq1.get(i));
                }
            }
            // 按以上方法处理完所有的字符后，再将栈中所有运算符依次弹出，并加入后缀表达式
            while(!stk.empty()){
        
                eq2.add(stk.pop());
            }
            System.out.println("中缀表达式eq1: " + eq1);
            System.out.println("后缀表达式eq2: " + eq2);
        }

**对后缀表达式进行计算**

//对后缀表达式计算
        private String postfixCalculate() {
        
            BigDecimal p1,p2;
            BigDecimal p3 = new BigDecimal("0");
    
            for(int i = 0;i < eq2.size();i++){
        
                if(prio.get(eq2.get(i)) == null){
         //对参数进行处理
                    stk.push(eq2.get(i)); //参数直接入栈
                } else {
         //对运算符进行处理
                    String c = eq2.get(i);
                    // 如果是S或者A运算需要单独处理
                    if (c.equals("A")) {
        
                        // 绝对值运算
                        p3 = new BigDecimal(stk.pop()).abs();
                        stk.push(p3.toString());
                    } else if (c.equals("S")) {
        
                        // 开方运算
                        p3 = new BigDecimal(Math.sqrt(Double.valueOf(stk.pop())));
                        stk.push(p3.toString());
                    } else if (c.equals("P")) {
        
                        // 平方运算
                        p3 = new BigDecimal(Math.pow(Double.valueOf(stk.pop()), 2.0));
                        stk.push(p3.toString());
                    } else {
        
                        p1 = new BigDecimal(stk.pop());
                        p2 = new BigDecimal(stk.pop());
    
                        switch(c){
        
                            case "+":p3 = p2.add(p1);break;
    
                            case "-":p3 = p2.subtract(p1);break;
    
                            case "*":p3 = p2.multiply(p1);break;
    
                            // 除法精确到小数点后第18位，并四舍五入
                            case "/": p3 = p2.divide(p1, RoundingMode.HALF_UP);break;
                            //case "/": p3 = new BigDecimal((p2.doubleValue()/p1.doubleValue()));
    
                            case "%":p3 = p2.remainder(p1);break;
    
                            default:p3=BigDecimal.ZERO;break;
                        }
                        stk.push(p3.toString());
                    }
                }
            }
            return stk.pop();
        }

\*\*注：\*\*以上只是部分代码，完整代码我上传到了gitee保管，[calculator][]，点击即可访问。

[0c8c949d99ec435b9f4f4300493630bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/2376aa24c586447fb68068342bf14883.png
[cc70a506ec7a43df83b5cf3e3b94c98f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/39c0e39c12ec4e068c646e24178e0519.png
[calculator]: https://gitee.com/Ethereal91/calculator