FormulaHelper.java

package com.yanzuoguang.util.helper;

import com.yanzuoguang.util.YzgError;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 公式计算
 *
 * @author 颜佐光
 */
public class FormulaHelper {

    private static final String REGEX_DOUBLE = "^[-+]?[0-9]*\\.?[0-9]+$";
    private static final String REGEX_QUOT = "(^.*?)\\((.+?)\\)(.*?$)";
    private static final String REGEX_CALC_ADD_PLUS = "(^.*)([+\\-])(.*?$)";
    private static final String REGEX_CALC_MULTIPLY_MOD = "(^.*)([*/])(.*?$)";
    private static final String REGEX_CALC_TAG = "[+\\-*/()]+";
    private static final String EMPTY_CHAR = " ";
    private static final String TEMP_VAR_NAME = "@temp";

    private static final FormulaHelper calcInstance = new FormulaHelper();

    /**
     * 公式参数获取
     */
    public interface CalcParameter {
        /**
         * 获取参数值
         *
         * @param parameterName 获取参数值的名称
         * @return
         */
        double getValue(String parameterName);
    }


    /**
     * 获取excel列序号
     *
     * @param columnName
     * @return
     */
    public static final int getExcelIndex(String columnName) {
        columnName = columnName.toLowerCase();
        if (!columnName.matches("^[a-z]+$")) {
            throw YzgError.getRuntimeException("013", columnName);
        }
        // 从名称转换列序号
        int formulaColumnIndex = 0;
        char[] chs = new char[columnName.length()];
        columnName.getChars(0, columnName.length(), chs, 0);
        for (int i = 0; i < chs.length; i++) {
            formulaColumnIndex = formulaColumnIndex * 26 + (chs[i] - 'a' + 1);
        }
        formulaColumnIndex--;
        return formulaColumnIndex;
    }

    /**
     * 计算公式
     *
     * @param formula 公式内容，支持括号、空格、数字、+、-、*、/、变量名，如: A * ( B + C )
     * @return 运算后的结果
     */
    public static double calc(String formula) {
        return calcInstance.calRun(formula, StringHelper.EMPTY, null);
    }


    /**
     * 计算公式
     *
     * @param formula       公式内容，支持括号、空格、数字、+、-、*、/、变量名，如: A * ( B + C )
     * @param calcParameter 获取变量值
     * @return 运算后的结果
     */
    public static double calc(String formula, CalcParameter calcParameter) {
        return calcInstance.calRun(formula, StringHelper.EMPTY, calcParameter);
    }


    /**
     * 计算公式
     *
     * @param formula       公式内容，支持括号、空格、数字、+、-、*、/、变量名，如: A * ( B + C )
     * @param tempName      临时变量名称
     * @param calcParameter 获取变量值
     * @return 运算后的结果
     */
    public static double calc(String formula, String tempName, CalcParameter calcParameter) {
        return calcInstance.calRun(formula, tempName, calcParameter);
    }

    /**
     * 计算公式
     *
     * @param formula       公式内容，支持括号、空格、数字、+、-、*、/、变量名，如: A * ( B + C )
     * @param tempName      临时变量名称
     * @param calcParameter 获取变量值
     * @return 运算后的结果
     */
    private double calRun(String formula, String tempName, CalcParameter calcParameter) {
        if (StringHelper.isEmpty(formula)) {
            return 0;
        }
        tempName = StringHelper.getFirst(tempName, TEMP_VAR_NAME);
        // 去掉公式空格
        formula = formula.replaceAll(EMPTY_CHAR, "");
        // 获取所有的变量名称
        List<String> varNames = getVarNames(formula);
        // 获取所有变量值
        Map<String, Double> varValues = getVarValues(varNames, calcParameter);
        // 返回计算结果
        return calcProc(formula, tempName, varValues);
    }

    /**
     * 获取变量表
     *
     * @param formula 输入等式的右边
     **/
    private List<String> getVarNames(String formula) {
        List<String> list = new ArrayList<>();
        //清理所有运算符，并且包含多个运算符号时，将多个运算符号当成一个运算符号处理
        String formulaTo = formula.replaceAll(REGEX_CALC_TAG, EMPTY_CHAR);
        String[] items = formulaTo.split(EMPTY_CHAR);
        for (String item : items) {
            // 判断是否是空字符串、纯数字，是则不属于变量
            if (StringHelper.isEmpty(item) || item.matches(REGEX_DOUBLE)) {
                continue;
            }
            list.add(item);
        }
        return list;
    }

    /**
     * 获取所有变量值
     *
     * @param varNames      变量名称列表
     * @param calcParameter 获取变量值
     * @return 变量值
     */
    private Map<String, Double> getVarValues(List<String> varNames, CalcParameter calcParameter) {
        // 获取所有的变量值
        Map<String, Double> varValues = new HashMap<>(varNames.size());
        for (String name : varNames) {
            if (varValues.containsKey(name) || calcParameter == null) {
                continue;
            }
            double value = calcParameter.getValue(name);
            varValues.put(name, value);
        }
        return varValues;
    }

    /**
     * 最终计算结果
     *
     * @param formula   公式
     * @param tempName  临时变量名称
     * @param varValues 变量值
     * @return
     */
    private double calcProc(String formula, String tempName, Map<String, Double> varValues) {
        double ret = 0;
        if (formula.matches(REGEX_QUOT)) {
            // 获取第一个括号和最后一个括号
            Matcher matcher = getMatcher(REGEX_QUOT, formula);
            double quotResult = calcProc(matcher.group(2), tempName, varValues);
            String mutualKey = TEMP_VAR_NAME + varValues.size();
            varValues.put(mutualKey, quotResult);
            String formulaTo = matcher.group(1) + mutualKey + matcher.group(3);
            ret = calcProc(formulaTo, tempName, varValues);
        } else if (formula.matches(REGEX_CALC_ADD_PLUS)) {
            // 判断是否包含+-运算符号
            Matcher matcher = getMatcher(REGEX_CALC_ADD_PLUS, formula);
            double leftResult = calcProc(matcher.group(1), tempName, varValues);
            double rightResult = calcProc(matcher.group(3), tempName, varValues);
            ret = calcItem(matcher.group(2), leftResult, rightResult);
        } else if (formula.matches(REGEX_CALC_MULTIPLY_MOD)) {
            // 判断是否包含*/运算符号
            Matcher matcher = getMatcher(REGEX_CALC_MULTIPLY_MOD, formula);
            double leftResult = calcProc(matcher.group(1), tempName, varValues);
            double rightResult = calcProc(matcher.group(3), tempName, varValues);
            ret = calcItem(matcher.group(2), leftResult, rightResult);
        } else if (formula.matches(REGEX_DOUBLE)) {
            ret = StringHelper.toDouble(formula);
        } else {
            ret = StringHelper.toDouble(varValues.get(formula));
        }
        // System.out.println("公式: " + formula + " 值" + ret);
        return ret;
    }

    /**
     * 匹配正则表达式和公式
     *
     * @param regex   正则表达式
     * @param formula 公式
     * @return 匹配后的结果
     */
    private Matcher getMatcher(String regex, String formula) {
        Pattern p = Pattern.compile(regex);
        Matcher matcher = p.matcher(formula);
        if (!matcher.find()) {
            throw YzgError.getRuntimeException("014");
        }
        return matcher;
    }

    private double calcItem(String flag, double a, double b) {
        switch (flag) {
            case "+":
                return CalcHelper.add(a, b);
            case "-":
                return CalcHelper.sub(a, b);
            case "*":
                return CalcHelper.mul(a, b);
            case "/":
                return CalcHelper.div(a, b);
            default:
                return 0;
        }
    }


}