java enum 类可以实现“Comparable”接口吗？

Question

Seems that enum class already has a final compareTo function, which cannnot be overriden. But my requirement is to customize an enum class like this:

enum Operator {
    Add('+', 1),
    Sub('-', 1),
    Mul('*', 2),
    Div('/', 2);

    private char op;
    private int priority;
    private Operator(char _op, int _priority) {
        op = _op;
        priority = _priority;
    }
}

Then I wish to have it implements Comparable interface to have the ability to compare among Add , Sub , Mul , etc. But seems I cannot use implements Comparable<Operator> as described above, javac gives compilation error:

Redundant superinterface Comparable<Operator> for the type Operator, already defined by Enum<Operator>Java(16777547)

So how to achieve my goal? Thanks.

Answer 1

您始终可以声明Comparator.comparingInt(Operator::getPriority)并使用它来比较您的运算符。

Answer 2

Then I wish to have it implements Comparable interface to have the ability to compare among Add , Sub , Mul , etc

You can't change the implementation of Comparable in your enum .

Every enum implicitly implements Comparable because its parent java.lang.Enum has implemented this interface and method compareTo() is marked with final modifier, ie you can't override it.

Here is the quote from the Javadoc :

public final int compareTo(E o)

Compares this enum with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. Enum constants are only comparable to other enum constants of the same enum type. The natural order implemented by this method is the order in which the constants are declared .

You can define a Comparator implemented based on the priority property as public static field.

enum Operator {
    MUL('*', 1),
    DIV('/', 1),
    ADD('+', 2),
    SUB('-', 2);
    
    public static final Comparator<Operator> BY_PRIORITY = 
        Comparator.comparing(Operator::getPriority);
    
    private char op;
    private int priority;
    
    Operator(char op, int priority) {
        this.op = op;
        this.priority = priority;
    }
    
    public char getOp() {
        return op;
    }
    
    public int getPriority() {
        return priority;
    }
}

If you need the order to reflect the standard order of arithmetic operations: Multiplication/Division comes before Addition/Subtraction , then the value of priority of the MUL and DIV needs to be lower than the value of priority of ADD and SUB .

The names of enum-member Add , Sub , etc., as well as names of constructor parameters _op , _priority in your code are not aligned with the Java naming convention .

Answer 3

Ok: first, as you mentioned in your question, the enum implicitly inherits from java.lang.Enum which has a final compare method, so you cannot override it. You could use a byte code manipulation Framework wo intercept the call, but that is more complicated that usefull.

So to work around that, just put your own compare function under a different name

 public int comparePrio(Operator other) {
        return Integer.compare(this.priority, other.priority);
    }

This should serve your purpose in most cases.

If you really need an instance of Comparable, you can make use of the fact, that the Compairable Interface has only one method, so you can make one using a method-lambda like so:

public Comparable<Operator> asPriorityComparable(){
        return this::comparePrio;
    }

A small test shows that this is working as expected:

for(var a : Operator.values()) {
            for(var b : Operator.values()) {
                System.out.printf("a=%-5s b=%-5s compair=%5d compairPrio=%5d%n", a.name(),b.name(),
                        a.compareTo(b),
                        a.asPriorityComparable().compareTo(b));
            }
        }

Produces output

a=Add   b=Add   compair=    0 compairPrio=    0
a=Add   b=Sub   compair=   -1 compairPrio=    0
a=Add   b=Mul   compair=   -2 compairPrio=   -1
a=Add   b=Div   compair=   -3 compairPrio=   -1
a=Sub   b=Add   compair=    1 compairPrio=    0
a=Sub   b=Sub   compair=    0 compairPrio=    0
a=Sub   b=Mul   compair=   -1 compairPrio=   -1
a=Sub   b=Div   compair=   -2 compairPrio=   -1
a=Mul   b=Add   compair=    2 compairPrio=    1
a=Mul   b=Sub   compair=    1 compairPrio=    1
a=Mul   b=Mul   compair=    0 compairPrio=    0
a=Mul   b=Div   compair=   -1 compairPrio=    0
a=Div   b=Add   compair=    3 compairPrio=    1
a=Div   b=Sub   compair=    2 compairPrio=    1
a=Div   b=Mul   compair=    1 compairPrio=    0
a=Div   b=Div   compair=    0 compairPrio=    0

Full enum class is

public enum Operator{
    Add('+', 1),
    Sub('-', 1),
    Mul('*', 2),
    Div('/', 2);

    private char op;
    private int priority;
    private Operator(char _op, int _priority) {
        op = _op;
        priority = _priority;
    }
    
    public int comparePrio(Operator other) {
        return Integer.compare(this.priority, other.priority);
    }
    
    public Comparable<Operator> asPriorityComparable(){
        return this::comparePrio;
    }
   
}

Answer 4

Why compare method is final

As you noted correctly, you cannot override the compare function of the enum class, because it is final.

The method is final, because of the semantics of an enum (Enumerated). It represent a number of values that could be completely substituted with there "ordnial" value. Actually, most applications of enum work with the ordinal value only. The names are just to make it easier to handle them.

Thus, the natural sort order (that is defined by the comparable interface) is to order by Ordinals and not on some field values. Actually, most enums don't have fields at all.

So if you find your self in a spot where you need to order enums based on something other than there ordinals, you should probably reconsider using enums ...

What you could do:

I'm going out an a limb here, since you didn't exactly specify what your final goal here is, but in most cases someone tries to implement Comparable, they try to sort a List or Array.

If that is the case, you could just work around that issue using a Comparator. Both the Array.sort, Collections.sort and Stream.sorted method have a overload that accepts a Comperator to define the sort order.

So what you could do is add a method to your enum like

 public static int comparePrio(Operator first, Operator second) {
        return Integer.compare(first.priority, second.priority);
    }

and then call the sort method like this:

Collections.sort(myListOfValues, Operator::comparePrio);

(Code for Arrays and Streams is analog)

Warning: The code is not null save. If null is a possibility, you need to add additional null checks in your comparePrio method