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
                            + "
语法错误:"
                            + "缺少右括号与之对应:"
                            + 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
                                + "
语法错误:"
                                + "括号中内容不可为空:"
                                + 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
                            + "
语法错误:"
                            + "括号前缺少操作符:"
                            + 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
                            + "
语法错误:"
                            + "缺少左括号与之对应:"
                            + 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
                                + "
语法错误:"
                                + "缺少左括号与之对应:"
                                + 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
                        + "
语法错误:"
                        + "缺少操作数:"
                        + fun.substring(Math.max(point - debug_len, 0),
                                Math.min(i + debug_len, fun.length())));
            }
        } else {
            // 有操作数
            if (nextIsOpt) {
                // 应该没有操作数
                throw new FunctionStackException(fun
                        + "
语法错误:"
                        + "缺少操作符:"
                        + 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("	", "");
                    num_before_opt = num_before_opt.replaceAll("
", "");
                    Float scannum = Float.parseFloat(num_before_opt);
                    println("↓压栈:" + scannum);
                    num.push(scannum);
                } catch (NumberFormatException e) {
                    throw new FunctionStackException(fun + "
语法错误:"
                            + "无法识别的数值:" + 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);
    }

}