Thread: Is there a card-shuffling Java class available?

Yes, look at the Java SE API docs's Index of method names for ones starting with shuff
https://docs.oracle.com/javase/8/docs/api/index.html
Click on INDEX in the top blue banner, then click on S and search for shuffle for links to methods of interest

Originally Posted by BackInTheSaddle

Since re-inventing the wheel is a mortal sin in the Church of Programming - plus the fact that I'd rather not spend the time to develop
my own - I'm hoping that there is a Java class that someone, somewhere has already created that will accomplish this task.

Although a tongue-in-cheek statement, writing code that already exists is not necessarily a bad thing. It all depends on its complexity and how long it takes you to find the appropriate API. Even for those who never heard of the Fisher-Yates algorithm writing a pretty good shuffle routine would take only about 10 minutes.

Regards,
Jim

my shuffled deck now contains duplicate cards!

Can you make a small, simple program that compiles and executes and shows the problem and paste it here so we can see the problem?
Be sure to wrap the code in code tags.

How to wrap your code with code tags:

[code]
**YOUR CODE GOES HERE**
[/code]

to get highlighting and preserve formatting.

If you go to the Go Advanced page, the # near the end of the second row of buttons will wrap the selected text in code tags.

Code tags are party of the BB Codes. When you go into the advanced editor (down and to the right of the normal editor box), you can see the BB codes at the end of the page. Here is a link to help. BB Code List - Java Programming Forums - The Java Community

Regards,
Jim

Originally Posted by Norm

Can you make a small, simple program that compiles and executes and shows the problem and paste it here so we can see the problem?
Be sure to wrap the code in code tags.

Here it is, quick and dirty, unpolished and unsophisticated - but it does produce an ArrayList with duplicate entries!

Here's a Fun Fact: When I used a single 'deck' the shuffled ArrayList contained no duplicates, but when I used two 'decks', the duplicates appeared.

import java.util.ArrayList;
import java.lang.StringBuilder;
import java.util.Collections;
import java.util.ListIterator;
import java.util.Random;
 
public class ProgramTester {
 
    public static void main(String[] args) {
        int rank = 0;
        char suit;
 
        StringBuilder sb = new StringBuilder();
 
        ArrayList<String> cardSuitandRank = new ArrayList();
        cardSuitandRank.ensureCapacity(104);
 
        // Create two decks of 52 cards each
        suit = 'H';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
 
        rank = 0;
        suit = 'D';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
 
        // Re-initialize rank for the second deck
        rank = 0;
        suit = 'S';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
        }
 
        rank = 0;
        suit = 'C';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
        rank = 0;
        suit = 'H';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
 
        rank = 0;
        suit = 'D';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
 
        rank = 0;
        suit = 'S';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
        }
 
        rank = 0;
        suit = 'C';
        for (int idx1 = 0; idx1 < 13; idx1++) {
 
            sb.append(suit);
            rank++;
            sb.append(rank);
            cardSuitandRank.add(sb.toString());
            sb.delete(0,sb.length());
 
        }
        ListIterator iter = cardSuitandRank.listIterator();
        System.out.println("Prior to shuffle");
 
        do {
 
            System.out.println(iter.next());
 
        } while (iter.hasNext());
 
        Collections.shuffle(cardSuitandRank, new Random());
 
        ListIterator iter2 = cardSuitandRank.listIterator();
        System.out.println("After shuffle");
 
        do {
 
            System.out.println(iter2.next());
 
        } while (iter2.hasNext());
    }
 
}

When I used a single 'deck' the shuffled ArrayList contained no duplicates, but when I used two 'decks', the duplicates appeared.

That is what I would expect. Two decks would have 2 of each card. 2 Ace of Clubs, 2 King of Spades etc
Please explain.

Ok, good luck with the project. See you next time.

There is a lot of repeated code in what you posted. Anything you repeat a block of code more than a couple of times, think about loops and arrays. Here is another solution:

        // Use array and loop to load 2 decks
        String[] suits = {"S", "H", "D", "C"};
        for(int deck=0; deck<2; deck++) {
           for(int suitIdx = 0; suitIdx < suits.length; suitIdx++) {
              for (int rankC=1; rankC<=13; rankC++) {
                 cardSuitandRank.add(suits[suitIdx] + rankC);
              }
           }
        }
        System.out.println(cardSuitandRank);
        // [S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, H1, H2, H3, H4, H5, H6, H7, H8, H9, H10, H11, H12, H13, 
        //  D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, 
        //  S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, H1, H2, H3, H4, H5, H6, H7, H8, H9, H10, H11, H12, H13, 
        //  D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13]

Originally Posted by Norm

Ok, good luck with the project. See you next time.

Just FYI - I'm a retired developer with decades of programming experience, including 15 years of programming in Java.

My program has come a long way, although it's still not quite done, and - as one would expect with this type of project - it runs and runs and runs while the number of possible sequences of play expands geometrically (at least it's not exponentially!) and millions of possibilities have been explored with no end in sight. (Yes, I've tested for halting conditions!) I'm working on a standard iMac, and I worry about crashing the computer if its resources are insufficient to run the program to its conclusion. So far it hasn't seemed to have any trouble, but then I haven't let it run until the end yet. I set an arbitrary limit on the number of branches it will explore before stopping while displaying the state of the card tableaus (this is a solitaire-playing program looking for possible winning sequences).

Once I'm satisfied that my logic will yield the correct results, I'm pondering the idea of rewriting it in some language that will compile to a nice, tight executable that will cough up the answer in less than a week (or however long it turns out that my Java program will need once I take off the limit). I'm sure that assembler would be lots of fun to learn and struggle with, there must be some other way that is somewhere in between. What would be your recommendation for a programming language I might use?

I've done a bit of fiddling with Erlang, which is supposed to run very fast but is based on Lisp, which (so I hear) requires some odd brain wiring to understand well. Maybe you've used some language I've never heard of for tasks like this.