Java 如何按（A-K-Q-J-T）的降序排列扑克卡字母？

我试图对一系列已排序的扑克牌进行排序，但无法找到一种方法来确保附加到套装上的排名字母的顺序 （A-K-Q-J-T），例如，我的输出显示HT（heartten）比HJ（heartjoker）大，而它应该是相反的

private void sort2D (String [][] twoD)
    {
        // to compile sorted array
        ArrayList<String> toCompileSorted = new ArrayList<String> ();

        for (int row = 0; row < twoD.length; row++)
        {
            String [] sorted2D = new String [MAXC]; // MAXC = 13
            for (int column = 0; column < twoD[row].length; column++)
            {
                sorted2D [column] = twoD [row][column];
            }
            // 2d array becomes ascending only row by row, not everything
            Arrays.sort (sorted2D);
            // make sure it goes by A-K-Q-J-T ???
            // array split according to letter ranks ??

            for (String s : sorted2D)
            {
                toCompileSorted.add (s);
            }
        }
        // put back into 2d array
        int i = 0;
        for (int row = 0; row < twoD.length; row++)
        {
            for (int column = 0; column < twoD[row].length; column++)
            {
                    twoD [row][column] = toCompileSorted.get(i);
                    i++;
            }
        }
    }

这是我的结果（忽略每行下面的数字），在第一行， CJ（club joker）大于CT（club ten），但输出显示相反，

---

其他行也会发生同样的情况。

快速解决方案

制作一个自定义比较器

public class CardComperator implements Comparator<String> {
    private static final Map<Character, Integer> cMap = new HashMap<>();
    private static final Map<Character, Integer> sMap = new HashMap<>();

    static {
        sMap.put('C', 1);
        sMap.put('D', 2);
        sMap.put('H', 3);
        sMap.put('S', 4);

        cMap.put('A', 1);
        cMap.put('K', 2);
        cMap.put('Q', 3);
        cMap.put('J', 4);
        cMap.put('T', 5);
        // so on
    }

    @Override
    public int compare (String p1, String p2) {
        int r1 = sMap.get(p1.charAt(0)) * 100 + cMap.get(p1.charAt(1));
        int r2 = sMap.get(p2.charAt(0)) * 100 + cMap.get(p2.charAt(1));
        return r1 - r2;
    }
}

更好的解决方案

以下是我在第一份工作的面试前任务中应用的解决方案

List<Card> mCards = ...
Collections.sort(mCards, new CardComperator());

public class Card {

    private CardRank mCardRank;
    private CardSuit mCardSuit;

    public Card(CardSuit cardSuit, CardRank cardRank) {
        this.mCardRank = cardRank;
        this.mCardSuit = cardSuit;
    }

    public int getCardRankToInt() {
        return mCardSuit.ordinal() * 100 + mCardRank.getCardinal();
    }
    // getters, setters
}

public enum CardRank {

    TWO(2),
    THREE(3),
    FOUR(4),
    FIVE(5),
    SIX(6),
    SEVEN(7),
    EIGHT(8),
    NINE(9),
    TEN(10),
    JACK(11),
    QUEEN(12),
    KING(13),
    ACE(14);

    private int cardinal;

    private CardRank(final int cardinal) {
        this.cardinal = cardinal;
    }

    public int getCardinal() {
        return cardinal;
    }
}

public enum CardSuit {
    CLUBS,
    DIAMONDS,
    HEARTS,
    SPADES
}

public class CardComperator implements Comparator<Card> {

    @Override
    public int compare(Card p1, Card p2) {
        // p2.getCardRankToInt() - p1.getCardRankToInt() for decending order
        return p1.getCardRankToInt() - p2.getCardRankToInt();
    }
}

列出mCards=。。。
Collections.sort（mCards，newcardcomperator（））；
公务舱卡{
私人卡德兰；
私人卡套装；
公共卡（CardSuit CardSuit，CardRank CardRank）{
this.mCardRank=cardRank；
this.mCardSuit=cardSuit；
}
public int getcardrankpoint（）{
返回mCardSuit.ordinal（）*100+mCardRank.getCardinal（）；
}
//能手，二传手
}
公共枚举卡秩{
两（2），
三（3），
四（4），
五（5），
六（6），
七（7），
八（8），
九（9），
十（10），
杰克（11岁），
女王（12岁），
国王（13），
ACE（14）；
私有整数基数；
私人CardRank（最终整数基数）{
this.cardinal=cardinal；
}
public int getCardinal（）{
返回基数；
}
}
公众登记证{
俱乐部，
钻石，
心，
黑桃
}
公共类CardComperator实现比较器{
@凌驾
公共整数比较（卡p1、卡p2）{
//p2.GetCardRankPoint（）-p1.GetCardRankPoint（）用于下位订单
返回p1.getCardRankPoint（）-p2.getCardRankPoint（）；
}
}

不要使用字符串表示卡值。使用枚举，其中值按适当顺序定义@JB Nizet，我确实定义了枚举值，并将它们分为两个等级，如果我声明一个枚举等级集，如下enum{TEN（'T'）、JOKER（'J'）}，java会认为“J”大于“T”吗？这只是一个问题，因为你的回答让我觉得二进制数是按照enum成员声明的顺序分配的。它不会将“J”视为大于“t”。但是Rank.JOKER将大于Rank.TEN，因为在枚举中，JOKER是在十之后声明的。”J'和T'是字符，不是等级的实例。这个问题非常具体，在我看来还不够小

Arrays.sort (sorted2D, new CardComperator());

List<Card> mCards = ...
Collections.sort(mCards, new CardComperator());

public class Card {

    private CardRank mCardRank;
    private CardSuit mCardSuit;

    public Card(CardSuit cardSuit, CardRank cardRank) {
        this.mCardRank = cardRank;
        this.mCardSuit = cardSuit;
    }

    public int getCardRankToInt() {
        return mCardSuit.ordinal() * 100 + mCardRank.getCardinal();
    }
    // getters, setters
}

public enum CardRank {

    TWO(2),
    THREE(3),
    FOUR(4),
    FIVE(5),
    SIX(6),
    SEVEN(7),
    EIGHT(8),
    NINE(9),
    TEN(10),
    JACK(11),
    QUEEN(12),
    KING(13),
    ACE(14);

    private int cardinal;

    private CardRank(final int cardinal) {
        this.cardinal = cardinal;
    }

    public int getCardinal() {
        return cardinal;
    }
}

public enum CardSuit {
    CLUBS,
    DIAMONDS,
    HEARTS,
    SPADES
}

public class CardComperator implements Comparator<Card> {

    @Override
    public int compare(Card p1, Card p2) {
        // p2.getCardRankToInt() - p1.getCardRankToInt() for decending order
        return p1.getCardRankToInt() - p2.getCardRankToInt();
    }
}