Как мне отсортировать 13 случайных игральных карт по порядку (последовательности) в Java?

Поскольку последняя буква обозначает масть, вы можете использовать ее для сортировки карт по мастям. Чтобы отсортировать по значениям, создайте список с допустимым порядком и сравните индекс ваших строк без последней буквы. Используйте интерфейс Компаратор, который упрощает цепочку сортировки и делает ваш код более читабельным.

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Example {

    public static void main(String[] args) {
        List<String> order = List.of("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A");

        String[] sTest = {"4H", "5H", "8C", "8D", "9H", "9D", "AC", "6S", "5D", "6D", "KD", "10C", "AD" };

        // compare by last char
        Comparator<String> bySuits = Comparator.comparingInt(s -> s.charAt(s.length()-1));

        //compare by the index of substring as they appear in the list
        Comparator<String> byValue = Comparator.comparingInt(s -> order.indexOf(s.substring(0, s.length()-1)));


        System.out.println("Before sorting: " + Arrays.toString(sTest));

        // compare by chaining the two comparators
        Arrays.sort(sTest, bySuits.thenComparing(byValue));

        System.out.println("After sorting: " + Arrays.toString(sTest));
    }
}

Используйте enum, чтобы определить колоду карт:

public final enum Card
{
  TWO_OF_CLUBS( "2C" ),
  THREE_OF_CLUBS( "3C" ),
  …
  ACE_OF_CLUBS( "AC" ),
  TWO_OF_DIAMONDS( "2D" ),
  …
  TWO_OF_HEARTS( "2H" ),
  …
  ACE_OF_SPADES( "AS" );

  private final String m_Code;

  private Card( final String code )
  {
    m_Code = code;
  }

  public static final Card forCode( final String code ) throws IllegalArgumentException
  {
     final var retValue = stream( values() )
       .filter( v -> v.m_Code.equals( code ) )
       .findFirst()
       .orElseThrow( () -> new IllegalArgumentException( Objects.toString( code ) );
      return retValue();
  }
  
  public final String getCode() { return m_Code; }
  
  @Override
  public final String toString() { return getCode(); }
}

Сортировка теперь работает так:

final String[] sTest = {"4H", "5H", "8C", "8D", "9H", "9D", "AC", "6S", "5D", "6D", "KD", "10C", "AD" };
final var result = stream( sTest )
  .map( Card::forCode )
  .sorted()
  .map( Card::getCode )
  .toArray( String []::new );

Порядок сортировки определяется последовательностью, в которой вы определяете значения перечисления в Card.

Забавным расширением может быть добавление кода Unicode в качестве символа к определению enum:

public final enum Card
{
  TWO_OF_CLUBS( "2C", "\u1F0D2" ),
  THREE_OF_CLUBS( "3C", "\u1F0D2" ),
  …
  ACE_OF_CLUBS( "AC", "\uF0D1" ),
  TWO_OF_DIAMONDS( "2D", "\uF0C2" ),
  …
  TWO_OF_HEARTS( "2H", "\uF0B2" ),
  …
  ACE_OF_SPADES( "AS", "\uF0A1" );

  private final String m_Code;
  private final String m_Symbol;

  private Card( final String code )
  {
    m_Code = code;
    m_Symbol = symbol;
  }

  public static final Card forCode( final String code ) throws IllegalArgumentException
  {
     final var retValue = stream( values() )
       .filter( v -> v.m_Code.equals( code ) )
       .findFirst()
       .orElseThrow( () -> new IllegalArgumentException( Objects.toString( code ) );
      return retValue();
  }
  
  public static final Card forSymbol( final String symbol ) throws IllegalArgumentException
  {
     final var retValue = stream( values() )
       .filter( v -> v.m_Symbol.equals( symbol ) )
       .findFirst()
       .orElseThrow( () -> new IllegalArgumentException( Objects.toString( symbol ) );
      return retValue();
  }
  
  public final String getCode() { return m_Code; }
  public final String getSymbol() { return m_Symbol; }
  
  @Override
  public final String toString() { return getCode(); }
}

Это позволяет представлять карты следующим образом:

final String[] sTest = {"🂴", "🂵", "🃘", "🃈", "🂹", "🃉", "🃑", "🂦", "🃅", "🃆", "🃎", "🃚", "🃁" };
final var result = stream( sTest )
  .map( Card::forSymbol )
  .sorted()
  .map( Card::getSymbol )
  .toArray( String []::new );

Есть много способов сделать это. По моему мнению, самое простое — просто определить отсортированную колоду карт в виде строки и отсортировать ее по индексу, находящемуся в этой строке.

String[] sTest = {"4H", "5H", "8C", "8D", "9H", "9D", "AC",
                   "6S", "5D", "6D", "KD", "10C", "AD" };

String sortedDeck = """
     2C3C4C5C6C7C8C9C10CJCQCKCAC\
     2D3D4D5D6D7D8D9D10DJDQDKDAD\
     2H3H4H5H6H7H8H9H10HJHQHKHAH\
     2S3S4S5S6S7S8S9S10SJSQSKSAS\
     """;
System.out.println(Arrays.toString(sTest)); // before sorting

Arrays.sort(sTest, Comparator.comparingInt(sortedDeck::indexOf));

System.out.println(Arrays.toString(sTest)); // after sorting

принты

[4H, 5H, 8C, 8D, 9H, 9D, AC, 6S, 5D, 6D, KD, 10C, AD]
[8C, 10C, AC, 5D, 6D, 8D, 9D, KD, AD, 4H, 5H, 9H, 6S]

Вышесказанное предполагает, что какой-то неизвестный элемент не проникнет в вашу колоду. Таким образом, предполагается, что индекс -1 не будет возвращен во время сортировки.

Вот колода, из которой вы получаете случайную комбинацию.

    static String suit[] = {"C", "D", "H", "S"};
    static String sym[] = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
    
    static String card_suit(byte c)
    {
        return suit[c / 13];
    }
    
    static String card_sym(byte c)
    {
        return sym[c % 13];
    }
    
    static void shuffle(byte deck[])
    {
        ArrayList<Byte> list = new ArrayList<Byte>();
        for (int i = 0; i < deck.length; i++) list.add(deck[i]);
        Collections.shuffle(list);
        for (int i = 0; i < deck.length; i++) deck[i] = list.get(i);
    }
    
    static void print(byte hand[])
    {
        for (int i = 0; i < hand.length; i++)
        {
            byte c = hand[i];
            String card = card_sym(c) + card_suit(c);
            System.out.print(card + " ");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        byte deck[] = new byte[52];
        for (int i = 0; i < deck.length; i++) deck[i] = (byte)i;
        
        print(deck);
        shuffle(deck);
        print(deck);
        Arrays.sort(deck);
        print(deck);
    }

Наборы C, D, H и S указаны в порядке ASCII.

Значение сюиты 2 – 10, J, Q, K и A – нет. Я переназначаю 10 на A, J на ​​B, Q на C, K на D и A на E, чтобы обеспечить правильный порядок ASCII.

Полный исходный код для перетасовки и раздачи карт https://dedetoknotes.blogspot.com/2024/07/java-17-shuffle-52-playing-cards-and.html

код

...
            //int posCard = beforeOrAfter(card2Sort, cardIterate, 0, iterMax);
            int posCard = beforeOrAfter2(card2Sort, cardIterate);

...
/* -1 wordA before wordB
 * 0 wordA equal wordB
 * 1 wordA after wordB
 * suite order less C D H S higher
 * value suit  less 0 1 2 3 4 5 6 7 8 9 A J K Q
 * map 10 to A
 *      J to B
 *      Q to C
 *      K to D
 *      A to E
 */
private static int beforeOrAfter2(String wordA, String wordB) {
    //System.out.print("word "+wordA+" "+wordB+" "); // debug
    char charA = wordA.charAt(wordA.length()-1);
    char charB = wordB.charAt(wordB.length()-1);
    //System.out.println(wordA+" "+wordB+" End "+charA+" "+charB+" "); // debug
    if (charA<charB) {
        return -1;
    } else if (charA>charB) {
        return 1;
    } else {
        // equal
        charA = wordA.charAt(wordA.length()-2);
        charB = wordB.charAt(wordB.length()-2);
        // mapping charA to correct order
        if (charA=='0') {
            charA='A';
        } else if (charA=='J') {
            charA='B';
        } else if (charA=='Q') {
            charA='C';
        } else if (charA=='K') {
            charA='D';
        } else if (charA=='A') {
            charA='E';
        }
        // mapping charB to correct order
        if (charB=='0') {
            charB='A';
        } else if (charB=='J') {
            charB='B';
        } else if (charB=='Q') {
            charB='C';
        } else if (charB=='K') {
            charB='D';
        } else if (charB=='A') {
            charB='E';
        }
        
        //System.out.println(" First "+charA+" "+charB); // debug
        if (charA<charB) {
            return -1;
        } else if (charA>charB) {
            return 1;
        }
    }
    
    return 0;
}