Confrontando rango un'enumerazione

Question

Ho il seguente enumerazione che rappresenta 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; 
    } 
} 

Il CardRank è rappresentato in ordine crescente. Ho bisogno di confrontare i ranghi per sapere quale grado è maggiore dell'altro. Posso usare l'operatore > con i valori numerici ma non con i valori 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"); 
} 

Qualche idea?

Answer 1

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

è quello che ti serve.

Si può ALWO utilizzare l'ordinale:

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

enumerazioni hanno un ordinamento naturale definito dal loro ordinale. E l'ordinale di un enum è attribuito in base alla sua posizione nella dichiarazione. Quindi DEUCE ha ordinale 0, TREY ha ordinale 1, ecc.

Answer 2

Considerare di utilizzare un comparatore per questo. Può essere una classe interna public static se si desidera:

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

Ha sede in this link e nel @Hovercraft completa di risposta Eels s', questo è quello che ho finalmente fatto (esempio di funzionamento: 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()); 
    } 
} 

e l'uscita è:

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