Geek asks and answers

Comparison of ranks in the listing

I have the following listing, which is 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;
    }
}

CardRankappears in ascending order. I need to compare ranks to find out which rank is greater than the other. I can use the operator >with numeric values, but not with char values.

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

Any ideas?

+5
source share
3 answers
if (card.getRank().compareTo(anotherCard.getRank()) > 0)

- This is what you need.

You can use the serial number:

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

Enumerations have a natural order, determined by their order. And the serial number of the transfer is assigned based on its position in the declaration. So DEUCE has serial number 0, TREY has serial number 1, etc.

+14
source

. , :

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;
      }
   }
}
+1

Based on this link and in @Hovercraft Full of Eels answer this is what I finally did (working example: 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());
    }
}

And the result:

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
0
source

More articles:


All Articles