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