Question

I’m writing a code for a deck of cards which shuffles the deck of cards. I tested the code but I don’t really know if it’s actually doing what it’s supposed to be doing correctly? What do you think?

This is the code for the shuffle method:

public void shuffle()
{
    for( int x = myDeck.size(); x > 0 ; x--) 
     {
        Random rn = new Random();
        int index1 = rn.nextInt(52);
        Card c = myDeck.remove(index1);
        myDeck.add(c);
     }
  }

My output seems shuffled in its numbers but not by the name of the card like spades hearts etc,

For example this is my output when I test the code :

Deuce of spades
Seven of spades
Eight of spades
Ace of spades
Three of hearts
Five of hearts
Six of hearts
Seven of hearts
Nine of hearts
Ten of hearts
Queen of hearts
King of hearts
Ace of hearts
Seven of diamonds
Eight of diamonds
Jack of diamonds
King of diamonds
Three of clubs
Seven of clubs
Nine of clubs
Jack of clubs
Queen of clubs
King of clubs
Ace of clubs
Queen of spades
Deuce of clubs
Three of spades
Nine of diamonds
Four of spades
Four of clubs
Deuce of hearts
Jack of spades
Ten of clubs
Six of diamonds
Jack of hearts
Six of clubs
Four of diamonds
Five of diamonds
Ace of diamonds
Four of hearts
Nine of spades
Ten of spades
Five of spades
Three of diamonds
Six of spades
Five of clubs
Deuce of diamonds
Eight of hearts
King of spades
Ten of diamonds
Eight of clubs
Queen of diamonds

Like there’s always repeated names. is it wrong since the point of shuffling is to mix it up?

This is the actual question: When playing cards, it is, of course, important to shuffle the deck, that is, to
arrange things so that the cards will be dealt in a random order. There are
several ways to achieve this. One strategy involves repeatedly picking a card
at random out of the deck and moving it to the end. The following code uses
the Random class (which you met on page 8 of the “ArrayLists” section of the
online course) to perform one such “pick and move to the end” operation:

Random rn = new Random();
int index1 = rn.nextInt( 52 );
Card c = myDeck.remove( index1 );
myDeck.add( c );

To shuffle the deck effectively, this operation should be repeated many times
(say, 500 times). Create a new instance method, shuffle, for the Deck class
that uses a single Random object and a for loop to shuffle myDeck. After
suitably modifying the main method, use it to test your new code.

So my main question is: am I doing this wrong?

Answer 1

Just change rn.nextInt(52); to rn.nextInt(x) and you have a proper Fisher-Yates shuffle. No need to do more than 52 iterations.

Why this works:

• In the first iteration (when x is 52) you’ll select a random card from the full deck and move it last.

• In the second iteration (when x is 51) you’ll select a random card from the remaining cards and move it last.

  …and so on.

• After 52 iterations, the first card selected, will have ended up in the first index. Since this card was selected randomly from the full deck, each card is equally probable.

• Same applies for second index, third index, …

• It follows that each possible permutation of the deck is equally probable.

(In production code, just use Collections.shuffle in these situations.)