java实现计算复杂逻辑表达式
最近遇到一个需求，需要对逻辑表达式进行计算，支持数据类型包括数字，日期以及字符串，运算符包括<,<=,>,>=,(,),==,!=,&&,||。
代码结构：
OperatorEnum 运算符枚举类 枚举了支持的运算符，信息包括运算符及他们的优先级
OperandTypeEnum 数据类型枚举类
LogicUtil 逻辑运算工具类，实现逻辑运算
DateUtil 日期工具类，提供验证是否为日期以及比较大小方法，是否为日期类型见https://www.cnblogs.com/lin0/p/13323925.html
（后续还在实现逻辑表达式中添加了判断表达式是否合法代码，括号不匹配，运算符两边数据类型不一致，逻辑表达式不完整等，未粘贴上来）
OperatorEnum：
import java.util.HashMap; import java.util.Map; public enum OperatorEnum { //!,&,|运算时暂时未考虑在内，主要用于判断字符是否为操作 NOT("!",0), LT("<",1), ELT("<=",1), GT(">",1), EGT(">=",1), EQ("==",2), NEQ("!=",2), BAND("&", 3), BOR("|", 4), AND("&&",5), OR("||",6), E("=", 7); private String name; private Integer priority; OperatorEnum(String name, Integer priority){ this.name = name; this.priority = priority; } private static Map<String, OperatorEnum> enums = new HashMap<>(); public static void enumToMap(){ enums.put("!", OperatorEnum.NOT); enums.put("<", OperatorEnum.LT); enums.put("<=", OperatorEnum.ELT); enums.put(">", OperatorEnum.GT); enums.put(">=", OperatorEnum.EGT); enums.put("==", OperatorEnum.EQ); enums.put("!=", OperatorEnum.NEQ); enums.put("&", OperatorEnum.BAND); enums.put("|", OperatorEnum.BOR); enums.put("&&", OperatorEnum.AND); enums.put("||", OperatorEnum.OR); enums.put("=", OperatorEnum.E); } public static OperatorEnum getEnumByName(String name){ if(enums.size() < 1){ enumToMap(); } return enums.get(name); } public static boolean isOperator(String name){ if(enums.size() < 1){ enumToMap(); } return enums.containsKey(name); } public Integer getPriority() { return priority; } public String getName() { return name; } }
OperandTypeEnum：
public enum OperandTypeEnum { NUM("数字"), DATE("日期"), STR("字符串"); private String typeName; OperandTypeEnum(String typeName){ this.typeName = typeName; } }
DateUtil：
/** * @author Carol * 比较日期大小 * @return */ public static int compareDate(String date1, String date2){ String d1 = date1.trim().replaceAll("-|:|/| ",""); String d2 = date2.trim().replaceAll("-|:|/| ", ""); StringBuilder sb1 = new StringBuilder(d1); StringBuilder sb2 = new StringBuilder(d2); while(sb1.length() < 14){ sb1.append("0"); } while(sb2.length() < 14){ sb2.append("0"); } long num1 = Long.parseLong(sb1.toString()); long num2 = Long.parseLong(sb2.toString()); return num1 == num2 ? 0 : num1 > num2 ? 1 : -1; }
LogicUtil：
/** * @author Carol * 计算表达式 * 利用一个操作数栈和一个操作栈来进行计算 * 出栈情况：当前字符串为操作并且优先级小于栈顶操作元素或者遇到“)”，将操作栈中栈顶元素出栈，操作数栈中出栈俩元素 * 入栈情况：“(”直接入栈，或者当前操作优先级大于栈顶元素则直接入栈，操作数直接入栈 * @param expression * @return */ public static boolean parse2(String expression) { Deque<String> operands = new LinkedList<>();//操作数栈 Deque<String> operate = new LinkedList<>();//操作栈 StringBuilder sb = new StringBuilder(); try { byte[] bytes = expression.getBytes("GBK"); for (int i = 0 ; i < bytes.length ; i ++) { //汉字 if (bytes[i] < 0) { if (i == bytes.length - 1) {//字符串异常截断 //不要这个字 } else { sb.append(new String(new byte[]{bytes[i], bytes[i + 1]}, "GBK")); i ++; } continue; } String thisOp = new String(new byte[]{bytes[i]}); //直接入栈 if ("(".equals(thisOp)) { pushOperandIntoStack(operands, sb); operate.addFirst(thisOp); continue; } //到“(”之前的全部出栈 if (")".equals(thisOp)) { pushOperandIntoStack(operands, sb); String topOp = operate.pollFirst(); while(!"(".equals(topOp)){ calculate(operands, topOp); if (operate.size() > 0) { topOp = operate.pollFirst(); } else { //括号没匹配上，逻辑表达式出错 return false; } } continue; } if (OperatorEnum.isOperator(thisOp)) {//当前是否为操作符 //是，1.查看之前是否有字符未入栈，先入栈字符 pushOperandIntoStack(operands, sb); //2.查看下一个是否为操作，并且非括号，是合并当前一起入操作栈 String nextOp = new String(new byte[]{bytes[i + 1]}); //下个与当前一起组成一个操作 if (!"(".equals(nextOp) && !")".equals(nextOp) && OperatorEnum.isOperator(nextOp)) { thisOp += nextOp; i ++; } //判断当前操作与栈顶操作优先级 if(operate.size() > 0){ String topOp = operate.getFirst(); while(!"(".equals(topOp) && OperatorEnum.getEnumByName(topOp).getPriority() < OperatorEnum.getEnumByName(thisOp).getPriority()){ //优先级高，出栈进行计算 topOp = operate.pollFirst(); calculate(operands, topOp); if (operate.size() > 0) { topOp = operate.getFirst(); } else { break; } } } operate.addFirst(thisOp); } else { sb.append(thisOp); } } } catch (Exception e){ e.printStackTrace(); } if(sb.length() > 0){ operands.addFirst(sb.toString()); } while(operate.size() > 0){ String topOp = operate.pollFirst(); calculate(operands, topOp); } if (operands.size() > 0){ String str = operands.pollFirst(); return StringUtils.isNotBlank(str) ? Boolean.parseBoolean(str) : false; } return false; } private static void pushOperandIntoStack(Deque operands, StringBuilder sb){ if(sb.length() > 0){ operands.addFirst(sb.toString()); sb.setLength(0); } } private static void calculate(Deque<String> operands, String topOp){ String operand2 = operands.pollFirst().trim(); String operand1 = operands.pollFirst().trim(); //判断两个操作数类型，不一致不可比较直接返回false OperandTypeEnum type1 = judgeType(operand1); OperandTypeEnum type2 = judgeType(operand2); if (type1 == type2) { switch (type1){ case NUM: operands.addFirst(numCalculate(Long.parseLong(operand1), Long.parseLong(operand2), OperatorEnum.getEnumByName(topOp)) + ""); break; case DATE: operands.addFirst(dateCalculate(operand1, operand2, OperatorEnum.getEnumByName(topOp)) + ""); break; case STR: operands.addFirst(strCalculate(operand1, operand2, OperatorEnum.getEnumByName(topOp)) + ""); break; } } else { operands.addFirst("false"); } } private static OperandTypeEnum judgeType (String operands) { operands = operands.trim(); if (Pattern.matches("^[-\\+]?[\\d]*$", operands)) { return OperandTypeEnum.NUM; } if (DateUtil.verifyDateLegal(operands)) { return OperandTypeEnum.DATE; } return OperandTypeEnum.STR; } private static boolean numCalculate(long operand1, long operand2, OperatorEnum operate){ switch (operate){ case LT: return operand1 < operand2; case ELT: return operand1 <= operand2; case GT: return operand1 > operand2; case EGT: return operand1 >= operand2; case EQ: return operand1 == operand2; case NEQ: return operand1 != operand2; default: return true; } } private static boolean strCalculate(String operand1, String operand2, OperatorEnum operate){ switch (operate){ case EQ: return operand1.equals(operand2); case NEQ: return !operand1.equals(operand2); case AND: return "true".equals(operand1) && "true".equals(operand2); case OR: return "true".equals(operand1) || "true".equals(operand2); default: return true; } } private static boolean dateCalculate(String operand1, String operand2, OperatorEnum operate){ switch (operate){ case LT: return DateUtil.compareDate(operand1, operand2) == -1 ? true : false; case ELT: return DateUtil.compareDate(operand1, operand2) <= 0 ? true : false; case GT: return DateUtil.compareDate(operand1, operand2) == 1 ? true : false; case EGT: return DateUtil.compareDate(operand1, operand2) >= 0 ? true : false; case EQ: return DateUtil.compareDate(operand1, operand2) == 0 ? true : false; case NEQ: return DateUtil.compareDate(operand1, operand2) != 0 ? true : false; default: return true; } }
测试代码：
System.out.println( LogicUtil.parse2("2==3 && 2==2 || 3==3"));
System.out.println("true == " + parse2("3>2"));
System.out.println("false == " + parse2("true == false"));
System.out.println("false == " + parse2("(3<2||2==2)&&(4==5)"));
System.out.println("false == " + parse2("(abc==fdg||民事==民事&&嘻嘻==嘻ha)&&(4>2||5<10)"));
System.out.println("true == " + parse2("()(((abc!=fdg||民事==民事&&嘻嘻==嘻ha)&&(4>2||5<10)))"));
System.out.println("true == " + parse2("5 < 19"));
System.out.println("false == " + parse2("5 > 19"));
测试结果：
