Sorting enums in java

Consider the below code:
I have defined a simple enum:

enum Rank {
 RANK1, RANK2, RANK3
}

Next is the main method.Here I have added the enum entries to a TreeSet instance.

public class TestEnum {

 public static void main(String[] args) {
  TreeSet<Rank> ranks = new TreeSet<Rank>();
  ranks.addAll(Arrays.asList(Rank.values()));
  for (Rank rank : ranks) {
   System.out.println(rank);
  }
 }

}

I would have expected the code to crash at runtime with an exception that goes:

Exception in thread "main" java.lang.ClassCastException:Rank cannot be cast 
to java.lang.Comparable

But on running the same:

RANK1
RANK2
RANK3

This wasn't what I was expecting. For I did not provide any Comparable implementation. TreeSet expects the items to implement comparable so as to successfully sort the items. I looked into the source code of the Enum class.

/**
* This is the common base class of all Java language enumeration types.
*
*/
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {

Enum's base class implements Comparable. So all enums created have the compareTo method as a part of its API.

        /**
  * 
  * 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.
  */

 public final int compareTo(E o) {
  Enum other = (Enum) o;
  Enum self = this;
  if (self.getClass() != other.getClass() && // optimization
    self.getDeclaringClass() != other.getDeclaringClass())
   throw new ClassCastException();
  return self.ordinal - other.ordinal;
 }

The code compares the ordinal value of the enum instances. Now what is this ordinal property?
The ordinal is one of the only two instance variable found in the enum class:

private final int ordinal;
private final String name;

Based on the documentation the ordinal of an enumeration constant is its position in its enum declaration, where the initial constant is assigned an ordinal of zero.
Accordingly I modified the for loop slightly:

for (Rank rank : ranks) {
 System.out.println(rank + " " + rank.ordinal());
}

The outputs is:

RANK1 0
RANK2 1
RANK3 2

As seen the ordinal is equivalent to the position of each enum in the declaration. So with all enums we have a guaranteed sorting technique available.

The problem with this approach is that if we have some logic that depends on the sort sequence of our enums, than that code will break every time somebody changes the sequence of elements in the enum or adds/removes an entry.
In such cases it is best to override the method - That however will fail at compilation !! The compareTo method that we saw earlier is marked final. So the only option here is to provide a custom comparator. Here I have modified the Rank class to have a rank property that is used to decide the sort order

enum Rank {
 RANK1(3), RANK2(2), RANK3(1);
 
 private final int rank;

 private Rank(int rank) {
  this.rank = rank;
 }

 public int getRank() {
  return rank;
 }
}

The custom Comparator uses the same property too:

class RankComparator implements Comparator<Rank> {

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

On running the test code:

public class TestEnum {

 public static void main(String[] args) {
  final List<Rank> rankList = Arrays.asList(Rank.values());
  
  TreeSet<Rank> ranks = new TreeSet<Rank>();
  ranks.addAll(rankList);

  System.out.println("--- Using the default sorting ---");
  for (Rank rank : ranks) {
   System.out.println(rank);
  }

  ranks = new TreeSet<Rank>(new RankComparator());
  ranks.addAll(rankList);
  
  System.out.println("--- Using the business rules based sorting ---");
  for (Rank rank : ranks) {
   System.out.println(rank);
  }
 }
}

The output is as below:

--- Using the default sorting ---
RANK1
RANK2
RANK3
--- Using the business rules based sorting ---
RANK3
RANK2
RANK1

As seen the two results generated a different sort order. Using our custom comparator in code will ensure that any modifications in the enum declarations does not break our sorting mechanism.