我来为您介绍几种Java中常见的扑克牌排序算法。

1. 基础准备

扑克牌类设计

java

public enum Suit {

SPADES("♠"), HEARTS("♥"), CLUBS("♣"), DIAMONDS("♦");

private final String symbol;

Suit(String symbol) {

this.symbol = symbol;

public String getSymbol {

return symbol;

public enum Rank {

TWO("2", 2), THREE("3", 3), FOUR("4", 4), FIVE("5", 5),

SIX("6", 6), SEVEN("7", 7), EIGHT("8", 8), NINE("9", 9),

TEN("10", 10), JACK("J", 11), QUEEN("Q", 12), KING("K", 13), ACE("A", 14);

private final String name;

private final int value;

Rank(String name, int value) {

this.name = name;

this.value = value;

public int getValue {

return value;

@Override

public String toString {

return name;

public class Card implements Comparable {

private final Suit suit;

private final Rank rank;

public Card(Suit suit, Rank rank) {

this.suit = suit;

this.rank = rank;

public Suit getSuit {

return suit;

public Rank getRank {

return rank;

@Override

public int compareTo(Card other) {

// 优先按花色排序，再按点数排序

int suitCompare = this.pareTo(other.suit);

if (suitCompare != 0) {

return suitCompare;

return pare(this.rank.getValue, other.rank.getValue);

@Override

public String toString {

return rank + suit.getSymbol;

2. 排序算法实现

方法一：使用Collections.sort（默认排序）

java

import java.util.*;

public class PokerSorting {

// 创建一副扑克牌

public static List createDeck {

List deck = new ArrayList;

for (Suit suit : Suit.values) {

for (Rank rank : Rank.values) {

deck.add(new Card(suit, rank));

return deck;

// 默认排序（按花色和点数）

public static void defaultSort(List cards) {

Collections.sort(cards);

方法二：使用Comparator自定义排序

java

public class PokerSortingWithComparators {

// 按点数排序（忽略花色）

public static void sortByRank(List cards) {

cards.sort((card1, card2) ->

pare(card1.getRank.getValue, card2.getRank.getValue));

// 按花色排序（忽略点数）

public static void sortBySuit(List cards) {

cards.sort((card1, card2) ->

card1.getSuit.compareTo(card2.getSuit));

// 反向排序（从大到小）

public static void reverseSort(List cards) {

cards.sort(Collections.reverseOrder);

悟空黑桃a德州现在叫什么

// 复杂排序：先按点数，再按花色

public static void complexSort(List cards) {

cards.sort((card1, card2) -> {

int rankCompare = pare(

card1.getRank.getValue,

card2.getRank.getValue

);

if (rankCompare != 0) {

return rankCompare;

return card1.getSuit.compareTo(card2.getSuit);

});

方法三：手动实现快速排序

java

public class QuickSortPoker {

public static void quickSort(List cards) {

quickSort(cards, 0, cards.size

1);

private static void quickSort(List cards, int low, int high) {

if (low

int pi = partition(cards, low, high);

quickSort(cards, low, pi

1);

quickSort(cards, pi + 1, high);

private static int partition(List cards, int low, int high) {

Card pivot = cards.get(high);

int i = low

1;

for (int j = low; j

if (cards.get(j).compareTo(pivot)

i++;

Collections.swap(cards, i, j);

Collections.swap(cards, i + 1, high);

return i + 1;

3. 完整示例和使用

java

import java.util.*;

public class PokerGame {

public static void main(String[] args) {

// 创建一副扑克牌

List deck = createDeck;

System.out.println("原始牌堆:");

printDeck(deck);

// 打乱牌

Collections.shuffle(deck);

System.out.println("\

洗牌后:");

printDeck(deck);

// 各种排序方式

System.out.println("\

默认排序:");

Collections.sort(deck);

printDeck(deck);

System.out.println("\

按点数排序:");

deck.sort((c1, c2) -> pare(

c1.getRank.getValue, c2.getRank.getValue));

printDeck(deck);

System.out.println("\

按花色排序:");

deck.sort((c1, c2) -> c1.getSuit.compareTo(c2.getSuit));

printDeck(deck);

// 快速排序示例

Collections.shuffle(deck);

System.out.println("\

快速排序前:");

printDeck(deck);

QuickSortPoker.quickSort(deck);

System.out.println("\

快速排序后:");

printDeck(deck);

public static List createDeck {

List deck = new ArrayList;

for (Suit suit : Suit.values) {

for (Rank rank : Rank.values) {

deck.add(new Card(suit, rank));

return deck;

public static void printDeck(List deck) {

for (int i = 0; i

System.out.print(deck.get(i) + " ");

if ((i + 1) % 13 == 0) {

System.out.println;

4. 特殊排序场景

德州扑克手牌排序

java

public class TexasHoldemSort {

// 德州扑克：按点数从高到低排序

public static void sortHandForTexasHoldem(List hand) {

hand.sort((card1, card2) ->

pare(card2.getRank.getValue, card1.getRank.getValue));

// 检测同花顺等特殊牌型

public static boolean isFlush(List hand) {

Suit firstSuit = hand.get(0).getSuit;

return hand.stream.allMatch(card -> card.getSuit == firstSuit);

public static boolean isStraight(List hand) {

List values = new ArrayList;

for (Card card : hand) {

values.add(card.getRank.getValue);

Collections.sort(values);

// 检查是否是连续的数字

for (int i = 1; i

if (values.get(i)

values.get(i

1) != 1) {

return false;

return true;

这些排序算法各有特点：

1. Collections.sort

最简单，适用于大多数情况

2. Comparator

最灵活，可以自定义各种排序规则

3. 手动实现的快速排序

学习算法原理，理解排序过程

选择哪种方法取决于具体需求：

简单排序：使用Collections.sort

复杂排序规则：使用Comparator

- 学习目的：手动实现排序算法