Отсортировать poker hand

public class Card implements Comparable<Card> {
 
    private final Rank rank;
    private final Suit suit;
 
    public Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }
 
    @Override
    public String toString() {
        return rank.getShortRepresentative()
                + Character.toString(suit.getShortRepresentative());
    }
 
    public String toLongString() {
        return rank.getLongRepresentative() + " of " + suit.getLongRepresentative();
    }
 
    public Rank getRank() {
        return rank;
    }
 
    public Suit getSuit() {
        return suit;
    }
 
    public int getValue() {
        return rank.getValue();
    }
 
    @Override
    public int compareTo(Card card) {
        return Comparator.comparing(Card::getRank)
                .compare(this, card);
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Card)) return false;
        Card card = (Card) o;
        return getRank() == card.getRank() &&
                getSuit() == card.getSuit();
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getRank(), getSuit());
    }
 
}

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 
public enum Rank {
    TWO(2, '2', "Two"), THREE(3, '3', "Three"), FOUR(4, '4', "Four"),
    FIVE(5, '5', "Five"), SIX(6, '6', "Six"), SEVEN(7, '7', "Seven"),
    EIGHT(8, '8', "Eight"), NINE(9, '9', "Nine"), TEN(10, 'T', "Ten"),
    JACK(11, 'J', "Jack"), QUEEN(12, 'Q', "Queen"), KING(13, 'K', "King"),
    ACE(14, 'A', "Ace");
 
    private int value;
    private char shortRepresentative;
    private String longRepresentative;
 
    private static final List<Rank> VALUES =
            Collections.unmodifiableList(Arrays.asList(values()));
    private static final int SIZE = VALUES.size();
    private static final Random RANDOM = new Random();
 
    Rank(int value, char shortRepresentative, String longRepresentative) {
        this.value = value;
        this.shortRepresentative = shortRepresentative;
        this.longRepresentative = longRepresentative;
    }
 
    public int getValue() {
        return value;
    }
 
    public char getShortRepresentative() {
        return shortRepresentative;
    }
 
    public String getLongRepresentative() {
        return longRepresentative;
    }
 
    public static Rank getRankFromChar(char c) {
        for (Rank r : Rank.values()) {
            if (c == r.getShortRepresentative()) {
                return r;
            }
        }
        return null;
    }
 
    public static Rank getRandomRank() {
        return VALUES.get(RANDOM.nextInt(SIZE));
    }
 
}

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 
public enum Suit {
    HEARTS('H', "Hearts", 0),
    SPADES('S', "Spades", 1),
    DIAMONDS('D', "Diamonds", 2),
    CLUBS('C', "Clubs", 3);
 
    private char shortRepresentative;
    private String longRepresentative;
    private int sortingIndex;
 
    private static final List<Suit> VALUES =
            Collections.unmodifiableList(Arrays.asList(values()));
    private static final int SIZE = VALUES.size();
    private static final Random RANDOM = new Random();
 
    Suit(char shortRepresentative, String longRepresentative, int sortingIdx) {
        this.shortRepresentative = shortRepresentative;
        this.longRepresentative = longRepresentative;
        this.sortingIndex = sortingIdx;
    }
 
    public void setSortingIndex(int sortingIndex) {
        this.sortingIndex = sortingIndex;
    }
 
    public char getShortRepresentative() {
        return shortRepresentative;
    }
 
    public String getLongRepresentative() {
        return longRepresentative;
    }
 
    public int getSortingIndex() {
        return sortingIndex;
    }
 
    public static Suit getSuitFromChar(char c) {
        for (Suit suit : Suit.values()) {
            if (c == suit.getShortRepresentative()) {
                return suit;
            }
        }
        return null;
    }
 
    public static Suit getRandomSuit() {
        return VALUES.get(RANDOM.nextInt(SIZE));
    }
}

import java.util.Comparator;
 
public class RankComparator implements Comparator<Card> {
    @Override
    public int compare(Card card1, Card card2) {
        if (card1.getRank() == card2.getRank()) {
            return card1.getSuit().compareTo(card2.getSuit());
        }
        return card1.getRank().compareTo(card2.getRank());
 
    }
}

import java.util.Comparator;
 
public class SuitComparator implements Comparator<Card> {
    @Override
    public int compare(Card card1, Card card2) {
        if (card1.getSuit() == card2.getSuit()) {
            return card1.getRank().compareTo(card2.getRank());
        }
        return card1.getSuit().compareTo(card2.getSuit());
    }
}

import java.util.*;
 
public class Main {
 
    private static List<Card> cards = getRandomHand();
    private static RankComparator rankComparator = new RankComparator();
    private static SuitComparator suitComparator = new SuitComparator();
 
    public static void main(String[] args) {
 
        System.out.println("Random hand, but still not sorted = " + cards.toString());
        cards.sort(rankComparator);
        cards.sort(Collections.reverseOrder());
//        cards.sort(suitComparator);
        System.out.println("Hand sorted by Rank = " + cards.toString());
    }
 
    private static List<Card> getRandomHand() {
        int sizeOfOmahaHand = 4;
        Set<Card> cardsSet = new HashSet<>();
        while (cardsSet.size() != sizeOfOmahaHand) {
            cardsSet.add(new Card(Rank.getRandomRank(), Suit.getRandomSuit()));
        }
        return new ArrayList<>(cardsSet);
    }
 
}