एक enum

Question

मैं है निम्नलिखित enum जो एक 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; 
    } 
} 

CardRank का प्रतिनिधित्व करता है आरोही क्रम में प्रतिनिधित्व किया है में रैंक की तुलना करना। मुझे यह जानने के लिए रैंक की तुलना करने की आवश्यकता है कि कौन सा रैंक दूसरे से बड़ा है। मैं > ऑपरेटर का उपयोग संख्यात्मक मानों के साथ कर सकता हूं लेकिन चार मानों के साथ नहीं।

// 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"); 
} 

कोई विचार?

Answer 1

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

तुम क्या जरूरत है।

आप alwo क्रमसूचक का उपयोग हो सकता है:

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

Enums एक प्राकृतिक आदेश उनके क्रमसूचक द्वारा परिभाषित किया गया है। और घोषणा में अपनी स्थिति के आधार पर एक enum के ordinal जिम्मेदार है। इसलिए DEUCE में औपचारिक 0 है, TREY क्रमिक 1 है, आदि

Answer 2

इसके लिए एक तुलनाकर्ता का उपयोग करने पर विचार करें। यदि आप चाहें यह एक सार्वजनिक स्थैतिक भीतरी वर्ग हो सकता है:

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

this link में और मछली के जवाब का @Hovercraft पूर्ण में आधार पर, यह है कि क्या मैं अंत में (: 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()); 
    } 
} 

और उत्पादन होता है:

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