Elevens Activity 4
<< Elevens Activity 3 | ElevensLab | Elevens Activity 5 >>
Introduction:
You implemented a Deck class in Activity 2. This class should be complete except for the shuffle method. You also implemented a DeckTester class that you used to test your incomplete Deck class.
In Activity 3, you implemented methods in the Shuffler class, which shuffled integers.
Now you will use what you learned about shuffling in Activity 3 to implement the Deck shuffle
method.
Exercises:
- The file
Deck.java, found below after we do Activity 2, is a correct solution from Activity 2. Complete theDeckclass by implementing theshufflemethod. Use the efficient selection shuffle algorithm from Activity 3 (if your method didn't work, see the solution in PlusPortals or watch the video. Note that theDeckconstructor creates thedeckand then calls theshufflemethod. The shuffle method also needs to reset the value of size to indicate that all of the cards can be dealt again. - The
DeckTester.javafile, found below folder, provides a basic set ofDecktests. It is similar to theDeckTesterclass you might have written in Activity 2. Add additional code at the bottom of the main method to create a standard deck of 52 cards and test the shuffle method. You can use the Deck toString method to “see” the cards after every shuffle.
Card.java
/**
* Card.java
*
* <code>Card</code> represents a playing card.
*/
public class Card {
/**
* String value that holds the suit of the card
*/
private String suit;
/**
* String value that holds the rank of the card
*/
private String rank;
/**
* int value that holds the point value.
*/
private int pointValue;
/**
* Creates a new <code>Card</code> instance.
*
* @param cardRank a <code>String</code> value
* containing the rank of the card
* @param cardSuit a <code>String</code> value
* containing the suit of the card
* @param cardPointValue an <code>int</code> value
* containing the point value of the card
*/
public Card(String cardRank, String cardSuit, int cardPointValue) {
//initializes a new Card with the given rank, suit, and point value
rank = cardRank;
suit = cardSuit;
pointValue = cardPointValue;
}
/**
* Accesses this <code>Card's</code> suit.
* @return this <code>Card's</code> suit.
*/
public String suit() {
return suit;
}
/**
* Accesses this <code>Card's</code> rank.
* @return this <code>Card's</code> rank.
*/
public String rank() {
return rank;
}
/**
* Accesses this <code>Card's</code> point value.
* @return this <code>Card's</code> point value.
*/
public int pointValue() {
return pointValue;
}
/** Compare this card with the argument.
* @param otherCard the other card to compare to this
* @return true if the rank, suit, and point value of this card
* are equal to those of the argument;
* false otherwise.
*/
public boolean matches(Card otherCard) {
return otherCard.suit().equals(this.suit())
&& otherCard.rank().equals(this.rank())
&& otherCard.pointValue() == this.pointValue();
}
/**
* Converts the rank, suit, and point value into a string in the format
* "[Rank] of [Suit] (point value = [PointValue])".
* This provides a useful way of printing the contents
* of a <code>Deck</code> in an easily readable format or performing
* other similar functions.
*
* @return a <code>String</code> containing the rank, suit,
* and point value of the card.
*/
@Override
public String toString() {
return rank + " of " + suit + " (point value = " + pointValue + ")";
}
}
Deck.java (to be revealed after Activity 2)
import java.util.List;
import java.util.ArrayList;
/**
* The Deck class represents a shuffled deck of cards.
* It provides several operations including
* initialize, shuffle, deal, and check if empty.
*/
public class Deck {
/**
* cards contains all the cards in the deck.
*/
private List<Card> cards;
/**
* size is the number of not-yet-dealt cards.
* Cards are dealt from the top (highest index) down.
* The next card to be dealt is at size - 1.
*/
private int size;
/**
* Creates a new <code>Deck</code> instance.<BR>
* It pairs each element of ranks with each element of suits,
* and produces one of the corresponding card.
* @param ranks is an array containing all of the card ranks.
* @param suits is an array containing all of the card suits.
* @param values is an array containing all of the card point values.
*/
public Deck(String[] ranks, String[] suits, int[] values) {
cards = new ArrayList<Card>();
for (int j = 0; j < ranks.length; j++) {
for (String suitString : suits) {
cards.add(new Card(ranks[j], suitString, values[j]));
}
}
size = cards.size();
shuffle();
}
/**
* Determines if this deck is empty (no undealt cards).
* @return true if this deck is empty, false otherwise.
*/
public boolean isEmpty() {
return size == 0;
}
/**
* Accesses the number of undealt cards in this deck.
* @return the number of undealt cards in this deck.
*/
public int size() {
return size;
}
/**
* Randomly permute the given collection of cards
* and reset the size to represent the entire deck.
*/
public void shuffle() {
/* *** TO BE IMPLEMENTED IN ACTIVITY 4 *** */
}
/**
* Deals a card from this deck.
* @return the card just dealt, or null if all the cards have been
* previously dealt.
*/
public Card deal() {
if (isEmpty()) {
return null;
}
size--;
Card c = cards.get(size);
return c;
}
/**
* Generates and returns a string representation of this deck.
* @return a string representation of this deck.
*/
@Override
public String toString() {
String rtn = "size = " + size + "\nUndealt cards: \n";
for (int k = size - 1; k >= 0; k--) {
rtn = rtn + cards.get(k);
if (k != 0) {
rtn = rtn + ", ";
}
if ((size - k) % 2 == 0) {
// Insert carriage returns so entire deck is visible on console.
rtn = rtn + "\n";
}
}
rtn = rtn + "\nDealt cards: \n";
for (int k = cards.size() - 1; k >= size; k--) {
rtn = rtn + cards.get(k);
if (k != size) {
rtn = rtn + ", ";
}
if ((k - cards.size()) % 2 == 0) {
// Insert carriage returns so entire deck is visible on console.
rtn = rtn + "\n";
}
}
rtn = rtn + "\n";
return rtn;
}
}
DeckTester.java
/**
* This is a class that tests the Deck class.
*/
public class DeckTester {
/**
* The main method in this class checks the Deck operations for consistency.
* @param args is not used.
*/
public static void main(String[] args) {
String[] ranks = {"jack", "queen", "king"};
String[] suits = {"blue", "red"};
int[] pointValues = {11, 12, 13};
Deck d = new Deck(ranks, suits, pointValues);
System.out.println("**** Original Deck Methods ****");
System.out.println(" toString:\n" + d.toString());
System.out.println(" isEmpty: " + d.isEmpty());
System.out.println(" size: " + d.size());
System.out.println();
System.out.println();
System.out.println("**** Deal a Card ****");
System.out.println(" deal: " + d.deal());
System.out.println();
System.out.println();
System.out.println("**** Deck Methods After 1 Card Dealt ****");
System.out.println(" toString:\n" + d.toString());
System.out.println(" isEmpty: " + d.isEmpty());
System.out.println(" size: " + d.size());
System.out.println();
System.out.println();
System.out.println("**** Deal Remaining 5 Cards ****");
for (int i = 0; i < 5; i++) {
System.out.println(" deal: " + d.deal());
}
System.out.println();
System.out.println();
System.out.println("**** Deck Methods After All Cards Dealt ****");
System.out.println(" toString:\n" + d.toString());
System.out.println(" isEmpty: " + d.isEmpty());
System.out.println(" size: " + d.size());
System.out.println();
System.out.println();
System.out.println("**** Deal a Card From Empty Deck ****");
System.out.println(" deal: " + d.deal());
System.out.println();
System.out.println();
/* *** TO BE COMPLETED IN ACTIVITY 4 *** */
System.out.println("\n**** 52 Card Deck shuffle Tests ****");
// make arrays for ranks, suits, and point values to initialize a standard poker deck
// System.out.println(" After Creation:\n" + d52.toString());
// next deal a card
// System.out.println(" After Dealing the " + c + ":\n" + d52.toString());
// next shuffle and print the deck 3 times
}
}