要解决ANTLR4中从左到右、等优先级进行求值的问题，可以使用ANTLR4中的语法规则和语义动作来实现。

下面是一个示例的ANTLR4语法规则，用于解析简单的四则运算表达式：

grammar Expression;

expression: additiveExpression;

additiveExpression: multiplicativeExpression (('+' | '-') multiplicativeExpression)*;

multiplicativeExpression: unaryExpression (('*' | '/') unaryExpression)*;

unaryExpression: '-' primaryExpression | primaryExpression;

primaryExpression: NUMBER | '(' expression ')';

NUMBER: [0-9]+;

在这个示例中，我们定义了四个语法规则，分别是expression、additiveExpression、multiplicativeExpression和unaryExpression。其中，expression规则是最高优先级的规则，表示整个表达式。additiveExpression规则表示加法或减法运算，multiplicativeExpression规则表示乘法或除法运算，unaryExpression规则表示取负数运算。primaryExpression规则表示表达式中的基本元素，可以是数字或者括号包裹的表达式。

接下来，我们可以在ANTLR4中添加语义动作来实现从左到右、等优先级进行求值的功能。下面是一个简单的示例代码：

import org.antlr.v4.runtime.*;

public class ExpressionEvaluator extends ExpressionBaseListener {
    private int result;

    @Override
    public void exitAdditiveExpression(ExpressionParser.AdditiveExpressionContext ctx) {
        int left = Integer.parseInt(ctx.multiplicativeExpression().getText());
        int right = Integer.parseInt(ctx.additiveExpression().getText());

        if (ctx.getChild(1).getText().equals("+")) {
            result = left + right;
        } else {
            result = left - right;
        }
    }

    @Override
    public void exitMultiplicativeExpression(ExpressionParser.MultiplicativeExpressionContext ctx) {
        int left = Integer.parseInt(ctx.unaryExpression().getText());
        int right = Integer.parseInt(ctx.multiplicativeExpression().getText());

        if (ctx.getChild(1).getText().equals("*")) {
            result = left * right;
        } else {
            result = left / right;
        }
    }

    @Override
    public void exitUnaryExpression(ExpressionParser.UnaryExpressionContext ctx) {
        if (ctx.getChild(0).getText().equals("-")) {
            result = -Integer.parseInt(ctx.primaryExpression().getText());
        } else {
            result = Integer.parseInt(ctx.primaryExpression().getText());
        }
    }

    @Override
    public void exitPrimaryExpression(ExpressionParser.PrimaryExpressionContext ctx) {
        if (ctx.NUMBER() != null) {
            result = Integer.parseInt(ctx.NUMBER().getText());
        } else {
            result = Integer.parseInt(ctx.expression().getText());
        }
    }

    public int getResult() {
        return result;
    }

    public static void main(String[] args) throws Exception {
        String expression = "2 + 3 * 4 - 5 / 2";

        ANTLRInputStream input = new ANTLRInputStream(expression);
        ExpressionLexer lexer = new ExpressionLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        ExpressionParser parser = new ExpressionParser(tokens);

        ExpressionParser.ExpressionContext context = parser.expression();
        ExpressionEvaluator evaluator = new ExpressionEvaluator();
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(evaluator, context);

        int result = evaluator.getResult();
        System.out.println(result);
    }
}

在这个示例代码中，我们创建了一个ExpressionEvaluator类，继承了ANTLR4生成的ExpressionBaseListener类，并重写了其中的exitXXX()方法。在这些方法中，我们根据不同的运算符和操作数，计算出对应的结果，并保存到result变量中。

在main()方法中，我们首先创建ANTLRInputStream、ExpressionLexer、CommonTokenStream和ExpressionParser等ANTLR4的必要实例。然后，我们使用ANTLR4生成的expression规则来解析输入的表达式，并使用ParseTreeWalker类来遍历语法树，调用ExpressionEvaluator类中的相应的方法，计算出表达式的结果。最后，我们将结果打印到控制台上。

如果我们运行这个示例代码，将会得到输出结果：9，表示表达式"2 + 3 * 4 - 5 / 2"的结果为9。

这就是一个使用