java小型科学计算器

/**
 * 1.先转换为逆波兰顺序
 *      数字直接存入list,符号压入栈中,但是如果栈底元素不大于该运算符的运算顺序,则将栈底pop,直到大于栈底运算符为止,再压入栈中,
 *      最后将运算符依次全部pop(以上pop出的运算符存入list)
 * 2.根据逆序算出结果
 *      从头到尾依次读取list的数据,将数字压入栈中,出现运算符后pop出两个数字进行运算,运算式为"后pop数 运算符 先pop数"
 *      运算完毕将结果再次压入栈中.结束后,将数字栈中的唯一一个数字pop出并将其返回.
 *
 *
 * 学习之处:
 *  1.String对象的比较不要用==,>,<.而是用equal()函数.
 *  2.使用HashMap<Object,Integer>()的定义可以给对象进行编号或加权.
 *  3.需要时要给读取的信息加上结尾标志,如读入String结尾的"#".
 *  4.取String的单个字母:String temps=String.valueOf(expression.charAt(i));
 *  5.检测数字:temps.matches("[0-9.]")
 **/

public class Calculator {
    private String string;
    private MyStack<String> opratorStack = new MyStack();
    private MyStack<Double> numberStack = new MyStack();
    private ArrayList<String> rpnList = new ArrayList();
    private Map<String,Integer> priorityMap=new HashMap<String,Integer>();//用于存储操作符优先级的Map
    //初始化优先级约定(可根据计算的复杂程度扩展)

    public Calculator(String str)
    {
        priorityMap.put("+",0);
        priorityMap.put("-",0);
        priorityMap.put("*", 1);
        priorityMap.put("/", 1);
        priorityMap.put("(", 2);
        string = str+"#";
    }
    private int getPriority(String op)//得到一个操作符的优先级
    {
        return priorityMap.get(op);
    }

    private void toRpn() {

        String temp = "";
        for (int i = 0; i < string.length(); i++) {
            String ch = String.valueOf(string.charAt(i));
            if (ch.matches("[0-9.]"))
                temp += ch;

            else { //如果操作数完整,现将其存入list中再进行后续操作

                if(!temp.equals("")) {//防止加入进空格
                    rpnList.add(temp);
                    temp = "";
                }

                if (ch.equals("#")) { //读取结束时将运算符栈依次pop并添加到rpnList中
                    while (!opratorStack.isEmpty()) {
                        rpnList.add(opratorStack.pop());
                    }
                } else if (ch.equals(")")) { //遇到右括号将左括号后的运算符全部pop
                    String op = opratorStack.pop();
                    while (!op .equals("(")) {
                        rpnList.add(op);
                        op = opratorStack.pop();
                    }
                } else {
                    if (!opratorStack.isEmpty()) { //如果为普通的运算符
                        String endOprator = opratorStack.endValue();

                        while (!endOprator.equals( "(") && (getPriority(ch) < getPriority(endOprator)
                                || getPriority(ch) == getPriority(endOprator))) {
                            rpnList.add(opratorStack.pop());//如果
                            if (!opratorStack.isEmpty()) {
                                endOprator = opratorStack.endValue();
                            }else
                                break;

                        }

                        opratorStack.push(ch);
                    }
                    else
                        opratorStack.push(ch);
                }
            }
        }
    }

    public double calculate(String string){
        this.string = string+"#";
        return calculate();
    }

    public double calculate(){
        toRpn();//逆波兰序列转换

        //扫描String对象
        for(int i = 0; i < rpnList.size(); i++){
            String temp = rpnList.get(i);
            //匹配第一个字符,为数字的则将String对象转为Double并存入numberStack中
            if(String.valueOf(temp.charAt(0)).matches("[0-9]")){
                numberStack.push(Double.valueOf(temp));
            } //匹配到运算符,调出最后两个numberStack中数字进行运算,并将得数压入栈中(栈次底数 操作符 栈最底数)
            else {
                //Double n = opration(numberStack.pop(), numberStack.pop(), temp);
                Double n = numberStack.pop();
                numberStack.push(opration(numberStack.pop(), n , temp));
            }
        }

        rpnList = new ArrayList();//为下次运算做准备
        return numberStack.pop();
    }

    private Double opration(Double val1,Double val2,String oprator){
        if(oprator.equals("+"))
            val1 += val2;
        else if(oprator.equals("-"))
            val1 -= val2;
        else if(oprator.equals("*"))
            val1 *= val2;
        else
            val1 /= val2;
        return val1;
    }

    public static void main(String[] args) {
        String string1 = "12+2*37-(4*5+6)*7";
        Calculator calculator = new Calculator(string1);

        System.out.println(calculator.calculate());
        System.out.println(calculator.calculate("4.99+5.99+6.99*1.06"));
    }
}

运算结果:

-96.0
18.389400000000002

Process finished with exit code 0