Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

I am trying to develop an card game for Android Can anyone suggest me how to write code for effectively shuffling the playing cards?

share|improve this question

3 Answers 3

Card shuffling is an algorithm which is easy to write intuitively, and get entirely wrong by doing so. There's a good reference for implementing card shuffling correctly on Wikipedia. What I'm presenting here is a very slightly simplified version of the algorithm covered on that page under The modern algorithm.

Here's the basic idea, in plain english:

Consider a deck of cards. For this discussion, you can have any number of cards in the deck, and they may start in any order.

We're going to be talking about "position" in the deck, where "position" is how many cards are higher in the deck than the card in that position. For example, the card on top of the deck is at position 0, the card beneath that is at position 1 (because there is 1 card higher than it -- the top card), and in a standard 52-card deck, the bottom card is at position 51, as 51 cards are higher than it in the deck.

Now, we consider each position in the deck, one at a time, starting from the bottom, and working our way up to the top.

For each position, we randomly select one of the cards which is at that position or at a lower-numbered position (remember, the top of the deck is 0, and we're working our way up from the bottom of the deck, so for each position, you're effectively picking up all the cards at and above that position and randomly picking one of those cards).

When we have made the random selection, we swap the card at the position we're currently considering with the card we randomly selected. If we randomly selected the card which was already in that position, then no swap is performed.

After swapping (or not swapping, if we randomly selected the card which was already in the position we were considering), we move on to the next position in the deck and continue.

In pseudocode, with n being the number of cards in the deck, and a being an array representing the deck, the algorithm looks like this:

for each i in [n .. 1] do
     j ← random integer in [ 0 .. i ]
     exchange a[j] and a[i]
share|improve this answer
+1 for more explained and broad answer –  Gustavo Maciel Apr 1 '12 at 5:23

You first define a sequence of all the cards you want to shuffle:

List<Card> shuffled = new ArrayList<Card>();

Then you walk through every position in the sequence and assign it a card randomly.

Random random = new Random();
for (int i = shuffled.size() - 1; i >= 0; i--) {
    int j = random.nextInt(i + 1);

    /* swap cards i,j */
    Card card = shuffled.get(i);
    shuffled.set(i, shuffled.get(j));
    shufflet.set(j, card);

Now shuffled is a random sequence of all of your cards.

share|improve this answer
this is known as Knuth's shuffle: en.wikipedia.org/wiki/Knuth_shuffle –  krolth Apr 1 '12 at 1:56

The java 1.5 enum tutorial has a interesting way to implement a deck of cards, building up the deck, shuffling and dealing. All very simple using enums and Collections

public class Card {
    public enum Rank { DEUCE, THREE, FOUR, FIVE, SIX,

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

    private final Rank rank;
    private final Suit suit;
    private Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;

    public Rank rank() { return rank; }
    public Suit suit() { return suit; }
    public String toString() { return rank + " of " + suit; }

    private static final List<Card> protoDeck = new ArrayList<Card>();

    // Initialize prototype deck
    static {
        for (Suit suit : Suit.values())
            for (Rank rank : Rank.values())
                protoDeck.add(new Card(rank, suit));

    public static ArrayList<Card> newDeck() {
        return new ArrayList<Card>(protoDeck); // Return copy of prototype deck

And the class to manage the deck.

public class Deal {
    public static void main(String args[]) {
        int numHands = Integer.parseInt(args[0]);
        int cardsPerHand = Integer.parseInt(args[1]);
        List<Card> deck  = Card.newDeck();
        for (int i=0; i < numHands; i++)
            System.out.println(deal(deck, cardsPerHand));

    public static ArrayList<Card> deal(List<Card> deck, int n) {
         int deckSize = deck.size();
         List<Card> handView = deck.subList(deckSize-n, deckSize);
         ArrayList<Card> hand = new ArrayList<Card>(handView);
         return hand;
share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.