Comparando rango en una enumeración

Question

I tienen las siguientes enum que representa un CardRank

public enum CardRank 
{ 
    DEUCE('2'), TREY('3'), FOUR('4'), FIVE('5'), SIX('6'), SEVEN('7'), 
    EIGHT('8'), NINE('9'), TEN('T'), JACK('J'), QUEEN('Q'), KING('K'), 
    ACE('A'); 

    private char symbol; 

    private CardRank(char symbol) 
    { 
     this.symbol = symbol; 
    } 

    public char getSymbol() 
    { 
     return this.symbol; 
    } 
} 

El CardRank está representado en orden ascendente. Necesito comparar los rangos para saber qué rango es mayor que el otro. Puedo usar el operador > con los valores numéricos pero no con los valores de char.

// this will print out TRUE for all numerical values compared 
// but FALSE for the chars 
if (card.getRank().getSymbol() > anotherCard.getRank().getSymbol()) { 
    System.out.println("true"); 
} else { 
    System.out.println("false"); 
} 

¿Alguna idea?

Answer 1

if (card.getRank().compareTo(anotherCard.getRank()) > 0) 

es lo que necesita.

Es posible utilizar alwo el ordinal:

if (card.getRank().ordinal() > anotherCard.getRank().ordinal()) 

enumeraciones tienen un orden natural definido por su ordinal. Y el ordinal de una enumeración se atribuye en función de su posición en la declaración. Así que DEUCE tiene ordinal 0, TREY tiene ordinal 1, etc.

Answer 2

Considere utilizar un comparador para esto. Puede ser una clase interna estática pública si así lo desea:

import java.util.Comparator; 

public enum CardRank implements Comparable<CardRank> { 
    DEUCE('2'), TREY('3'), FOUR('4'), FIVE('5'), SIX('6'), SEVEN('7'), EIGHT('8'), NINE(
     '9'), TEN('T'), JACK('J'), QUEEN('Q'), KING('K'), ACE('A'); 

    private char symbol; 
    private static CardRankComparator cardRankComparator = new CardRankComparator(); 

    private CardRank(char symbol) { 
     this.symbol = symbol; 
    } 

    public char getSymbol() { 
     return this.symbol; 
    } 

    public int compareRank(CardRank otherCardRank) { 
     return cardRankComparator.compare(this, otherCardRank); 
    } 

    // public so that this can be used for sorting if need be 
    public static class CardRankComparator implements Comparator<CardRank> { 
     private static final String RANKS = "23456789TJQKA"; 

     @Override 
     public int compare(CardRank cr1, CardRank cr2) { 
     int rank1 = RANKS.indexOf(String.valueOf(cr1.getSymbol())); 
     int rank2 = RANKS.indexOf(String.valueOf(cr2.getSymbol())); 
     return rank1 - rank2; 
     } 
    } 
} 

Answer 3

Basado en this link y en el @Hovercraft completo de la respuesta anguilas 's, esto es lo que finalmente hice (ejemplo de trabajo: https://repl.it/EIZL/0):

import java.util.Arrays; 
import java.util.Comparator; 
import java.util.TreeSet; 

enum GoldSaints { 

    ARIES(1), 
    GEMINI(3), 
    LEO(5), 

    //oops, almost forgot about... 
    TAURUS(2), 
    CANCER(4), 
    VIRGO(6); 

    /* RANKING CAPABILITIES */ 

    private final int rank; 
    private static TreeSet<GoldSaints> rankedValues = new TreeSet<>(new GoldSaintsComparator()); 

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

    private int getRank() { 
     return this.rank; 
    } 

    private static class GoldSaintsComparator implements Comparator<GoldSaints> { 
     @Override 
     public int compare(GoldSaints gs1, GoldSaints gs2) { 
      return gs1.getRank() - gs2.getRank(); 
     } 
    } 

    public static TreeSet rankedValues() { 
     if (rankedValues.isEmpty()) { 
      rankedValues.addAll(Arrays.asList(GoldSaints.values())); 
     } 

     return rankedValues; 
    } 

    public GoldSaints prev() { 
     return (GoldSaints) GoldSaints.rankedValues().lower(this); 
    } 

    public GoldSaints next() { 
     return (GoldSaints) GoldSaints.rankedValues().higher(this); 
    } 
} 

class Main { 

    public static void main(String[] args) { 

     TreeSet<GoldSaints> rankedValues = GoldSaints.rankedValues(); 

     for (GoldSaints gs : rankedValues) { 
      System.out.println(gs + " after " + gs.prev() + " and before " + gs.next()); 
     } 

     System.out.println("----------------------------------------"); 

     System.out.println(GoldSaints.ARIES.prev()); 
     System.out.println(GoldSaints.ARIES.next()); 
     System.out.println(GoldSaints.VIRGO.prev()); 
     System.out.println(GoldSaints.VIRGO.next()); 
    } 
} 

y la salida es:

ARIES after null and before TAURUS 
TAURUS after ARIES and before GEMINI 
GEMINI after TAURUS and before CANCER 
CANCER after GEMINI and before LEO 
LEO after CANCER and before VIRGO 
VIRGO after LEO and before null 
---------------------------------------- 
null 
TAURUS 
LEO 
null