因项目需要，在网上找来一套表达式解析方法，由于原来的方法太过于零散，不利于移植，现在整理在同一文件内；
文件中包含5个内部类，源码如下：
1 import java.util.ArrayList; 2 import java.util.Date; 3 import java.util.List; 4 import java.util.Stack; 5 6 /** 7 * @项目名称: sunson_pams 8 * @类名称: FormulaUtils 9 * @类描述: 非原创（慎用） 10 * @创建人: 唐泽齐 11 * @创建时间: 2017年12月15日 上午9:47:23 12 * @修改人: 唐泽齐 13 * @修改时间: 2017年12月15日 上午9:47:23 14 * @修改备注: 15 * @version: 1.0 16 */ 17 public class FormulaUtils { 18 19 /** 20 * 表达式解析 21 */ 22 public static ExpressionEvaluator ExpressionEvaluator; 23 24 public FormulaUtils() { 25 ExpressionEvaluator = new ExpressionEvaluator(); 26 }; 27 28 /** 29 * 表达式各个字符节点的类型枚举类 30 * 31 * @项目名称: sunson_pams 32 * @类名称: ExpressionNodeType 33 * @类描述: 34 * @创建人: 唐泽齐 35 * @创建时间: 2017年12月15日 上午9:49:48 36 * @修改人: 唐泽齐 37 * @修改时间: 2017年12月15日 上午9:49:48 38 * @修改备注: 39 * @version: 1.0 40 */ 41 public enum ExpressionNodeType { 42 43 Unknown, Plus, // + 44 Subtract, /// - 45 MultiPly, // * 46 Divide, // / 47 LParentheses, // ( 48 RParentheses, /// ) 49 Mod, // % (求模,取余) 50 Power, // ^ (次幂) 51 BitwiseAnd, /// & (按位与) 52 BitwiseOr, /// | (按位或) 53 And, // && (逻辑与) 54 Or, /// || (逻辑或) 55 Not, /// ! (逻辑非) 56 Equal, /// == (相等) 57 Unequal, /// != 或 <> (不等于) 58 GT, /// > (大于) 59 LT, /// < (小于) 60 GTOrEqual, /// >= (大于等于) 61 LTOrEqual, /// <= (小于等于) 62 LShift, /// << (左移位) 63 RShift, /// >> (右移位) 64 Numeric, /// 数值, 65 String, Date, Like, // 包含 66 NotLike, // 不包含 67 StartWith, // 已什么开始 68 EndWith// 已什么结尾 69 70 } 71 72 /** 73 * 存储表达式运算符或操作数的各个节点的类 74 * 75 * @项目名称: sunson_pams 76 * @类名称: ExpressionNode 77 * @类描述: 78 * @创建人: 唐泽齐 79 * @创建时间: 2017年12月15日 上午9:50:50 80 * @修改人: 唐泽齐 81 * @修改时间: 2017年12月15日 上午9:50:50 82 * @修改备注: 83 * @version: 1.0 84 */ 85 public static class ExpressionNode { 86 87 private String value; 88 89 private ExpressionNodeType type; 90 91 private int pri; 92 93 private ExpressionNode unitaryNode; 94 95 private Object numeric; 96 97 /** 98 * 99 * @param value 100 * 操作数或运算符 101 */ 102 public ExpressionNode(String value) { 103 this.value = value; 104 this.type = parseNodeType(value); 105 this.pri = getNodeTypePRI(this.type); 106 this.numeric = null; 107 } 108 109 public Object getNumeric() { 110 if (this.numeric == null) { 111 112 if ((this.type == ExpressionNodeType.String) || (this.type == ExpressionNodeType.Date)) { 113 return this.value; 114 } 115 116 if (this.type != ExpressionNodeType.Numeric) { 117 return 0; 118 } 119 Double num = new Double(this.value); 120 if (this.unitaryNode != null && this.unitaryNode.type == ExpressionNodeType.Subtract) { 121 num = 0 - num; 122 } 123 this.numeric = num; 124 } 125 return numeric; 126 } 127 128 public void setNumeric(Object numeric) { 129 this.numeric = numeric; 130 this.value = this.numeric.toString(); 131 } 132 133 /** 134 * 设置或返回与当前节点相关联的一元操作符节点 135 * 136 * @param unitaryNode 137 */ 138 public void setUnitaryNode(ExpressionNode unitaryNode) { 139 this.unitaryNode = unitaryNode; 140 } 141 142 /** 143 * 解析节点类型 144 * 145 * @param value 146 * @return 147 */ 148 private ExpressionNodeType parseNodeType(String value) { 149 if (StringUtils.isEmpty(value)) { 150 return ExpressionNodeType.Unknown; 151 } 152 switch (value) { 153 case "+": 154 return ExpressionNodeType.Plus; 155 case "-": 156 return ExpressionNodeType.Subtract; 157 case "*": 158 return ExpressionNodeType.MultiPly; 159 case "/": 160 return ExpressionNodeType.Divide; 161 case "%": 162 return ExpressionNodeType.Mod; 163 case "^": 164 return ExpressionNodeType.Power; 165 case "(": 166 return ExpressionNodeType.LParentheses; 167 case ")": 168 return ExpressionNodeType.RParentheses; 169 case "&": 170 return ExpressionNodeType.BitwiseAnd; 171 case "|": 172 return ExpressionNodeType.BitwiseOr; 173 case "&&": 174 case "<并且>": 175 case "并且": 176 return ExpressionNodeType.And; 177 case "||": 178 case "<或者>": 179 case "或者": 180 return ExpressionNodeType.Or; 181 case "!": 182 return ExpressionNodeType.Not; 183 case "==": 184 case "=": 185 return ExpressionNodeType.Equal; 186 case "!=": 187 case "<>": 188 case "≠": 189 return ExpressionNodeType.Unequal; 190 case ">": 191 return ExpressionNodeType.GT; 192 case "<": 193 return ExpressionNodeType.LT; 194 case ">=": 195 case "≥": 196 return ExpressionNodeType.GTOrEqual; 197 case "<=": 198 case "≤": 199 return ExpressionNodeType.LTOrEqual; 200 case "<<": 201 return ExpressionNodeType.LShift; 202 case ">>": 203 return ExpressionNodeType.RShift; 204 case "@": 205 case "<包含>": 206 case "包含": 207 return ExpressionNodeType.Like; 208 case "[email protected]": 209 case "<不包含>": 210 case "不包含": 211 return ExpressionNodeType.NotLike; 212 case "!!$": 213 return ExpressionNodeType.StartWith; 214 case "[email protected]": 215 return ExpressionNodeType.EndWith; 216 217 } 218 if (isNumerics(value)) { 219 return ExpressionNodeType.Numeric; 220 } 221 if (isDatetime(value)) { 222 return ExpressionNodeType.Date; 223 } 224 if (value.contains("\"")) { 225 return ExpressionNodeType.String; 226 } 227 return ExpressionNodeType.Unknown; 228 } 229 230 /** 231 * 获取各节点类型的优先级 232 * 233 * @param nodeType 234 * @return 235 */ 236 private int getNodeTypePRI(ExpressionNodeType nodeType) { 237 switch (nodeType) { 238 case LParentheses: 239 case RParentheses: 240 return 9; 241 // 逻辑非是一元操作符,所以其优先级较高 242 case Not: 243 return 8; 244 case Mod: 245 return 7; 246 case MultiPly: 247 case Divide: 248 case Power: 249 return 6; 250 case Plus: 251 case Subtract: 252 return 5; 253 case LShift: 254 case RShift: 255 return 4; 256 case BitwiseAnd: 257 case BitwiseOr: 258 return 3; 259 case Equal: 260 case Unequal: 261 case GT: 262 case LT: 263 case GTOrEqual: 264 case LTOrEqual: 265 case Like: 266 case NotLike: 267 case StartWith: 268 case EndWith: 269 return 2; 270 case And: 271 case Or: 272 return 1; 273 default: 274 return 0; 275 } 276 277 } 278 279 /** 280 * 判断是否为数值 281 * 282 * @param op 283 * @return 284 */ 285 public boolean isNumerics(String op) { 286 return op.matches("^[\\+\\-]?(0|[1-9]\\d*|[1-9]\\d*\\.\\d+|0\\.\\d+)"); 287 } 288 289 /** 290 * 判断是否为日期 291 * 292 * @param op 293 * @return 294 */ 295 public static boolean isDatetime(String op) { 296 op = op.replace("\"", "").trim(); 297 return op.matches("\\d{4}\\-\\d{2}\\-\\d{2}(\\s\\d{2}\\:\\d{2}\\:\\d{2})?"); 298 } 299 300 /** 301 * 判断某个字符后是否需要更多的操作符 302 * 303 * @param c 304 * @return 305 */ 306 public boolean needMoreOperator(char c) { 307 switch (c) { 308 case ‘&‘: 309 case ‘|‘: 310 case ‘=‘: 311 case ‘!‘: 312 case ‘>‘: 313 case ‘<‘: 314 case ‘.‘: // 小数点 315 return true; 316 } 317 // //数字则需要更多 318 return Character.isDigit(c); 319 } 320 321 /** 322 * 判断两个字符是否是同一类 323 * 324 * @param c1 325 * @param c2 326 * @return 327 */ 328 public boolean IsCongener(char c1, char c2) { 329 if ((c1 == ‘(‘) || (c2 == ‘(‘)) { 330 return false; 331 } 332 if ((c1 == ‘)‘) || (c2 == ‘)‘)) { 333 return false; 334 } 335 if ((c1 == ‘"‘) || (c2 == ‘"‘)) { 336 return false; 337 } 338 if (Character.isDigit(c1) || (c1 == ‘.‘)) { 339 // c1为数字,则c2也为数字 340 return (Character.isDigit(c2) || (c2 == ‘.‘)); 341 } 342 return (!Character.isDigit(c2) && (c2 != ‘.‘)); 343 } 344 345 /** 346 * 判断某个字符是否是空白字符 347 * 348 * @param c 349 * @return 350 */ 351 public boolean IsWhileSpace(char c) { 352 return c == ‘ ‘ || c == ‘\t‘; 353 } 354 355 /** 356 * 判断是否是一元操作符节点 357 * 358 * @param nodeType 359 * @return 360 */ 361 public static boolean IsUnitaryNode(ExpressionNodeType nodeType) { 362 return (nodeType == ExpressionNodeType.Plus || nodeType == ExpressionNodeType.Subtract); 363 } 364 365 public String getValue() { 366 return value; 367 } 368 369 public void setValue(String value) { 370 this.value = value; 371 } 372 373 public ExpressionNodeType getType() { 374 return type; 375 } 376 377 public void setType(ExpressionNodeType type) { 378 this.type = type; 379 } 380 381 public int getPri() { 382 return pri; 383 } 384 385 public void setPri(int pri) { 386 this.pri = pri; 387 } 388 389 public ExpressionNode getUnitaryNode() { 390 return unitaryNode; 391 } 392 } 393 394 /** 395 * 表达式异常类 396 * 397 * @项目名称: sunson_pams 398 * @类名称: ExpressionException 399 * @类描述: 400 * @创建人: 唐泽齐 401 * @创建时间: 2017年12月15日 上午9:52:13 402 * @修改人: 唐泽齐 403 * @修改时间: 2017年12月15日 上午9:52:13 404 * @修改备注: 405 * @version: 1.0 406 */ 407 public static class ExpressionException extends RuntimeException { 408 409 /** 410 * 411 */ 412 private static final long serialVersionUID = 3136681292988750961L; 413 414 public ExpressionException() { 415 super(); 416 } 417 418 public ExpressionException(String msg) { 419 super(msg); 420 } 421 422 public ExpressionException(String msg, Throwable cause) { 423 super(msg, cause); 424 } 425 426 public ExpressionException(Throwable cause) { 427 super(cause); 428 } 429 } 430 431 /** 432 * 负责读取表达式生成ExpressionNode对象的类 433 * 434 * @项目名称: sunson_pams 435 * @类名称: ExpressionParser 436 * @类描述: 437 * @创建人: 唐泽齐 438 * @创建时间: 2017年12月15日 上午9:52:59 439 * @修改人: 唐泽齐 440 * @修改时间: 2017年12月15日 上午9:52:59 441 * @修改备注: 442 * @version: 1.0 443 */ 444 public static class ExpressionParser { 445 446 // 当前分析的表达式 447 private String expression; 448 449 // 当前读取的位置 450 private int position; 451 452 public String getExpression() { 453 return expression; 454 } 455 456 public void setExpression(String expression) { 457 this.expression = expression; 458 } 459 460 public int getPosition() { 461 return position; 462 } 463 464 public void setPosition(int position) { 465 this.position = position; 466 } 467 468 public ExpressionParser(String expression) { 469 this.expression = expression; 470 this.position = 0; 471 } 472 473 /** 474 * 读取下一个表达式节点,如果读取失败则返回null 475 * 476 * @return 477 */ 478 public ExpressionNode readNode() { 479 ExpressionNode s = new ExpressionNode(null); 480 // 空格的位置 481 int whileSpacePos = -1; 482 boolean flag = false; 483 StringBuffer buffer = new StringBuffer(10); 484 while (this.position < this.expression.length()) { 485 char c = this.expression.charAt(this.position); 486 if (c == ‘"‘) { 487 flag = !flag; 488 if (!flag) { 489 this.position++; 490 buffer.append(c); 491 break; 492 } 493 if (buffer.length() != 0) { 494 break; 495 } 496 } 497 if (flag) { 498 this.position++; 499 buffer.append(c); 500 } else { 501 if (s.IsWhileSpace(c)) { 502 if ((whileSpacePos >= 0) && ((this.position - whileSpacePos) > 1)) { 503 throw new ExpressionException( 504 String.format("表达式\"%s\"在位置(%s)上的字符非法!", this.getExpression(), this.getPosition())); 505 } 506 if (buffer.length() == 0) { 507 whileSpacePos = -1; 508 } else { 509 whileSpacePos = this.position; 510 } 511 this.position++; 512 continue; 513 } 514 if ((buffer.length() == 0) || s.IsCongener(c, buffer.charAt(buffer.length() - 1))) { 515 this.position++; 516 buffer.append(c); 517 } else { 518 break; 519 } 520 if (!s.needMoreOperator(c)) { 521 break; 522 } 523 } 524 } 525 if (buffer.length() == 0) { 526 return null; 527 } 528 ExpressionNode node = new ExpressionNode(buffer.toString()); 529 if (node.getType() == ExpressionNodeType.Unknown) { 530 throw new ExpressionException(String.format("表达式\"%s\"在位置%s上的字符\"%s\"非法!", this.getExpression(), 531 this.getPosition() - node.getValue().length(), node.getValue())); 532 } 533 return node; 534 } 535 536 } 537 538 /** 539 * 解析公式并返回结果的类 540 * 541 * @项目名称: sunson_pams 542 * @类名称: ExpressionEvaluator 543 * @类描述: 544 * @创建人: 唐泽齐 545 * @创建时间: 2017年12月15日 上午9:56:08 546 * @修改人: 唐泽齐 547 * @修改时间: 2017年12月15日 上午9:56:08 548 * @修改备注: 549 * @version: 1.0 550 */ 551 public static class ExpressionEvaluator { 552 553 private ExpressionEvaluator() { 554 555 } 556 557 /** 558 * 将算术表达式转换为逆波兰表达式 559 * 560 * @param expression 561 * 要计算的表达式,如"1+2+3+4" 562 * @return 563 */ 564 private static List<ExpressionNode> parseExpression(String expression) { 565 if (StringUtils.isEmpty(expression)) { 566 return new ArrayList<ExpressionNode>(); 567 } 568 569 List<ExpressionNode> listOperator = new ArrayList<ExpressionNode>(10); 570 Stack<ExpressionNode> stackOperator = new Stack<ExpressionNode>(); 571 572 ExpressionParser expParser = new ExpressionParser(expression); 573 ExpressionNode beforeExpNode = null; // 前一个节点 574 ExpressionNode unitaryNode = null; // 一元操作符 575 ExpressionNode expNode; 576 // 是否需要操作数 577 boolean requireOperand = false; 578 579 while ((expNode = expParser.readNode()) != null) { 580 if ((expNode.getType() == ExpressionNodeType.Numeric) 581 || (expNode.getType() == ExpressionNodeType.String) 582 || (expNode.getType() == ExpressionNodeType.Date)) { 583 // 操作数， 直接加入后缀表达式中 584 if (unitaryNode != null) { 585 // 设置一元操作符节点 586 expNode.setUnitaryNode(unitaryNode); 587 unitaryNode = null; 588 } 589 590 listOperator.add(expNode); 591 requireOperand = false; 592 continue; 593 } else if (expNode.getType() == ExpressionNodeType.LParentheses) { 594 // 左括号， 直接加入操作符栈 595 stackOperator.push(expNode); 596 continue; 597 } else if (expNode.getType() == ExpressionNodeType.RParentheses) { 598 // 右括号则在操作符栈中反向搜索，直到遇到匹配的左括号为止，将中间的操作符依次加到后缀表达式中。 599 ExpressionNode lpNode = null; 600 while (stackOperator.size() > 0) { 601 lpNode = stackOperator.pop(); 602 if (lpNode.getType() == ExpressionNodeType.LParentheses) 603 break; 604 listOperator.add(lpNode); 605 } 606 if (lpNode == null || lpNode.getType() != ExpressionNodeType.LParentheses) { 607 throw new ExpressionException(String.format("在表达式\"%s\"中没有与在位置(%s)上\")\"匹配的\"(%s)\"字符!",expParser.getExpression(), expParser.getPosition())); 608 } 609 } else { 610 if (stackOperator.size() == 0) { 611 // 第一个节点则判断此节点是否是一元操作符"+,-,!,("中的一个,否则其它都非法 612 if (listOperator.size() == 0 && !(expNode.getType() == ExpressionNodeType.LParentheses 613 || expNode.getType() == ExpressionNodeType.Not)) { 614 // 后缀表达式没有任何数据则判断是否是一元操作数 615 if (ExpressionNode.IsUnitaryNode(expNode.getType())) { 616 unitaryNode = expNode; 617 } else { 618 // 丢失操作数 619 throw new ExpressionException(String.format("表达式\"%s\"在位置(%s)上缺少操作数!", 620 expParser.getExpression(), expParser.getPosition())); 621 } 622 } else { 623 // 直接压入操作符栈 624 stackOperator.push(expNode); 625 } 626 requireOperand = true; // 下一个节点需要操作数 627 continue; 628 } else { 629 if (requireOperand) { 630 // 如果需要操作数则判断当前的是否是"+","-"号(一元操作符),如果是则继续 631 if (ExpressionNode.IsUnitaryNode(expNode.getType()) && unitaryNode == null) { 632 unitaryNode = expNode; 633 } else { 634 // 丢失操作数 635 throw new ExpressionException(String.format("表达式\"%s\"在位置({1})上缺少操作数!", 636 expParser.getExpression(), expParser.getPosition())); 637 } 638 } else { 639 // 对前面的所有操作符进行优先级比较 640 do { 641 // 取得上一次的操作符 642 beforeExpNode = stackOperator.peek(); 643 644 // 如果前一个操作符优先级较高，则将前一个操作符加入后缀表达式中 645 if (beforeExpNode.getType() != ExpressionNodeType.LParentheses 646 && (beforeExpNode.getPri() - expNode.getPri()) >= 0) { 647 listOperator.add(stackOperator.pop()); 648 } else { 649 break; 650 } 651 652 } while (stackOperator.size() > 0); 653 654 // 将操作符压入操作符栈 655 stackOperator.push(expNode); 656 requireOperand = true; 657 } 658 } 659 } 660 } 661 662 if (requireOperand) { 663 // 丢失操作数 664 throw new ExpressionException( 665 String.format("表达式\"%s\"在位置({1})上缺少操作数!", expParser.getExpression(), expParser.getPosition())); 666 } 667 // 清空堆栈 668 while (stackOperator.size() > 0) { 669 // 取得操作符 670 beforeExpNode = stackOperator.pop(); 671 if (beforeExpNode.getType() == ExpressionNodeType.LParentheses) { 672 throw new ExpressionException(String.format("表达式\"%s\"中括号不匹配,丢失右括号!", expParser.getExpression(), 673 expParser.getPosition())); 674 } 675 listOperator.add(beforeExpNode); 676 } 677 678 return listOperator; 679 } 680 681 /** 682 * 对逆波兰表达式进行计算 683 * 684 * @param nodes 685 * @return 686 */ 687 @SuppressWarnings({ "rawtypes", "unchecked", "incomplete-switch" }) 688 private static Object CalcExpression(List<ExpressionNode> nodes) { 689 if (nodes == null || nodes.size() == 0) 690 return null; 691 692 if (nodes.size() > 1) { 693 int index = 0; 694 // 储存数据 695 ArrayList values = new ArrayList(); 696 while (index < nodes.size()) { 697 ExpressionNode node = nodes.get(index); 698 699 switch (node.getType()) { 700 // 如果是数字，则将值存入 values 中 701 case Numeric: 702 case String: 703 case Date: 704 values.add(node.getNumeric()); 705 index++; 706 break; 707 default: 708 // 二元表达式，需要二个参数， 如果是Not的话，则只要一个参数 709 int paramCount = 2; 710 if (node.getType() == ExpressionNodeType.Not) 711 paramCount = 1; 712 // 计算操作数的值 713 if (values.size() < paramCount) { 714 throw new ExpressionException("缺少操作数"); 715 } 716 // 传入参数 717 Object[] data = new Object[paramCount]; 718 for (int i = 0; i < paramCount; i++) { 719 data[i] = values.get(index - paramCount + i); 720 } 721 // 将计算结果再存入当前节点 722 node.setNumeric(calculate(node.getType(), data)); 723 node.setType(ExpressionNodeType.Numeric); 724 // 将操作数节点删除 725 for (int i = 0; i < paramCount; i++) { 726 nodes.remove(index - i - 1); 727 values.remove(index - i - 1); 728 } 729 index -= paramCount; 730 break; 731 } 732 733 } 734 } 735 736 if (nodes.size() != 1) { 737 throw new ExpressionException("缺少操作符或操作数"); 738 } 739 switch (nodes.get(0).getType()) { 740 case Numeric: 741 return nodes.get(0).getNumeric(); 742 743 case String: 744 case Date: 745 return nodes.get(0).getNumeric().toString().replace("\"", ""); 746 } 747 throw new ExpressionException("缺少操作数"); 748 } 749 750 /** 751 * 计算节点的值 752 * 753 * @param nodeType 754 * 节点的类型 755 * @param data 756 * 要计算的值,有可能是两位或一位数 757 * @return 758 */ 759 @SuppressWarnings("incomplete-switch") 760 private static Object calculate(ExpressionNodeType nodeType, Object[] data) { 761 double d1, d2; 762 boolean b1, b2; 763 Date time1, time2; 764 Object obj1 = data[0]; 765 Object obj2 = data[1]; 766 String str1 = obj1.toString(); 767 String str2 = obj2.toString(); 768 769 boolean dateflag = ExpressionNode.isDatetime(str1) || ExpressionNode.isDatetime(str2); 770 boolean strflag = str1.contains("\"") || str2.contains("\""); 771 str1 = str1.replace("\"", ""); 772 str2 = str2.replace("\"", ""); 773 774 switch (nodeType) { 775 case Plus: 776 if (!strflag) { 777 d1 = ConvertToDecimal(obj1); 778 d2 = ConvertToDecimal(obj2); 779 return (d1 + d2); 780 } 781 return new StringBuffer(str1 + str2).toString(); 782 case Subtract: 783 d1 = ConvertToDecimal(obj1); 784 d2 = ConvertToDecimal(obj2); 785 return d1 - d2; 786 case MultiPly: 787 d1 = ConvertToDecimal(obj1); 788 d2 = ConvertToDecimal(obj2); 789 return d1 * d2; 790 case Divide: 791 d1 = ConvertToDecimal(obj1); 792 d2 = ConvertToDecimal(obj2); 793 if (d2 == 0) 794 throw new RuntimeException(); 795 return d1 / d2; 796 case Power: 797 d1 = ConvertToDecimal(obj1); 798 d2 = ConvertToDecimal(obj2); 799 return Math.pow((double) d1, (double) d2); 800 case Mod: 801 d1 = ConvertToDecimal(obj1); 802 d2 = ConvertToDecimal(obj2); 803 if (d2 == 0) 804 throw new RuntimeException(); 805 return d1 % d2; 806 case BitwiseAnd: 807 d1 = ConvertToDecimal(obj1); 808 d2 = ConvertToDecimal(obj2); 809 return (int) d1 & (int) d2; 810 case BitwiseOr: 811 d1 = ConvertToDecimal(obj1); 812 d2 = ConvertToDecimal(obj2); 813 return (int) d1 | (int) d2; 814 case And: 815 b1 = ConvertToBool(obj1); 816 b2 = ConvertToBool(obj2); 817 return b1 && b2; 818 case Or: 819 b1 = ConvertToBool(obj1); 820 b2 = ConvertToBool(obj2); 821 return b1 || b2; 822 case Not: 823 b1 = ConvertToBool(obj1); 824 return !b1; 825 case Equal: 826 if (!dateflag) { 827 if (strflag) { 828 return str1.equals(str2); 829 } 830 d1 = ConvertToDecimal(obj1); 831 d2 = ConvertToDecimal(obj2); 832 return (d1 == d2); 833 } 834 time1 = DateUtils.parseDate(str1); 835 time2 = DateUtils.parseDate(str2); 836 837 return (time1.getTime() == time2.getTime()); 838 case Unequal: 839 if (!dateflag) { 840 if (strflag) { 841 return (!str1.equals(str2)); 842 } 843 d1 = ConvertToDecimal(obj1); 844 d2 = ConvertToDecimal(obj2); 845 return (d1 != d2); 846 } 847 time1 = DateUtils.parseDate(str1); 848 time2 = DateUtils.parseDate(str2); 849 850 return (time1.getTime() != time2.getTime()); 851 case GT: 852 853 if (!dateflag) { 854 d1 = ConvertToDecimal(obj1); 855 d2 = ConvertToDecimal(obj2); 856 return (d1 > d2); 857 } 858 time1 = DateUtils.parseDate(str1); 859 time2 = DateUtils.parseDate(str2); 860 return (time1.getTime() > time2.getTime()); 861 862 case LT: 863 864 if (!dateflag) { 865 d1 = ConvertToDecimal(obj1); 866 d2 = ConvertToDecimal(obj2); 867 return (d1 < d2); 868 } 869 time1 = DateUtils.parseDate(str1); 870 time2 = DateUtils.parseDate(str2); 871 return (time1.getTime() < time2.getTime()); 872 873 case GTOrEqual: 874 875 if (!dateflag) { 876 d1 = ConvertToDecimal(obj1); 877 d2 = ConvertToDecimal(obj2); 878 return (d1 >= d2); 879 } 880 time1 = DateUtils.parseDate(str1); 881 time2 = DateUtils.parseDate(str2); 882 return (time1.getTime() >= time2.getTime()); 883 884 case LTOrEqual: 885 if (!dateflag) { 886 d1 = ConvertToDecimal(obj1); 887 d2 = ConvertToDecimal(obj2); 888 return (d1 <= d2); 889 } 890 time1 = DateUtils.parseDate(str1); 891 time2 = DateUtils.parseDate(str2); 892 return (time1.getTime() <= time2.getTime()); 893 case LShift: 894 d1 = ConvertToDecimal(obj1); 895 d2 = ConvertToDecimal(obj2); 896 return (long) d1 << (int) d2; 897 898 case RShift: 899 d1 = ConvertToDecimal(obj1); 900 d2 = ConvertToDecimal(obj2); 901 return (long) d1 >> (int) d2; 902 case Like: 903 if (!strflag) { 904 return false; 905 } 906 return str1.contains(str2); 907 case NotLike: 908 if (!strflag) { 909 return false; 910 } 911 return !str1.contains(str2); 912 case StartWith: 913 if (!strflag) { 914 return false; 915 } 916 return str1.startsWith(str2); 917 case EndWith: 918 if (!strflag) { 919 return false; 920 } 921 return str1.endsWith(str2); 922 } 923 924 return 0; 925 } 926 927 /** 928 * 某个值转换为bool值 929 * 930 * @param value 931 * @return 932 */ 933 private static Boolean ConvertToBool(Object value) { 934 if (value instanceof Boolean) { 935 return (Boolean) value; 936 } else { 937 return value != null; 938 } 939 } 940 941 /** 942 * 将某个值转换为decimal值 943 * 944 * @param value 945 * @return 946 */ 947 private static Double ConvertToDecimal(Object value) { 948 if (value instanceof Boolean) { 949 return ((Boolean) value ? 1d : 0d); 950 } else { 951 return Double.parseDouble(value.toString()); 952 } 953 } 954 955 /** 956 * 957 * @param expression 958 * 要计算的表达式,如"1+2+3+4" 959 * @return 返回计算结果,如果带有逻辑运算符则返回true/false,否则返回数值 960 */ 961 public Object eval(String expression) { 962 return CalcExpression(parseExpression(expression)); 963 } 964 965 public Object evalThreeOperand(String expression) { 966 int index = expression.indexOf("?"); 967 if (index > -1) { 968 String str = expression.substring(0, index); 969 String str2 = expression.substring(index + 1); 970 index = str2.indexOf(":"); 971 972 if (Boolean.parseBoolean((CalcExpression(parseExpression(str))).toString())) { 973 return eval(str2.substring(0, index)); 974 } 975 return eval(str2.substring(index + 1)); 976 } 977 return CalcExpression(parseExpression(expression)); 978 } 979 980 } 981 982 // /** 983 // * 测试 984 // * 985 // * @方法名:main 986 // * @参数 @param args 987 // * @返回类型 void 988 // */ 989 // public static void main(String[] args) { 990 // String s1 = "1+2+3+4"; 991 // System.out.println(ExpressionEvaluator.eval(s1)); 992 // 993 // String s2 = "(20 - 6) < 3"; 994 // System.out.println(ExpressionEvaluator.eval(s2)); 995 // 996 // String s3 = "(3 + 1) == 4 && 5 > (2 + 3)"; 997 // System.out.println(ExpressionEvaluator.eval(s3)); 998 // 999 // String s4 = "\"hello\" == \"hello\" && 3 != 4"; 1000 // System.out.println(ExpressionEvaluator.eval(s4)); 1001 // 1002 // String s5 = "\"helloworld\" @ \"hello\" && \"helloworld\" [email protected] \"word\" "; 1003 // System.out.println(ExpressionEvaluator.eval(s5)); 1004 // 1005 // } 1006 1007 }