直接上一个之前写过的工具类，无依赖，全部逻辑都在方法上有注释。
public class FormulaCalcUtil {
/**
* 数学的基础运算符号，按照优先级排序放入数组;
* 乘号与除号是同一优先级；加号与减号是同一优先级
*/
private final static char MathSymbolArr[][] = {{'*', '/'}, {'+', '-'}};
private final static char leftBracket = '(';
private final static char rightBracket = ')';
/**简单运算的结果
*/
private static float executeResult = 0.0f;
/**
* 表达式的计算结果
*/
private static float result = 0.0f;
/**
* 计算一个简单的运算
*
* @param operator 数学运算符
* @param left 计算公式左侧数字
* @param right 计算公式右侧数字
* @return
*/
private static Float baseExecute(char operator, Float left, Float right) {
switch (operator) {
case ('*'):
return left * right;
case ('/'):
return left / right;
case ('+'):
return left + right;
case ('-'):
return left - right;
default:
throw new IllegalArgumentException("Invalid operator: " + operator);
}
}
/**
* 判断公式是否需要计算
*
* @param expression 数学表达式
* @return
*/
public boolean needCalculate(String expression) {
if (expression.contains("\\*") || expression.contains("\\/")
|| expression.contains("\\+") || expression.contains("\\-")) {
return true;
}
return false;
}
/**
* 判断运算式是否合法（主要是判断括号是否是成对存在）
*
* @param expression 数学公式的字符串
* @return
*/
public static boolean isValidExpression(String expression) {
Stack<Character> stack = new Stack<>();
for (char c : expression.toCharArray()) {
if (c == leftBracket) {
stack.push('(');
} else if (c == rightBracket) {
if (stack.isEmpty()) {
return false;
}
stack.pop();
}
}
return stack.isEmpty();
}
/**
* 计算运算式是否有括号
* 注：
* 已经确定了公式的合法性；
*
* @param expression
* @return
*/
public static boolean hasBracket(String expression) {
boolean hasBracket = false;
for (char c : expression.toCharArray()) {
if (c == leftBracket) {
hasBracket = true;
break;
}
}
return hasBracket;
}
/**
* 判断表达式是否有基础运算符
*
* @param expression
* @return
*/
public static boolean hasOperator(String expression) {
boolean hasOperator = false;
if (null != expression) {
loop:
for (char[] mathSymbol : MathSymbolArr) {
for (char symbol : mathSymbol) {
for (char expressChar : expression.toCharArray()) {
if (symbol == expressChar) {
hasOperator = true;
break loop;
}
}
}
}
}
return hasOperator;
}
/**
* 完整公式的计算过程
* 1 将表达式转成字节数组；
* 2 遍历表达式字节数组，所有左括号和右括号的index，存入数组
* 左括号用先进后出的数组；右括号用先进先出的数组;
* 但是，如果查到左括号的时候，右括号数组已经有内容，说明存在同一层级的括号，那么对括号优先级的判断到此为止，先计算已经统计的最内层括号；
* 3 找出最内层括号的简单表达式，通过 @method{executeWithNoBracket}计算
* 4 重复步骤2到步骤3，直到没有括号
* <p>
* 注：表达式最外层不允许有括号
* todo 该方法还需优化
* @param expression
* @return
*/
public static Float execute(String expression) {
if (!hasBracket(expression) && !hasOperator(expression)) {
return Float.valueOf(expression);
}
char[] chars = expression.toCharArray();
// 存储左括号的index
List<Integer> leftList = new ArrayList<>();
// 右侧括号的index
int rightIndex = 0;
// 提取到最内层的括号
loop:
while (hasBracket(expression)) {
for (int i = 0; i < chars.length; i++) {
// 只要找到右侧的第一个括号的位置就跳出括号统计的循环，开始计算
if (chars[i] == '(' && rightIndex == 0) {
leftList.add(i);
}
if (chars[i] == ')') {
rightIndex = i;
break loop;
}
}
}
/**
* 提取到最内层括号后开始计算最内层公式；
* 括号内的公式提取要去除左右括号；
* leftList.get(leftSize-1) 是最内层左括号的index；leftList.get(leftSize-1)+1 是避开了左括号的位置;
* rightIndex 是最内层右括号的index;
*/
if (rightIndex > 0) {
int leftSize = leftList.size();
String expressionNoBrackets = expression.substring(leftList.get(leftSize - 1) + 1, rightIndex);
result = executeWithNoBracket(expressionNoBrackets);
expression = replaceExpress(expression, leftList.get(leftSize - 1), rightIndex, result);
execute(expression);
}
if (hasOperator(expression)) {
result = executeWithNoBracket(expression);
}
return result;
}
/**
* 计算没有括号的运算公式
* 逻辑思路：
* 按照运算公式本身的顺序，根据数学符号的优先级，逐步计算
* <p>
* 具体步骤：
* 1 遍历数学符号的字节数组 {MathSymbolArr}，该数组已经定义了运算符号的优先级；
* 2 数学公式{expressionNoBracket}转为字节数组{expressArr},遍历该字节数组，找到与当前运算符匹配的运算符；如果没有，继续下一个运算符。
* 3 找到对应运算符后，以该运算符为索引，查找运算符两端的数字；
* 左侧数字：从运算符开始往前查找，直到找到上一个运算符，或者找到该表达式的起始位置；且每个位置上的字符c属于[0,9]区间或是小数点；
* 右侧数字：从运算符开始往后查找，直到找到下一个运算符，或者找到该表达式的结束为止；且每个位置上的字符c属于[0,9]区间或是小数点；
* <p>
* 4 将获取到的数值和运算符进行基础运算，带入 {baseExecute(char operator, Float left, Float right)};
* 5 将基础运算的结果，替换到未运算完成的公式，得到新的需要运算的表达式；
* 只要进行过一次运算，就赋值得到新的表达式；
* 并跳出内外循环（表达式字节数组的循环到此终止；基础运算符号的循环也终止）；
* <p>
* 6 计算接下来的公式；重复步骤1到步骤4，直到表达式中不存在运算符，计算结束。
*
* @param expressionNoBracket
* @return
*/
private static Float executeWithNoBracket(String expressionNoBracket) {
if (!hasOperator(expressionNoBracket)) {
return Float.valueOf(expressionNoBracket);
}
char[] expressCharArr = expressionNoBracket.toCharArray();
int opIndex = 0;
/*
* 无括号的表达式，优先级排序： 乘号 = 除号 > 加号 = 减号；
* 同一优先级，先查到哪个符号就计算那个符号;
* 每次循环只进行一次基础计算
*/
loop:
for (char[] chars : MathSymbolArr) {
char[] mathSymbol = chars;
for (int expIndex = 0; expIndex < expressCharArr.length; expIndex++) {
// 找到运算符的位置， 每个运算符只做一次计算，然后更新表达式
if (expressCharArr[expIndex] == mathSymbol[0] || expressCharArr[expIndex] == mathSymbol[1]) {
opIndex = expIndex;
break loop;
}
}
}
String left = getLeftNumber(expressionNoBracket, 0, opIndex - 1);
String right = getRightNumber(expressionNoBracket, opIndex + 1, expressionNoBracket.length() - 1);
// 只有两个数值的表达式简单运算
executeResult = baseExecute(expressCharArr[opIndex], Float.valueOf(left), Float.valueOf(right));
// 带入刚计算出的值，更新表达式
expressionNoBracket = replaceExpress(expressionNoBracket, opIndex - left.length(), opIndex + right.length(), executeResult);
if (hasOperator(expressionNoBracket)) {
executeWithNoBracket(expressionNoBracket);
}
return executeResult;
}
/**
* 通过上一步计算出的结果覆盖公式中的基础运算式
* 如
* 原式 2*3+1；上一步计算出2*3 = 6；
* 通过 nextExpress(2*3+1, 0, 2, 6) 得出新的公式为 6 + 1
*
* @param expression 被替换的表达式
* @param start 替换开始的位置（该位置也替换）
* @param end 替换结束的位置（该位置也替换）
* @param executeResult 用来替换的数值
* @return
*/
private static String replaceExpress(String expression, int start, int end, Float executeResult) {
return expression.substring(0, start) + executeResult + expression.substring(end + 1);
}
/**
* 找到运算符右边的数值
*
* @param expression 原表达式
* @param start 表达式右侧数值的开始位置
* @param end 表达式结束的位置
* @return
*/
private static String getRightNumber(String expression, int start, int end) {
char[] chars = expression.toCharArray();
int bottom = 0;
for (int i = start; i <= end && (chars[i] >= '0' && chars[i] <= '9' || chars[i] == '.'); i++) {
bottom = i;
}
return expression.substring(start, bottom + 1);
}
/**
* 找到运算符左边的数值
*
* @param expression 原表达式
* @param start 表达式开始的位置
* @param end 计算右侧数值的终止位置
* @return
*/
private static String getLeftNumber(String expression, int start, int end) {
char[] chars = expression.toCharArray();
int bottom = 0;
for (int i = end; i >= start && (chars[i] >= '0' && chars[i] <= '9' || chars[i] == '.'); i--) {
bottom = i;
}
return expression.substring(bottom, end + 1);
}
public static void main(String[] args) {
/**
* 测试1：左右侧数值的提取
*/
/*String expression = "9*0.01";
System.out.println("leftNumber = " + getLeftNumber(expression, 0, 0));
System.out.println("rightNumber = " + getRightNumber(expression, 2, 5));
*//**
* 测试2：表达式替换
*//*
String expression = "1+6.0+1";
System.out.println(replaceExpress(expression, 2, 4, (float) 6));
System.out.println(hasOperator("11.23"));
*//**
* 测试3：基础运算
*//*
String expression = "20*2/5-0.77+2*2";
Float execute = executeWithNoBracket(expression);
System.out.println("计算结果：" + execute)*/
/**
* 测试4：带括号的计算
*/
String expression = "((2*3+1+8)*5+1)/2";
Float execute = execute(expression);
System.out.println("计算结果：" + execute);
}
}
这个实现没有好好的使用栈的功能，完全是按照最简单的方法实现的。
而实际上，java本身就可以实现这些简单的四则运算，直接将公式作为脚本使用就行。
float formula = (float) (((2*3+1+8)*5+1)/2);
System.out.println(formula);
