Java实现四则运算,使用堆栈,检查语法

突然发闲想试一试自己实现算术的四则运算，支持加减乘除和括号、正负号；支持语法检查；思路很常规，利用两个堆栈，一个压操作符，一个压操作数，念头冒出来之后，立马动手；然后本以为很容易的一个实现，却存在各种各样的坑，正常逻辑花了1个小时，填坑缺填了5个小时，不多说，上代码；

能够检测的语法错误:缺少操作数、缺少操作符、缺失括号、不合法的数值；

支持运算程度：全部使用浮点数float；支持任意位置的空格、制表符、回车；多重括号；

视为语法错误的约束：空括号、多重正负号（非加减号）、除数为0；

编码能力有限，望各路大神海涵；

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Stack;

 public class FunctionStack {

     private Map<String, Integer> optLevel;
     private boolean nextIsOpt = false;
     private boolean debug = false;
     private int debug_len = 3;

     public FunctionStack setDebugLen(int len) {
         this.debug_len = len;
         return this;
     }

     public FunctionStack setDebug(boolean debug) {
         this.debug = debug;
         return this;
     }

     private void println(Object obj) {
         if (debug) {
             System.out.println(obj);
         }
     }

     public FunctionStack() {
         optLevel = new HashMap<String, Integer>();
         optLevel.put("(", 1);
         optLevel.put("+", 2);
         optLevel.put("-", 2);
         optLevel.put("*", 3);
         optLevel.put("/", 3);
         optLevel.put(")", 4);
     }

     public static void main(String[] args) {

         FunctionStack fs = new FunctionStack();
         fs.setDebug(true).setDebugLen(5);
         String fun = " 1 + 2 * 3 / 4 ";
         try {
             float res = fs.execute(fun);
             System.out.println("结果为:" + res);
         } catch (FunctionStackException e) {
             System.out.println(e.getMessage());
         }
         System.out.println("结束.");
     }

     /**
      *
      * @param fun
      * @return
      * @throws FunctionStackException
      */
     public float execute(String fun) throws FunctionStackException {
         this.clear();
         // TODO Auto-generated method stub
         if (fun == null || fun.trim().length() == 0) {
             throw new FunctionStackException("表达式不能为空;");
         }
         // 创建操作符堆栈和操作数堆栈
         Stack<String> opt = new Stack<String>();
         Stack<Float> num = new Stack<Float>();
         // 扫描整个表达式
         // point记录上一个扫描点
         int point = 0;
         for (int i = 0; i < fun.length(); i++) {
             String scanOpt = fun.charAt(i) + "";
             if (scanOpt.equals("(")) {
                 // 发现左括号,压入栈
                 // 检查是否为空的括号
                 int right = fun.indexOf(')', i);
                 if (right < 0) {
                     // 如果没有找到右括号
                     throw new FunctionStackException(fun
                             + "\n语法错误:"
                             + "缺少右括号与之对应:"
                             + fun.substring(Math.max(point - debug_len, 0),
                                     Math.min(i + debug_len, fun.length())));
                 } else {
                     // 找到右括号,检查是否为空括号
                     if (fun.substring(i + 1, right).trim().length() == 0) {
                         throw new FunctionStackException(fun
                                 + "\n语法错误:"
                                 + "括号中内容不可为空:"
                                 + fun.substring(Math.max(point - debug_len, 0),
                                         Math.min(i + debug_len, fun.length())));
                     }
                 }
                 // 检查语法
                 String num_before_opt = fun.substring(point, i).trim();
                 if (num_before_opt.length() != 0) {
                     throw new FunctionStackException(fun
                             + "\n语法错误:"
                             + "括号前缺少操作符:"
                             + fun.substring(Math.max(point - debug_len, 0),
                                     Math.min(i + debug_len, fun.length())));
                 }
                 // 将左括号压入栈
                 println("↓压栈:" + fun.substring(i, i + 1));
                 opt.push(fun.substring(i, i + 1));
                 // 记录扫描点
                 point = i + 1;
             } else if (scanOpt.equals(")")) {
                 // 发现右括号,取出栈,直到取出左括号
                 println("---计算括号开始:");
                 // 将括号前的数值取出
                 pushFloatStack(fun, num, point, i);
                 // 记录下一个是操作符
                 nextIsOpt = true;
                 // 检查前一个操作符是否为空
                 if (opt.empty()) {
                     throw new FunctionStackException(fun
                             + "\n语法错误:"
                             + "缺少左括号与之对应:"
                             + fun.substring(Math.max(point - debug_len, 0),
                                     Math.min(i + debug_len, fun.length())));
                 }
                 // 取出前一个操作符
                 String optpop = opt.pop();
                 println("↑↑出栈:" + optpop);
                 // 取出栈,直到取出左括号
                 while (!optpop.equals("(")) {
                     // 若取出的操作符不是左括号,执行运算;
                     calculator(optpop, num);
                     if (opt.empty()) {
                         throw new FunctionStackException(fun
                                 + "\n语法错误:"
                                 + "缺少左括号与之对应:"
                                 + fun.substring(Math.max(point - debug_len, 0),
                                         Math.min(i + debug_len, fun.length())));
                     }
                     optpop = opt.pop();
                     println("↑↑出栈:" + optpop);
                 }

                 // 记录扫描点
                 point = i + 1;
                 println("---计算括号结束:");
             } else if (optLevel.get(scanOpt) != null) {
                 if (scanOpt.equals("-") || scanOpt.equals("+")) {
                     // 如果是减号,可能是一个负号
                     if (fun.substring(point, i).trim().replaceAll("-", "")
                             .replaceAll("\\+", "").trim().length() == 0) {
                         // 如果减号前没有操作数,视此减号为负号,point不移动,-也不压入堆栈
                         continue;
                     }
                 }
                 // 发现非括号的操作符,查看栈顶操作符优先级,选择计算or压栈
                 // 获取操作数,并检查语法
                 pushFloatStack(fun, num, point, i);
                 // 比较优先级,将栈顶优先级高的先计算
                 if (!opt.empty()) {
                     // 获取栈顶操作符,不取出
                     String optpop = opt.peek();
                     // 取栈计算,直到栈顶操作符优先级小于scanOpt
                     while (optLevel.get(optpop) >= optLevel.get(scanOpt)) {
                         calculator(optpop, num);
                         optpop = opt.pop();
                         println("↑↑出栈:" + optpop);
                         if (opt.empty()) {
                             // 如果操作符取空了则退出
                             break;
                         }
                         optpop = opt.peek();
                     }
                 }
                 // 压入操作符
                 println("↓压栈:" + scanOpt);
                 opt.push(scanOpt);
                 // 记录扫描点
                 point = i + 1;
             } else if (scanOpt.equals("=")) {
                 // 发现=号,取栈计算总结果,并提前结束循环
                 // 获取操作数,并检查语法
                 pushFloatStack(fun, num, point, i);
                 // 取栈计算直到结束
                 while (!opt.empty()) {
                     String optpop = opt.pop();
                     println("↑↑出栈:" + optpop);
                     calculator(optpop, num);
                 }
                 return getResult(num);
             }

         }

         // 表达式结束
         // 获取操作数,并检查语法
         pushFloatStack(fun, num, point, fun.length());
         // 取栈计算直到结束
         while (!opt.empty()) {
             String optpop = opt.pop();
             println("↑↑出栈:" + optpop);
             calculator(optpop, num);
         }
         return getResult(num);
     }

     private void clear() {
         // TODO Auto-generated method stub
         nextIsOpt = false;
     }

     private float getResult(Stack<Float> num) {
         // TODO Auto-generated method stub
         Float res = num.pop();
         if (num.empty()) {
             return res;
         } else {
             throw new FunctionStackException("计算错误,堆栈中还有数据;");
         }
     }

     /**
      * 将操作符i前的操作数解析,并压入堆栈
      *
      * @param fun
      * @param num
      * @param point
      *            操作数起点
      * @param i
      *            操作符位置，即操作数终点
      */
     private void pushFloatStack(String fun, Stack<Float> num, int point, int i) {
         String num_before_opt = fun.substring(point, i).trim();
         if (num_before_opt.length() == 0) {
             // 没有操作数
             if (nextIsOpt) {

                 // 应该没有操作数,(即此处本应只有操作符,没有操作数)
                 nextIsOpt = false;
                 return;
             } else {
                 // 应该有操作数
                 throw new FunctionStackException(fun
                         + "\n语法错误:"
                         + "缺少操作数:"
                         + fun.substring(Math.max(point - debug_len, 0),
                                 Math.min(i + debug_len, fun.length())));
             }
         } else {
             // 有操作数
             if (nextIsOpt) {
                 // 应该没有操作数
                 throw new FunctionStackException(fun
                         + "\n语法错误:"
                         + "缺少操作符:"
                         + fun.substring(Math.max(point - debug_len, 0),
                                 Math.min(i + debug_len, fun.length())));
             } else {
                 // 应该有操作数
                 try {
                     // 去除操作数中间的空格、回车、制表符
                     num_before_opt = num_before_opt.replaceAll(" ", "");
                     num_before_opt = num_before_opt.replaceAll("\t", "");
                     num_before_opt = num_before_opt.replaceAll("\n", "");
                     Float scannum = Float.parseFloat(num_before_opt);
                     println("↓压栈:" + scannum);
                     num.push(scannum);
                 } catch (NumberFormatException e) {
                     throw new FunctionStackException(fun + "\n语法错误:"
                             + "无法识别的数值:" + num_before_opt);
                 }
             }
         }
     }

     /**
      *
      * @param optpop
      *            运算符
      */
     private void calculator(String optpop, Stack<Float> num) {
         // TODO Auto-generated method stub
         Float pop2 = num.pop();
         println("↑↑出栈:" + pop2);
         Float pop1 = num.pop();
         println("↑↑出栈:" + pop1);
         println("--------计算 " + pop1 + optpop + pop2);
         if (optpop.equals("+")) {
             println("↓压栈:" + (pop1 + pop2));
             num.push(pop1 + pop2);
         } else if (optpop.equals("-")) {
             println("↓压栈:" + (pop1 - pop2));
             num.push(pop1 - pop2);
         } else if (optpop.equals("*")) {
             println("↓压栈:" + (pop1 * pop2));
             num.push(pop1 * pop2);
         } else if (optpop.equals("/")) {
             if (pop2 == 0) {
                 throw new FunctionStackException("语法错误:" + "除数不可以为零:" + pop2);
             }
             println("↓压栈:" + (pop1 / pop2));
             num.push(pop1 / pop2);
         } else if (optpop.equals("(")) {
             throw new FunctionStackException("语法错误:" + "缺少右括号与之对应:" + optpop);
         } else {
             throw new FunctionStackException("语法错误:" + "错误的操作符:" + optpop);
         }

     }

 }

主代码

 public class FunctionStackException extends RuntimeException {

     /**
      *
      */
     private static final long serialVersionUID = 1L;

     public FunctionStackException(String message) {
         super(message);
     }

 }

自定义异常