Caros participantes do Fórum,
Solicito ajuda para explicar como funciona o exemplo da figura 7.10, página 214 do livro, o método de embaralha cartas.
Já fiz várias simulações e não consigo visualizar como a classe consegue embaralhar as cartas e ao final mostrar todas as cartas sem repetir.
Nas simulações que faço o método shuffle, da classe DeckOfCards, embaralha as cartas, porém apresenta um resultado com 52 cartas, mas contém cartas repetidas, contudo ao rodar o programa ele apresenta as 52 cartas embaralhadas e sem repetição.
Será que alguém pode explicar como isso funciona.
Seguem as classes abaixo:
[code]// Fig. 7.9: Card.java
// Classe Card representa uma carta de baralho.
public class Card
{
private String face; // face da carta (“Ace”, “Deuce”, …)
private String suit; // naipe da carta (“Hearts”, “Diamonds”, …)
// construtor de dois argumentos inicializa face e naipe da carta
public Card( String cardFace, String cardSuit )
{
face = cardFace; // inicializa face da carta
suit = cardSuit; // inicializa naipe da carta
} // fim do construtor Card de dois argumentos
// retorna representação String de Card
public String toString()
{
return face + " of " + suit;
} // fim do método toString
} // fim da classe Card[/code]
[code]// Fig. 7.10: DeckOfCards.java
// classe DeckOfCards representa um baralho.
import java.util.Random;
public class DeckOfCards
{
private Card deck[]; // array de objetos Card
private int currentCard; // índice do próximo Card a ser distribuído
private final int NUMBER_OF_CARDS = 52; // número constante de Cards
private Random randomNumbers; // gerador de número aleatório
// construtor preenche baralho de cartas
public DeckOfCards()
{
String faces[] = { “Ace”, “Deuce”, “Three”, “Four”, “Five”, “Six”,
“Seven”, “Eight”, “Nine”, “Ten”, “Jack”, “Queen”, “King” };
String suits[] = { “Hearts”, “Diamonds”, “Clubs”, “Spades” };
deck = new Card[ NUMBER_OF_CARDS ]; // cria array de objetos Card
currentCard = 0; // configura currentCard então o primeiro Card distribuído é deck[ 0 ]
randomNumbers = new Random(); // cria gerador de número aleatório
// preenche baralho com objetos Card
for ( int count = 0; count < deck.length; count++ )
deck[ count ] =
new Card( faces[ count % 13 ], suits[ count / 13 ] );
} // fim do construtor DeckOfCards
// embaralha as cartas com um algoritmo de uma passagem
public void shuffle()
{
// depois de embaralhar, a distribuição deve iniciar em deck[ 0 ] novamente
currentCard = 0; // reinicializa currentCard
// para cada Card, seleciona outro Card aleatório e os compara
for ( int first = 0; first < deck.length; first++ )
{
// seleciona um número aleatório entre 0 e 51
int second = randomNumbers.nextInt( NUMBER_OF_CARDS );
// compara Card atual com Card aleatoriamente selecionado
Card temp = deck[ first ];
deck[ first ] = deck[ second ];
deck[ second ] = temp;
} // for final
} // fim do método shuffle
// distribui um Card
public Card dealCard()
{
// determina se ainda há Cards a serem distribuídos
if (currentCard < deck.length)
return deck[ currentCard++ ]; // retorna Card atual no array
else
return null; // retorna nulo p/ indicar que todos os Cards foram distribuídos
} // fim do método dealCard
} // fim da classe DeckOfCards[/code]
[code]// Fig. 7.11: DeckOfCardsTest.java
// Aplicativo de embaralhar e distribuir cartas.
public class DeckOfCardsTest
{
// executa o aplicativo
public static void main( String args[] )
{
DeckOfCards myDeckOfCards = new DeckOfCards();
myDeckOfCards.shuffle(); // coloca Cards em ordem aleatória
// imprime todas as 52 cartas na ordem em que elas são distribuídas
for ( int i = 0; i < 13; i++ )
{
// distribui e imprime 4 Cards
System.out.printf( "%-20s%-20s%-20s%-20s\n",
myDeckOfCards.dealCard(), myDeckOfCards.dealCard(),
myDeckOfCards.dealCard(), myDeckOfCards.dealCard() );
} // for final
} // fim de main
} // fim da classe DeckOfCardsTest[/code]
:thumbup: Valeu.