Question

在后缀计算器中添加一个前缀，需要检查一个运算符的优先级是否比另一个运算符的优先级低。这是我到目前为止的内容：

public enum Operators {

    ADD('+', 2), SUBTRACT('-', 2), MULTIPLY('*', 4), DIVIDE('/', 4);

    private char operator;
    private int precedence;

    Operators(char operator, int precedence) {
        this.operator = operator;
        this.precedence = precedence;
    }

    public char getOperator() {
        return operator;
    }

    public int getPrecedence() {
        return precedence;
    }
}

private static boolean isOperator(char c) {
    return c == Operators.ADD.getOperator() || c == Operators.SUBTRACT.getOperator()
            || c == Operators.MULTIPLY.getOperator() || c == Operators.DIVIDE.getOperator();
}

private static boolean isLowerPrecedence(char ch1, char ch2) {
    // STUCK HERE
}

我尝试了多种方法来检查传入的char的优先级，但无济于事。有没有一种简单的方法可以比较一个枚举的两个值？我需要创建一个循环吗？

Answer 1

如果您有一种将“运算符” char转换为枚举值的方法，则比较起来很容易。

例如：

static Operators getOperatorForChar(char op) {
    for(Operators val: values())
        if(op == val.operator)
            return val; //return enum type

    return null;
}

然后您可以使用以下方法实现您的方法：

private static boolean isLowerPrecedence(char ch1, char ch2) {

    //assuming intention is to compare precedence of ch1 to that of ch2
    return getOperatorForChar(ch1).precedence < getOperatorForChar(ch2).precedence;
}

Answer 2

或者，您可以像这样比较优先级：

private static boolean isLowerPrecedence(Operators operatorFirst, Operators operatorSecond) {
    if(operatorFirst.getPrecedence() < operatorSecond.getPrecedence()){
        return true;
    } else {
        return false;
    }
}

当然，它可以写为：

return operatorFirst.getPrecedence() < operatorSecond.getPrecedence();

Answer 3

您可以循环枚举值以匹配正确的运算符并比较其优先级：

private static boolean isLowerPrecedence(char ch1, char ch2) {
    Integer first = null;
    Integer second = null;
    for (Operators o: Operators.values()) {
        if (o.getOperator() == ch1) {
            first = o.getPrecedence();
        }
        if (o.getOperator() == ch2) {
            second = o.getPrecedence();
        }
    }
    return (first != null && second !=null && first < second);
}

在找不到操作员时返回boolean可能会造成混淆。我建议您在这种情况下抛出异常。

...
if (first == null || second ==null) throw new Exception("Operator not found.");
return first < second;

Answer 4

通过查看this question，您可以通过Comparable和Comparator接口找出Java处理类型的比较。

当然，它们是指比这种情况更复杂的情况，但是我认为您应该将它们考虑在内，以便可以看到处理标准Java库提供的一组排序算法的正确方法。 / p>

由于您无法覆盖默认的Enum的compareTo（声明为 final ），因此您可以这样实现自己的Comparator：

public class OperatorsComparator implements Comparator<Operators> {

    @Override
    public int compare(Operators o1, Operators o2) {
        return o1.getPrecedence() - o2.getPrecedence();
    }
}

然后，您将需要某种方式从您输入的Operators中找到正确的char值：

private static Operators findOperator(char c){
    for(Operators op : Operators.values()){
        if(op.getOperator() == c)
            return op;
    }
    return null;
}

通过在两个优先级和上一个Operators查找器之间进行减法运算，可以实现isLowerPrecedence方法，如下所示：

public static boolean isLowerPrecedence(char c1, char c2) throws Exception {
    Operators o1 = findOperator(c1);
    Operators o2 = findOperator(c2);
    if(o1 == null || o2 == null)
        throw new Exception("Invalid operators");

    return new OperatorsComparator().compare(o1, o2) <= 0;
}

通过以这种方式比较优先级，您将获得o1被标记为较低优先级的信息，即使它的优先级与o2相同，也是默认行为。当心您尝试用作运算符的字符，因为如果出现任何问题，您将需要捕获Exception

执行示例：

System.out.println(isLowerPrecedence('+', '-'));
System.out.println(isLowerPrecedence('+', '*'));
System.out.println(isLowerPrecedence('/', '-'));
System.out.println(isLowerPrecedence('/', '*'));
System.out.println(isLowerPrecedence('*', '-'));

打印这些消息：

true
true
false
true
false

Answer 5

您可以使用this answer of mine中提出的EnumLookup帮助类（那里的EnumLookup的源代码）。

稍稍重新命名您的Operators枚举（我强烈建议使用单个类名），您将得到：

public enum Operator {

    ADD('+', 2), SUBTRACT('-', 2), MULTIPLY('*', 4), DIVIDE('/', 4);

    private static final EnumLookup<Operator, Character> BY_OPERATOR_CHAR
            = EnumLookup.of(Operator.class, Operator::getOperatorChar, "operator char");

    private final char operatorChar;
    private final int precedence;

    Operator(char operatorChar, int precedence) {
        this.operatorChar = operatorChar;
        this.precedence = precedence;
    }

    public char getOperatorChar() {
        return operatorChar;
    }

    public int getPrecedence() {
        return precedence;
    }

    public static EnumLookup<Operator, Character> byOperatorChar() {
        return BY_OPERATOR_CHAR;
    }
}

private static boolean isOperator(char c) {
    return Operator.byOperatorChar().contains(c);
}

private static boolean isLowerPrecedence(char ch1, char ch2) {
    return Operator.byOperatorChar().get(ch1).getPrecedence() < Operator.byOperatorChar().get(ch2).getPrecedence();
}

此方法的主要缺点是您的char会boxed进入Character，但是除非性能对您的应用程序至关重要，否则我不会担心（可读性应该是更重要）。

比较枚举的值

5 个答案: