java读写txt文件并且进行字符串操作代码 第3页

                numStack.add(nf.parse(token).doubleValue());
            } else {
                doCalcByOptr(token, numStack);
            }
        }

        if (!numStack.isEmpty() && numStack.size() == 1) {
            return numStack.lastElement();
        } else {
            throw new Exception("计算错误！");
        }
    }

    /**
     * 将运算符输出到后缀表达式序列.
     *
     * @param optr
     * @param optrStack
     * @param rpnList
     * @throws Exception
     */
    public static void outputOptr(String optr, Stack<String> optrStack,
            List<String> rpnList) throws Exception {
        String preOptr;

        if (optr.equals("(")) {// 处理左括号
            optrStack.push(optr);
            return;
        }

        if (optr.equals(")")) {// 处理右括号
            while (!optrStack.isEmpty()) {
                preOptr = optrStack.pop();
                if (!preOptr.equals("(")) {
                    rpnList.add(preOptr);
                } else {
                    break;
                }
            }

            if (optrStack.isEmpty()) {
                throw new Exception("括号未闭合!");
            }

            return;
        }

        /*
         * 按优先级处理其他运算符，若当前运算符优先级较高 直接入栈， 否则将栈中运算符出战直至栈顶运算符 低于当前运算符
         */
        preOptr = optrStack.lastElement();
        if (optrCmp(optr, preOptr) < 0) {
            optrStack.push(optr);
        } else {
            while (!preOptr.equals("(") && !optrStack.isEmpty()
                    && optrCmp(optr, preOptr) >= 0) {

                preOptr = optrStack.pop();
                if (!preOptr.equals("^")) {
                    rpnList.add(preOptr);
                }
            }
            optrStack.push(optr);
        }
    }

    /**
     * 运算符优先级比较函数,optr1优先级大于optr2返回小于0值, 优先级相等返回0,optr1小于optr2返回大于0值.
     *
     * @param optr1
     * @param optr2
     * @return
     */
    public static int optrCmp(String optr1, String optr2) {
        int order1 = optrOrder.get(optr1);
        int order2 = optrOrder.get(optr2);
        return order1 - order2;
    }

    /**
     * 根据运算符对数据栈中的内容进行操作.
     *
     * @param optr
     * @param numStack
     */
    public static void doCalcByOptr(String optr, Stack<Double> numStack) {
        double n1, n2;
        n2 = numStack.pop();
        n1 = numStack.pop();

        if (optr.equals("+")) {
            numStack.push(n1 + n2);
        } else if (optr.equals("-")) {
            numStack.push(n1 - n2);
        } else if (optr.equals("*")) {
            numStack.push(n1 * n2);
        } else if (optr.equals("/")) {
            numStack.push(n1 / n2);
        } else if (optr.equals("%")) {
            numStack.push(n1 % n2);
        }
    }
}

 

上一页  [1] [2] [3]