Java 表达式解析（非原创）

因项目需要，在网上找来一套表达式解析方法，由于原来的方法太过于零散，不利于移植，现在整理在同一文件内；

文件中包含5个内部类，源码如下：

 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Stack;

 /**
  * @项目名称: sunson_pams
  * @类名称: FormulaUtils
  * @类描述: 非原创（慎用）
  * @创建人: 唐泽齐
  * @创建时间: 2017年12月15日 上午9:47:23
  * @修改人: 唐泽齐
  * @修改时间: 2017年12月15日 上午9:47:23
  * @修改备注:
  * @version: 1.0
  */
 public class FormulaUtils {

     /**
      * 表达式解析
      */
     public static ExpressionEvaluator ExpressionEvaluator;

     public FormulaUtils() {
         ExpressionEvaluator = new ExpressionEvaluator();
     };

     /**
      * 表达式各个字符节点的类型枚举类
      *
      * @项目名称: sunson_pams
      * @类名称: ExpressionNodeType
      * @类描述:
      * @创建人: 唐泽齐
      * @创建时间: 2017年12月15日 上午9:49:48
      * @修改人: 唐泽齐
      * @修改时间: 2017年12月15日 上午9:49:48
      * @修改备注:
      * @version: 1.0
      */
     public enum ExpressionNodeType {

         Unknown, Plus, // +
         Subtract, /// -
         MultiPly, // *
         Divide, // /
         LParentheses, // (
         RParentheses, /// )
         Mod, // % (求模,取余)
         Power, // ^ (次幂)
         BitwiseAnd, /// & (按位与)
         BitwiseOr, /// | (按位或)
         And, // && (逻辑与)
         Or, /// || (逻辑或)
         Not, /// ! (逻辑非)
         Equal, /// == (相等)
         Unequal, /// != 或 <> (不等于)
         GT, /// > (大于)
         LT, /// < (小于)
         GTOrEqual, /// >= (大于等于)
         LTOrEqual, /// <= (小于等于)
         LShift, /// << (左移位)
         RShift, /// >> (右移位)
         Numeric, /// 数值,
         String, Date, Like, // 包含
         NotLike, // 不包含
         StartWith, // 已什么开始
         EndWith// 已什么结尾

     }

     /**
      * 存储表达式运算符或操作数的各个节点的类
      *
      * @项目名称: sunson_pams
      * @类名称: ExpressionNode
      * @类描述:
      * @创建人: 唐泽齐
      * @创建时间: 2017年12月15日 上午9:50:50
      * @修改人: 唐泽齐
      * @修改时间: 2017年12月15日 上午9:50:50
      * @修改备注:
      * @version: 1.0
      */
     public static class ExpressionNode {

         private String value;

         private ExpressionNodeType type;

         private int pri;

         private ExpressionNode unitaryNode;

         private Object numeric;

         /**
          *
          * @param value
          *            操作数或运算符
          */
         public ExpressionNode(String value) {
             this.value = value;
             this.type = parseNodeType(value);
             this.pri = getNodeTypePRI(this.type);
             this.numeric = null;
         }

         public Object getNumeric() {
             if (this.numeric == null) {

                 if ((this.type == ExpressionNodeType.String) || (this.type == ExpressionNodeType.Date)) {
                     return this.value;
                 }

                 if (this.type != ExpressionNodeType.Numeric) {
                     return 0;
                 }
                 Double num = new Double(this.value);
                 if (this.unitaryNode != null && this.unitaryNode.type == ExpressionNodeType.Subtract) {
                     num = 0 - num;
                 }
                 this.numeric = num;
             }
             return numeric;
         }

         public void setNumeric(Object numeric) {
             this.numeric = numeric;
             this.value = this.numeric.toString();
         }

         /**
          * 设置或返回与当前节点相关联的一元操作符节点
          *
          * @param unitaryNode
          */
         public void setUnitaryNode(ExpressionNode unitaryNode) {
             this.unitaryNode = unitaryNode;
         }

         /**
          * 解析节点类型
          *
          * @param value
          * @return
          */
         private ExpressionNodeType parseNodeType(String value) {
             if (StringUtils.isEmpty(value)) {
                 return ExpressionNodeType.Unknown;
             }
             switch (value) {
             case "+":
                 return ExpressionNodeType.Plus;
             case "-":
                 return ExpressionNodeType.Subtract;
             case "*":
                 return ExpressionNodeType.MultiPly;
             case "/":
                 return ExpressionNodeType.Divide;
             case "%":
                 return ExpressionNodeType.Mod;
             case "^":
                 return ExpressionNodeType.Power;
             case "(":
                 return ExpressionNodeType.LParentheses;
             case ")":
                 return ExpressionNodeType.RParentheses;
             case "&":
                 return ExpressionNodeType.BitwiseAnd;
             case "|":
                 return ExpressionNodeType.BitwiseOr;
             case "&&":
             case "<并且>":
             case "并且":
                 return ExpressionNodeType.And;
             case "||":
             case "<或者>":
             case "或者":
                 return ExpressionNodeType.Or;
             case "!":
                 return ExpressionNodeType.Not;
             case "==":
             case "=":
                 return ExpressionNodeType.Equal;
             case "!=":
             case "<>":
             case "≠":
                 return ExpressionNodeType.Unequal;
             case ">":
                 return ExpressionNodeType.GT;
             case "<":
                 return ExpressionNodeType.LT;
             case ">=":
             case "≥":
                 return ExpressionNodeType.GTOrEqual;
             case "<=":
             case "≤":
                 return ExpressionNodeType.LTOrEqual;
             case "<<":
                 return ExpressionNodeType.LShift;
             case ">>":
                 return ExpressionNodeType.RShift;
             case "@":
             case "<包含>":
             case "包含":
                 return ExpressionNodeType.Like;
             case "!@":
             case "<不包含>":
             case "不包含":
                 return ExpressionNodeType.NotLike;
             case "!!$":
                 return ExpressionNodeType.StartWith;
             case "!!@":
                 return ExpressionNodeType.EndWith;

             }
             if (isNumerics(value)) {
                 return ExpressionNodeType.Numeric;
             }
             if (isDatetime(value)) {
                 return ExpressionNodeType.Date;
             }
             if (value.contains("\"")) {
                 return ExpressionNodeType.String;
             }
             return ExpressionNodeType.Unknown;
         }

         /**
          * 获取各节点类型的优先级
          *
          * @param nodeType
          * @return
          */
         private int getNodeTypePRI(ExpressionNodeType nodeType) {
             switch (nodeType) {
             case LParentheses:
             case RParentheses:
                 return 9;
             // 逻辑非是一元操作符,所以其优先级较高
             case Not:
                 return 8;
             case Mod:
                 return 7;
             case MultiPly:
             case Divide:
             case Power:
                 return 6;
             case Plus:
             case Subtract:
                 return 5;
             case LShift:
             case RShift:
                 return 4;
             case BitwiseAnd:
             case BitwiseOr:
                 return 3;
             case Equal:
             case Unequal:
             case GT:
             case LT:
             case GTOrEqual:
             case LTOrEqual:
             case Like:
             case NotLike:
             case StartWith:
             case EndWith:
                 return 2;
             case And:
             case Or:
                 return 1;
             default:
                 return 0;
             }

         }

         /**
          * 判断是否为数值
          *
          * @param op
          * @return
          */
         public boolean isNumerics(String op) {
             return op.matches("^[\\+\\-]?(0|[1-9]\\d*|[1-9]\\d*\\.\\d+|0\\.\\d+)");
         }

         /**
          * 判断是否为日期
          *
          * @param op
          * @return
          */
         public static boolean isDatetime(String op) {
             op = op.replace("\"", "").trim();
             return op.matches("\\d{4}\\-\\d{2}\\-\\d{2}(\\s\\d{2}\\:\\d{2}\\:\\d{2})?");
         }

         /**
          * 判断某个字符后是否需要更多的操作符
          *
          * @param c
          * @return
          */
         public boolean needMoreOperator(char c) {
             switch (c) {
             case '&':
             case '|':
             case '=':
             case '!':
             case '>':
             case '<':
             case '.': // 小数点
                 return true;
             }
             // //数字则需要更多
             return Character.isDigit(c);
         }

         /**
          * 判断两个字符是否是同一类
          *
          * @param c1
          * @param c2
          * @return
          */
         public boolean IsCongener(char c1, char c2) {
             if ((c1 == '(') || (c2 == '(')) {
                 return false;
             }
             if ((c1 == ')') || (c2 == ')')) {
                 return false;
             }
             if ((c1 == '"') || (c2 == '"')) {
                 return false;
             }
             if (Character.isDigit(c1) || (c1 == '.')) {
                 // c1为数字,则c2也为数字
                 return (Character.isDigit(c2) || (c2 == '.'));
             }
             return (!Character.isDigit(c2) && (c2 != '.'));
         }

         /**
          * 判断某个字符是否是空白字符
          *
          * @param c
          * @return
          */
         public boolean IsWhileSpace(char c) {
             return c == ' ' || c == '\t';
         }

         /**
          * 判断是否是一元操作符节点
          *
          * @param nodeType
          * @return
          */
         public static boolean IsUnitaryNode(ExpressionNodeType nodeType) {
             return (nodeType == ExpressionNodeType.Plus || nodeType == ExpressionNodeType.Subtract);
         }

         public String getValue() {
             return value;
         }

         public void setValue(String value) {
             this.value = value;
         }

         public ExpressionNodeType getType() {
             return type;
         }

         public void setType(ExpressionNodeType type) {
             this.type = type;
         }

         public int getPri() {
             return pri;
         }

         public void setPri(int pri) {
             this.pri = pri;
         }

         public ExpressionNode getUnitaryNode() {
             return unitaryNode;
         }
     }

     /**
      * 表达式异常类
      *
      * @项目名称: sunson_pams
      * @类名称: ExpressionException
      * @类描述:
      * @创建人: 唐泽齐
      * @创建时间: 2017年12月15日 上午9:52:13
      * @修改人: 唐泽齐
      * @修改时间: 2017年12月15日 上午9:52:13
      * @修改备注:
      * @version: 1.0
      */
     public static class ExpressionException extends RuntimeException {

         /**
          *
          */
         private static final long serialVersionUID = 3136681292988750961L;

         public ExpressionException() {
             super();
         }

         public ExpressionException(String msg) {
             super(msg);
         }

         public ExpressionException(String msg, Throwable cause) {
             super(msg, cause);
         }

         public ExpressionException(Throwable cause) {
             super(cause);
         }
     }

     /**
      * 负责读取表达式生成ExpressionNode对象的类
      *
      * @项目名称: sunson_pams
      * @类名称: ExpressionParser
      * @类描述:
      * @创建人: 唐泽齐
      * @创建时间: 2017年12月15日 上午9:52:59
      * @修改人: 唐泽齐
      * @修改时间: 2017年12月15日 上午9:52:59
      * @修改备注:
      * @version: 1.0
      */
     public static class ExpressionParser {

         // 当前分析的表达式
         private String expression;

         // 当前读取的位置
         private int position;

         public String getExpression() {
             return expression;
         }

         public void setExpression(String expression) {
             this.expression = expression;
         }

         public int getPosition() {
             return position;
         }

         public void setPosition(int position) {
             this.position = position;
         }

         public ExpressionParser(String expression) {
             this.expression = expression;
             this.position = 0;
         }

         /**
          * 读取下一个表达式节点,如果读取失败则返回null
          *
          * @return
          */
         public ExpressionNode readNode() {
             ExpressionNode s = new ExpressionNode(null);
             // 空格的位置
             int whileSpacePos = -1;
             boolean flag = false;
             StringBuffer buffer = new StringBuffer(10);
             while (this.position < this.expression.length()) {
                 char c = this.expression.charAt(this.position);
                 if (c == '"') {
                     flag = !flag;
                     if (!flag) {
                         this.position++;
                         buffer.append(c);
                         break;
                     }
                     if (buffer.length() != 0) {
                         break;
                     }
                 }
                 if (flag) {
                     this.position++;
                     buffer.append(c);
                 } else {
                     if (s.IsWhileSpace(c)) {
                         if ((whileSpacePos >= 0) && ((this.position - whileSpacePos) > 1)) {
                             throw new ExpressionException(
                                     String.format("表达式\"%s\"在位置(%s)上的字符非法!", this.getExpression(), this.getPosition()));
                         }
                         if (buffer.length() == 0) {
                             whileSpacePos = -1;
                         } else {
                             whileSpacePos = this.position;
                         }
                         this.position++;
                         continue;
                     }
                     if ((buffer.length() == 0) || s.IsCongener(c, buffer.charAt(buffer.length() - 1))) {
                         this.position++;
                         buffer.append(c);
                     } else {
                         break;
                     }
                     if (!s.needMoreOperator(c)) {
                         break;
                     }
                 }
             }
             if (buffer.length() == 0) {
                 return null;
             }
             ExpressionNode node = new ExpressionNode(buffer.toString());
             if (node.getType() == ExpressionNodeType.Unknown) {
                 throw new ExpressionException(String.format("表达式\"%s\"在位置%s上的字符\"%s\"非法!", this.getExpression(),
                         this.getPosition() - node.getValue().length(), node.getValue()));
             }
             return node;
         }

     }

     /**
      * 解析公式并返回结果的类
      *
      * @项目名称: sunson_pams
      * @类名称: ExpressionEvaluator
      * @类描述:
      * @创建人: 唐泽齐
      * @创建时间: 2017年12月15日 上午9:56:08
      * @修改人: 唐泽齐
      * @修改时间: 2017年12月15日 上午9:56:08
      * @修改备注:
      * @version: 1.0
      */
     public static class ExpressionEvaluator {

         private ExpressionEvaluator() {

         }

         /**
          * 将算术表达式转换为逆波兰表达式
          *
          * @param expression
          *            要计算的表达式,如"1+2+3+4"
          * @return
          */
         private static  List<ExpressionNode> parseExpression(String expression) {
             if (StringUtils.isEmpty(expression)) {
                 return new ArrayList<ExpressionNode>();
             }

             List<ExpressionNode> listOperator = new ArrayList<ExpressionNode>(10);
             Stack<ExpressionNode> stackOperator = new Stack<ExpressionNode>();

             ExpressionParser expParser = new ExpressionParser(expression);
             ExpressionNode beforeExpNode = null; // 前一个节点
             ExpressionNode unitaryNode = null; // 一元操作符
             ExpressionNode expNode;
             // 是否需要操作数
             boolean requireOperand = false;

             while ((expNode = expParser.readNode()) != null) {
                 if ((expNode.getType() == ExpressionNodeType.Numeric)
                         || (expNode.getType() == ExpressionNodeType.String)
                         || (expNode.getType() == ExpressionNodeType.Date)) {
                     // 操作数， 直接加入后缀表达式中
                     if (unitaryNode != null) {
                         // 设置一元操作符节点
                         expNode.setUnitaryNode(unitaryNode);
                         unitaryNode = null;
                     }

                     listOperator.add(expNode);
                     requireOperand = false;
                     continue;
                 } else if (expNode.getType() == ExpressionNodeType.LParentheses) {
                     // 左括号， 直接加入操作符栈
                     stackOperator.push(expNode);
                     continue;
                 } else if (expNode.getType() == ExpressionNodeType.RParentheses) {
                     // 右括号则在操作符栈中反向搜索，直到遇到匹配的左括号为止，将中间的操作符依次加到后缀表达式中。
                     ExpressionNode lpNode = null;
                     while (stackOperator.size() > 0) {
                         lpNode = stackOperator.pop();
                         if (lpNode.getType() == ExpressionNodeType.LParentheses)
                             break;
                         listOperator.add(lpNode);
                     }
                     if (lpNode == null || lpNode.getType() != ExpressionNodeType.LParentheses) {
                         throw new ExpressionException(String.format("在表达式\"%s\"中没有与在位置(%s)上\")\"匹配的\"(%s)\"字符!",expParser.getExpression(), expParser.getPosition()));
                     }
                 } else {
                     if (stackOperator.size() == 0) {
                         // 第一个节点则判断此节点是否是一元操作符"+,-,!,("中的一个,否则其它都非法
                         if (listOperator.size() == 0 && !(expNode.getType() == ExpressionNodeType.LParentheses
                                 || expNode.getType() == ExpressionNodeType.Not)) {
                             // 后缀表达式没有任何数据则判断是否是一元操作数
                             if (ExpressionNode.IsUnitaryNode(expNode.getType())) {
                                 unitaryNode = expNode;
                             } else {
                                 // 丢失操作数
                                 throw new ExpressionException(String.format("表达式\"%s\"在位置(%s)上缺少操作数!",
                                         expParser.getExpression(), expParser.getPosition()));
                             }
                         } else {
                             // 直接压入操作符栈
                             stackOperator.push(expNode);
                         }
                         requireOperand = true; // 下一个节点需要操作数
                         continue;
                     } else {
                         if (requireOperand) {
                             // 如果需要操作数则判断当前的是否是"+","-"号(一元操作符),如果是则继续
                             if (ExpressionNode.IsUnitaryNode(expNode.getType()) && unitaryNode == null) {
                                 unitaryNode = expNode;
                             } else {
                                 // 丢失操作数
                                 throw new ExpressionException(String.format("表达式\"%s\"在位置({1})上缺少操作数!",
                                         expParser.getExpression(), expParser.getPosition()));
                             }
                         } else {
                             // 对前面的所有操作符进行优先级比较
                             do {
                                 // 取得上一次的操作符
                                 beforeExpNode = stackOperator.peek();

                                 // 如果前一个操作符优先级较高，则将前一个操作符加入后缀表达式中
                                 if (beforeExpNode.getType() != ExpressionNodeType.LParentheses
                                         && (beforeExpNode.getPri() - expNode.getPri()) >= 0) {
                                     listOperator.add(stackOperator.pop());
                                 } else {
                                     break;
                                 }

                             } while (stackOperator.size() > 0);

                             // 将操作符压入操作符栈
                             stackOperator.push(expNode);
                             requireOperand = true;
                         }
                     }
                 }
             }

             if (requireOperand) {
                 // 丢失操作数
                 throw new ExpressionException(
                         String.format("表达式\"%s\"在位置({1})上缺少操作数!", expParser.getExpression(), expParser.getPosition()));
             }
             // 清空堆栈
             while (stackOperator.size() > 0) {
                 // 取得操作符
                 beforeExpNode = stackOperator.pop();
                 if (beforeExpNode.getType() == ExpressionNodeType.LParentheses) {
                     throw new ExpressionException(String.format("表达式\"%s\"中括号不匹配,丢失右括号!", expParser.getExpression(),
                             expParser.getPosition()));
                 }
                 listOperator.add(beforeExpNode);
             }

             return listOperator;
         }

         /**
          * 对逆波兰表达式进行计算
          *
          * @param nodes
          * @return
          */
         @SuppressWarnings({ "rawtypes", "unchecked", "incomplete-switch" })
         private static  Object CalcExpression(List<ExpressionNode> nodes) {
             if (nodes == null || nodes.size() == 0)
                 return null;

             if (nodes.size() > 1) {
                 int index = 0;
                 // 储存数据
                 ArrayList values = new ArrayList();
                 while (index < nodes.size()) {
                     ExpressionNode node = nodes.get(index);

                     switch (node.getType()) {
                     // 如果是数字，则将值存入 values 中
                     case Numeric:
                     case String:
                     case Date:
                         values.add(node.getNumeric());
                         index++;
                         break;
                     default:
                         // 二元表达式，需要二个参数， 如果是Not的话，则只要一个参数
                         int paramCount = 2;
                         if (node.getType() == ExpressionNodeType.Not)
                             paramCount = 1;
                         // 计算操作数的值
                         if (values.size() < paramCount) {
                             throw new ExpressionException("缺少操作数");
                         }
                         // 传入参数
                         Object[] data = new Object[paramCount];
                         for (int i = 0; i < paramCount; i++) {
                             data[i] = values.get(index - paramCount + i);
                         }
                         // 将计算结果再存入当前节点
                         node.setNumeric(calculate(node.getType(), data));
                         node.setType(ExpressionNodeType.Numeric);
                         // 将操作数节点删除
                         for (int i = 0; i < paramCount; i++) {
                             nodes.remove(index - i - 1);
                             values.remove(index - i - 1);
                         }
                         index -= paramCount;
                         break;
                     }

                 }
             }

             if (nodes.size() != 1) {
                 throw new ExpressionException("缺少操作符或操作数");
             }
             switch (nodes.get(0).getType()) {
             case Numeric:
                 return nodes.get(0).getNumeric();

             case String:
             case Date:
                 return nodes.get(0).getNumeric().toString().replace("\"", "");
             }
             throw new ExpressionException("缺少操作数");
         }

         /**
          * 计算节点的值
          *
          * @param nodeType
          *            节点的类型
          * @param data
          *            要计算的值,有可能是两位或一位数
          * @return
          */
         @SuppressWarnings("incomplete-switch")
         private static  Object calculate(ExpressionNodeType nodeType, Object[] data) {
             double d1, d2;
             boolean b1, b2;
             Date time1, time2;
             Object obj1 = data[0];
             Object obj2 = data[1];
             String str1 = obj1.toString();
             String str2 = obj2.toString();

             boolean dateflag = ExpressionNode.isDatetime(str1) || ExpressionNode.isDatetime(str2);
             boolean strflag = str1.contains("\"") || str2.contains("\"");
             str1 = str1.replace("\"", "");
             str2 = str2.replace("\"", "");

             switch (nodeType) {
             case Plus:
                 if (!strflag) {
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 + d2);
                 }
                 return new StringBuffer(str1 + str2).toString();
             case Subtract:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return d1 - d2;
             case MultiPly:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return d1 * d2;
             case Divide:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 if (d2 == 0)
                     throw new RuntimeException();
                 return d1 / d2;
             case Power:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return Math.pow((double) d1, (double) d2);
             case Mod:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 if (d2 == 0)
                     throw new RuntimeException();
                 return d1 % d2;
             case BitwiseAnd:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return (int) d1 & (int) d2;
             case BitwiseOr:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return (int) d1 | (int) d2;
             case And:
                 b1 = ConvertToBool(obj1);
                 b2 = ConvertToBool(obj2);
                 return b1 && b2;
             case Or:
                 b1 = ConvertToBool(obj1);
                 b2 = ConvertToBool(obj2);
                 return b1 || b2;
             case Not:
                 b1 = ConvertToBool(obj1);
                 return !b1;
             case Equal:
                 if (!dateflag) {
                     if (strflag) {
                         return str1.equals(str2);
                     }
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 == d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);

                 return (time1.getTime() == time2.getTime());
             case Unequal:
                 if (!dateflag) {
                     if (strflag) {
                         return (!str1.equals(str2));
                     }
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 != d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);

                 return (time1.getTime() != time2.getTime());
             case GT:

                 if (!dateflag) {
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 > d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);
                 return (time1.getTime() > time2.getTime());

             case LT:

                 if (!dateflag) {
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 < d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);
                 return (time1.getTime() < time2.getTime());

             case GTOrEqual:

                 if (!dateflag) {
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 >= d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);
                 return (time1.getTime() >= time2.getTime());

             case LTOrEqual:
                 if (!dateflag) {
                     d1 = ConvertToDecimal(obj1);
                     d2 = ConvertToDecimal(obj2);
                     return (d1 <= d2);
                 }
                 time1 = DateUtils.parseDate(str1);
                 time2 = DateUtils.parseDate(str2);
                 return (time1.getTime() <= time2.getTime());
             case LShift:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return (long) d1 << (int) d2;

             case RShift:
                 d1 = ConvertToDecimal(obj1);
                 d2 = ConvertToDecimal(obj2);
                 return (long) d1 >> (int) d2;
             case Like:
                 if (!strflag) {
                     return false;
                 }
                 return str1.contains(str2);
             case NotLike:
                 if (!strflag) {
                     return false;
                 }
                 return !str1.contains(str2);
             case StartWith:
                 if (!strflag) {
                     return false;
                 }
                 return str1.startsWith(str2);
             case EndWith:
                 if (!strflag) {
                     return false;
                 }
                 return str1.endsWith(str2);
             }

             return 0;
         }

         /**
          * 某个值转换为bool值
          *
          * @param value
          * @return
          */
         private static  Boolean ConvertToBool(Object value) {
             if (value instanceof Boolean) {
                 return (Boolean) value;
             } else {
                 return value != null;
             }
         }

         /**
          * 将某个值转换为decimal值
          *
          * @param value
          * @return
          */
         private static  Double ConvertToDecimal(Object value) {
             if (value instanceof Boolean) {
                 return ((Boolean) value ? 1d : 0d);
             } else {
                 return Double.parseDouble(value.toString());
             }
         }

         /**
          *
          * @param expression
          *            要计算的表达式,如"1+2+3+4"
          * @return 返回计算结果,如果带有逻辑运算符则返回true/false,否则返回数值
          */
         public Object eval(String expression) {
             return CalcExpression(parseExpression(expression));
         }

         public  Object evalThreeOperand(String expression) {
             int index = expression.indexOf("?");
             if (index > -1) {
                 String str = expression.substring(0, index);
                 String str2 = expression.substring(index + 1);
                 index = str2.indexOf(":");

                 if (Boolean.parseBoolean((CalcExpression(parseExpression(str))).toString())) {
                     return eval(str2.substring(0, index));
                 }
                 return eval(str2.substring(index + 1));
             }
             return CalcExpression(parseExpression(expression));
         }

     }

 //    /**
 //     * 测试
 //     *
 //     * @方法名:main
 //     * @参数 @param args
 //     * @返回类型 void
 //     */
 //    public static void main(String[] args) {
 //        String s1 = "1+2+3+4";
 //        System.out.println(ExpressionEvaluator.eval(s1));
 //
 //        String s2 = "(20 - 6) < 3";
 //        System.out.println(ExpressionEvaluator.eval(s2));
 //
 //        String s3 = "(3 + 1) == 4 && 5 > (2 + 3)";
 //        System.out.println(ExpressionEvaluator.eval(s3));
 //
 //        String s4 = "\"hello\" == \"hello\" && 3 != 4";
 //        System.out.println(ExpressionEvaluator.eval(s4));
 //
 //        String s5 = "\"helloworld\" @ \"hello\" &&  \"helloworld\" !@ \"word\" ";
 //        System.out.println(ExpressionEvaluator.eval(s5));
 //
 //    }

 }