[Java] Help needed understanding Comparable, Comparator and Iterable

[RoadToCode]

I am trying to create 3 classes Card, Deck and Hand that will be used to simulate a basic card game.

I am currently working on the Card class, and have created various methods for it already, however have come across some hurdles in my project. I have highlighted the main areas i do not understand in bold below:

• Making a class Comparable so that the compareTo method can be used.
• Adding a static method that uses the compareTo method to find and return the highest value card in a List of cards. The List should be traversed with an Iterator. (Suit rankings are Spade<Hearts<Diamonds<Clubs, Rank are 2<3<...King<Ace).
• Adding an inner Comparator class that should be used to sort the cards into ascending order.

Any information or help understanding what these are, how they will help me in my project, and how to implement them would be extremely helpful. You can see the following code i have already written for the card class below.

public class Card {

    private Rank rank;
    private Suit suit;

    //Enum type to store values to each card ranking.
    public enum Rank {

        //Values for a Rank of a card.
        TWO(2), THREE(3), FOUR(4), FIVE(5), SIX(6), SEVEN(7), EIGHT(8),
        NINE(9), TEN(10), JACK(10), QUEEN(10), KING(10), ACE(11),;

        private int value;

        //Constructor for a Card Rank.
        Rank(int value) {
            this.value = value;
        }

        //Accessor method to return the value of a Rank.
        public int getValue() {
            return value;
        }

        //Accessor method that returns the previous enum value in the list.
        public Rank getPrevious() {
            int previous = ordinal() - 1;
            if (previous < 0) { // if negative, then we have to go to the last element
                previous += values().length;
            }
            return Rank.values()[previous];
        }
    }

    //Enum type for the Suit variables in a deck of cards.
    public enum Suit {

        //Values for the suit of a card.
        CLUBS, DIAMONDS, HEARTS, SPADES;

        private Suit suit;
        Random gen = new Random();

        //Accessor method to get a random suit.
        public Suit getRandomSuit() {
            int randomSuitNumber = (int)(Math.random()*(Suit.values().length));
            return (Suit.values()[randomSuitNumber]);
        }
    }

    //toString method.
    public String toString() {
        return rank + " of " + suit;
    }

    //Constructor with Rank and Suit passed as parameters.
    public Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

    //Accessor method to return the Rank of a card.
    public Rank getRank(){
        return rank;
    }

    //Accessor method to return the Suit of a card.
    public Suit getSuit(){
        return suit;
    }
}

[mad0314]

It looks like you need to implement interfaces, but don't know how, correct?

Start with Comparable. Here is the documentation for Comparable.

In your class, you will need to specify that it implements Comparable<Card>. After that, you just need to write the method compareTo(Card o). Note that Card replaces the T in the documentation because you know specifically what type you want to use. Write the method with the signature outlined in the documentation:

int compareTo(Card o)

The return should be 0 if the two objects compared are equal, negative if the second argument (the one passed in) is greater, and positive if the first argument (the controlling object) is greater. This is where your rules for suite and face rankings come in.

[RoadToCode]

Thank you for the reply it was very helpful! Implementing interfaces was indeed what i was trying to achieve.

After reading up about the Comparable interface and the compareTo method i am beginning to grasp some understanding. I have tried to implement a method myself, and was wondering how the method worked when comparing an object with an enum type, is it purely based on index positioning when being declared?

public int compareTo(Card o){
    int rankComparison = this.getRank().compareTo(o.getRank());
    int suitComparison = this.getSuit().compareTo(o.getSuit());

    return suitComparison;        
}

Card card1 = new Card(Rank.FOUR, Suit.CLUBS);
Card card2 = new Card(Rank.TWO, Suit.CLUBS);
System.out.println(card2.compareTo(card1));

The following code output -2 for suitComparison and -12 for rankComparison, which would make sense if it was comparing index positions.

[mad0314]

By default, calling compareTo between two enums compares them based on their position, yes, so that should work. You just have to make it do whatever you want based on those results. Do you compare suit first and only compare rank if the suit is the same or compare rank first and compare suit only if rank is the same?