用java解析字符串

我想以字符串的形式解析java中的SQL queriesequal、greater、less-That和运算符。我有一节课

class QueryBuilder()
{
 Expression parse(String query)
 {
  String[] token = query.split("\\s+");
  String field = token[0];
  String value = token[1];
  String operator = token[2];

  switch (operator)
  case "EQ" (equals):
   return new BinaryExpression(field, Operator.EQ, value);
  case "LT" (less than):
   return new BinaryExpression(field, Operator.LT, value);
  case "GT" (greater than):
   return new BinaryExpression(field, Operator.GT, value);
  default (In condition):
   return new BinaryExpression(field, Operator.IN, value);
 }
}
}

//当我叫这个班的时候：

QueryBuilder ob= new QueryBuilder();
ob.parse("eid EQ 2"); ///This will give results with eid =2 records

Similarly ob.parse("eid GT 2"); //This will give results eid>2 records.

Now I want to add Logical Expression like AND:

For Ex: ob.parse("eid EQ 2 AND deptname foo");// it should give both eid=2 AND 

deptname="foo"  

有人能帮我用和条件解析字符串吗

检查inputString查询是否包含和。 如果包含AND，则可以拆分AND 然后，调用源逻辑递归地将拆分项放入输入。 最后，递归地合并每个分割输入的结果。

---

现在有两类操作符。考虑使用递归下降。< /P> 您将拥有以下规则：

表达式：：=二进制表达式布尔运算符二进制表达式*

布尔运算符：：=或|和

BinaryExpression:：=名称BinaryOperator值

二进制运算符：：=EQ | LT | GT | IN

下面是一个非常简单的实现：

public class QueryBuilder {
    final String[] token;
    int i = 0;

    public static Expression parse(String query) {
        return new QueryBuilder(query).expression();
    }

    private QueryBuilder(String query) {
        token = query.split("\\s+");
    }

    private Expression expression() {
        Expression expr = binaryExpression();
        while (i < token.length) {
            String operator = token[i++];
            Expression right = binaryExpression();
            switch (operator) {
                case "AND":
                    expr = new BooleanExpression(expr, Operator.AND, right);
                    break;
                default:
                    expr = new BooleanExpression(expr, Operator.OR, right);
                    break;
            }
        }
        return expr;
    }

    private Expression binaryExpression() {
        String field = token[i++];
        String operator = token[i++];
        String value = token[i++];

        switch (operator) {
            case "EQ":
                return new BinaryExpression(field, Operator.EQ, value);
            case "LT":
                return new BinaryExpression(field, Operator.LT, value);
            case "GT":
                return new BinaryExpression(field, Operator.GT, value);
            default:
                return new BinaryExpression(field, Operator.IN, value);
        }
    }
}

更新

我已经为测试定义了这些类：

abstract class Expression {
}

enum Operator {
    EQ, LT, GT, IN, AND, OR;
}

class BinaryExpression extends Expression {

    private final String field;
    private final Operator op;
    private final String value;

    BinaryExpression(String field, Operator op, String value) {
        this.field = field;
        this.op = op;
        this.value = value;
    }

    @Override
    public String toString() {
        return "(" + field + " " + op + " " + value + ")";
    }
}

class BooleanExpression extends Expression {

    private final Expression left;
    private final Operator op;
    private final Expression right;

    BooleanExpression(Expression left, Operator op, Expression right) {
        this.left = left;
        this.op = op;
        this.right = right;
    }

    @Override
    public String toString() {
        return "(" + left + " " + op + " " + right + ")";
    }
}

---

现在有两类操作符。考虑使用递归下降。抱歉，我忘记了中断，并且表达式是从右到左构建的：谢谢你的响应，它对我起作用。请你解释一下代码，从右到左的部分好吗？

abstract class Expression {
}

enum Operator {
    EQ, LT, GT, IN, AND, OR;
}

class BinaryExpression extends Expression {

    private final String field;
    private final Operator op;
    private final String value;

    BinaryExpression(String field, Operator op, String value) {
        this.field = field;
        this.op = op;
        this.value = value;
    }

    @Override
    public String toString() {
        return "(" + field + " " + op + " " + value + ")";
    }
}

class BooleanExpression extends Expression {

    private final Expression left;
    private final Operator op;
    private final Expression right;

    BooleanExpression(Expression left, Operator op, Expression right) {
        this.left = left;
        this.op = op;
        this.right = right;
    }

    @Override
    public String toString() {
        return "(" + left + " " + op + " " + right + ")";
    }
}