Develop Reference

Build Blackjack program in Java, but "split" method would require rewriting whole program?

Getting back into programming after many years, and build a simple "blackjack" program in Java.
I'm wondering if the way I structured the methods/objects is bad, using global static variables. The program seems to work fine, but there's no way to implement a "split" method without re-writing everything, since you can't pass the new "split" hands into the "hit" or "stand" functions.
I'm curious how others would structure this and what the flaws in my methodology were. Thanks!
import java.io.*;
import java.util.*;
public class BlackJack {
static int bankroll = 0;
static int bet = 1;
static int index = 0;
static CardDeck d = new CardDeck();
static ArrayList<Card> playerCards = new ArrayList<Card>();
static ArrayList<Card> playerCards2 = new ArrayList<Card>(); //unused - was thinking of using for splitting
static ArrayList<Card> playerCards3 = new ArrayList<Card>(); //unused - was thinking of using for splitting
static ArrayList<Card> playerCards4 = new ArrayList<Card>(); //unused - was thinking of using for splitting
static ArrayList<Card> playerCards5 = new ArrayList<Card>(); //unused - was thinking of using for splitting
static ArrayList<Card> playerCards6 = new ArrayList<Card>(); //unused - was thinking of using for splitting
static ArrayList<Card> dealerCards = new ArrayList<Card>(); //unused - was thinking of using for splitting
static int playerScore = 0;
static int dealerScore = 0;
static String action = "";
static Scanner s = new Scanner(System.in);
public static void main(String[] args) {
initializeBankroll();
while (bet != 0) {
startRound();
display();
if(checkBlackJacks()) continue;
while (playerScore <= 21) {
System.out.println("H - hit, S - stand, X - surrender, D - double down");
action = s.nextLine();
if (action.equals("H")) hit();
else if (action.equals("S")) {
stand();
break;
}
else if (action.equals("X")) surrender();
else if (action.equals("D")) {
doubleDown();
break;
}
}
eval();
}
}
public static int score (ArrayList<Card> list) {
int ret = 0;
int acecounter = 0;
for (int i=0; i<list.size(); i++) {
if (list.get(i).getVal()>1) {
ret += Math.min(10, list.get(i).getVal());
}
else { //An ace
ret += 11;
acecounter++;
}
}
while(ret >21 && acecounter >0) {
ret -= 10;
acecounter -= 1;
}
return ret;
}
public static void dealToPlayer() {
playerCards.add(d.getCard(index));
index++;
}
public static void dealToDealer() {
dealerCards.add(d.getCard(index));
index++;
}
public static void display() {
System.out.println("PLAYER CARDS:");
String playerCardString = "";
for (int i=0; i<playerCards.size(); i++) {
playerCardString += playerCards.get(i).toString();
playerCardString += " ";
}
System.out.println(playerCardString);
System.out.println("DEALER CARD:");
System.out.println(dealerCards.get(0).toString());
}
public static void hit() {
dealToPlayer();
reScore();
display();
}
public static void surrender() {
if(playerCards.size()>2) {
System.out.println("You can't do that");
return;
}
bankroll -= (bet / 2);
playerScore = 100; //surrender
}
public static void reScore() {
playerScore = score(playerCards);
dealerScore = score(dealerCards);
}
public static void stand() {
try {
System.out.println("DEALER DOWNCARD: " + dealerCards.get(1).toString());
Thread.sleep(1000);
while (dealerScore <17) {
dealToDealer();
System.out.println(dealerCards.get(dealerCards.size()-1).toString());
reScore();
System.out.println("DEALER SCORE " + Integer.toString(dealerScore));
Thread.sleep(1000);
}
}catch(Exception E) {
System.out.println("Exception");
}
}
public static void doubleDown() {
if(playerCards.size()>2) {
System.out.println("You can't do that, hitting instead");
hit();
if(playerScore<=21) stand();
return;
}
if( bet * 2 > bankroll) {
System.out.println("Doubling for less...");
bet = bankroll;
hit();
if(playerScore<=21) stand();
return;
}
bet *= 2;
hit();
if(playerScore<=21) stand();
}
public static void split(ArrayList<Card> splitarray, int splitcount) { //INCOMPLETE. How to get this to work?
if(splitarray.size()>2 || bet * (splitcount+1) > bankroll || splitarray.get(1).getVal() != splitarray.get(0).getVal()) {
System.out.println("Can't split. Hitting instead");
hit();
}
ArrayList<Card> s1 = new ArrayList<Card>();
ArrayList<Card> s2 = new ArrayList<Card>();
s1.add(splitarray.get(0));
s2.add(splitarray.get(1));
}
public static void eval() {
if (playerScore==100) { //indicates a surrender, and bankroll has already been adjusted
return;
}
if (playerScore>21) {
System.out.println("BUST");
bankroll -= bet;
return;
}
if (dealerScore>21) {
System.out.println("DEALER BUST");
bankroll += bet;
return;
}
if (playerScore > dealerScore) {
System.out.println("WIN");
bankroll += bet;
return;
}
if (playerScore < dealerScore) {
System.out.println("LOSE");
bankroll -= bet;
return;
}
System.out.println("PUSH");
return;
}
public static void newhand() {
d.shuffle();
playerCards.clear();
dealerCards.clear();
index = 0;
reScore();
}
public static boolean checkBlackJacks() {
if(playerScore == 21) {
if(dealerCards.get(0).getVal()==1) {
System.out.println("Even money? Y / N");
String even = s.nextLine();
if (even=="Y"){
bankroll += bet;
newhand();
return true;
}
}
if(dealerScore != 21) {
System.out.println("BlackJack");
bankroll += (1.5 * bet);
newhand();
return true;
}
else {
System.out.println("Push - Mutual Blackjack");
newhand();
return true;
}
}
if(dealerCards.get(0).getVal()==1) { //insurance
System.out.println("Insurance? Type wager or 0, up to half your bet");
int insuranceBet = s.nextInt();
if (insuranceBet > bankroll) insuranceBet = bankroll;
if (insuranceBet > (bet / 2)) insuranceBet = bet / 2;
if (dealerScore == 21) bankroll += (insuranceBet * 2);
else bankroll -= insuranceBet;
}
if(dealerScore==21) {
System.out.println("Dealer Blackjack");
bankroll -= bet;
newhand();
return true;
}
return false;
}
public static void initializeBankroll() {
System.out.println("Enter your buy-in");
bankroll = s.nextInt();
}
public static void startRound() {
newhand();
System.out.println("Money remaining:" + Integer.toString(bankroll));
System.out.println("Enter your bet");
bet = s.nextInt();
if (bet>bankroll) bet=0;
dealToPlayer();
dealToDealer();
dealToPlayer();
dealToDealer();
reScore();
}
}
___________________
public class Card {
int val; //1 = Ace, 11 = Jack, 12 = Queen, 13 = King
int suit; //1 = Club, 2 = Diamond, 3 = Heart, 4 = Spade
public Card() {
this(1,1);
}
public Card(int val, int suit) {
this.val = val;
this.suit = suit;
}
public int getSuit(){
return suit;
}
public int getVal() {
return val;
}
public void setVal(int a) {
if(a>=1 && a<= 13) val = a;
}
public void setSuit(int a) {
if (a>=1 && a<=4) suit = a;
}
public String toString() {
String valString = "";
String suitString = "";
String ret = "";
switch(val) {
case 1: valString = "A"; break;
case 10: valString = "T"; break;
case 11: valString = "J"; break;
case 12: valString = "Q"; break;
case 13: valString = "K"; break;
default: valString = Integer.toString(val);
}
switch(suit) {
case 1: suitString = "c"; break;
case 2: suitString = "d"; break;
case 3: suitString = "h"; break;
case 4: suitString = "s"; break;
default: suitString = "ERROR"; break;
}
ret = valString + suitString;
return ret;
}
}
______________________
public class CardDeck{
Card[] deck;
public CardDeck(){
int k=0;
deck = new Card[52];
for (int i=0; i<13; i++){
for (int j=0; j<4; j++){
Card c = new Card(i+1,j+1);
deck[k]=c;
k++;
}
}
shuffle();
}
public void shuffle(){
Card[] deckCopy = new Card[52];
boolean[] flags = new boolean[52];
for (int i=0; i<flags.length; i++) flags[i]=false;
int numConverted=0;
while(numConverted<52){
int num = (int)(Math.random() * 52);
if (flags[num]==false){
deckCopy[numConverted]=deck[num];
numConverted++;
flags[num]=true;
}
}
deck = deckCopy;
} //end shuffle
public String toString() {
String ret = "";
for (int i = 0; i<deck.length; i++) {
ret += deck[i].toString();
ret += " ";
}
return ret;
}
public Card getCard(int a) {
if (a<0 || a > 51) return null;
else return deck[a];
}
public int getSuit(int a) {
if (a<0 || a > 51) return 0;
else return deck[a].getSuit();
}
public int getVal(int a) {
if (a<0 || a > 51) return 0;
else return deck[a].getVal();
}
}

Blackjack game - How to use the getter and the toString() methods

I'm trying to learn Java and I copied a program that simulate a blackjack game (from here: https://www.youtube.com/watch?v=buGFs1aQgaY).
I understood most of it but I got stuck at how the program make the sum of an hand. In the forth class, called "Player", at some point there is:
cardNum = this.hand[c].getNumber();
Let's say that:
this.hand[c] = King of Clubs.
I don't understand how the program gives as a result:
cardNum = 13.
How does the getNumber method works? (The method is made in the first class, called Card)
I'll post all the classes of the program.
FIRST CLASS.
public class Card {
private Suit mySuit;
private int myNumber;
public Card(Suit aSuit, int aNumber){
this.mySuit = aSuit;
if (aNumber >= 1 && aNumber <= 13){
this.myNumber = aNumber;
} else{
System.err.println(aNumber + " is not a valid Card number");
System.exit(1);
}}
public int getNumber(){
return myNumber;
}
public String toString(){
String numStr = "Err";
switch(this.myNumber){
case 2:
numStr = "Two";
break;
case 3:
numStr = "Three";
break;
case 4:
numStr = "Four";
break;
case 5:
numStr = "Five";
break;
case 6:
numStr = "Six";
break;
case 7:
numStr = "Seven";
break;
case 8:
numStr = "Eight";
break;
case 9:
numStr = "Nine";
break;
case 10:
numStr = "Ten";
break;
case 11:
numStr = "Jack";
break;
case 12:
numStr = "Queen";
break;
case 13:
numStr = "King";
break;
case 1:
numStr = "Ace";
break;
}
return numStr + " of " + mySuit.toString();
}
}
SECOND CLASS
public enum Suit {
Clubs,
Diamonds,
Spades,
Hearts
}
THIRD CLASS
import java.util.Random;
public class Deck {
private Card[] myCards;
private int numCards;
public Deck(){
this(1,false);
}
public Deck(int numDecks, boolean shuffle) {
this.numCards = numDecks * 52;
this.myCards = new Card[this.numCards];
int c = 0;
for (int d = 0; d < numDecks; d++) {
for (int s = 0; s < 4; s++) {
for (int n = 1; n <= 13; n++) {
this.myCards[c] = new Card(Suit.values()[s], n);
c++;
}
}
}
if (shuffle) {
this.shuffle();
}
}
public void shuffle(){
Random rng = new Random();
Card temp;
int j;
for (int i = 0; i < this.numCards; i++){
j = rng.nextInt(this.numCards);
temp = this.myCards[i];
this.myCards[i] = this.myCards[j];
this.myCards[j] = temp;
}
}
public Card dealNextCard() {
Card top = this.myCards[0];
for (int c = 1; c < this.numCards; c++) {
this.myCards[c - 1] = this.myCards[c];
}
this.myCards[this.numCards - 1] = null;
this.numCards--;
return top;
}
public void printDeck(int numToPrint){
for(int c=0; c < numToPrint; c++) {
System.out.printf("% 3d/%d/%s\n", c + 1, this.numCards,
this.myCards[c].toString());
}
System.out.printf("/t/t[%d other]\n", this.numCards-numToPrint);
}
}
FORTH CLASS
public class Player {
private String name;
private Card[]hand = new Card[10];
private int numCards;
public Player(String aName) {
this.name = aName;
this.emptyHand();
}
public void emptyHand(){
for(int c=0; c<10; c++){
this.hand[c] = null;
}
this.numCards = 0;
}
public boolean addCard(Card aCard) {
if (this.numCards == 10) {
System.err.printf("%s's hand already has 10 cards;" +
"cannot add another\n", this.name);
System.exit(1);
}
this.hand[this.numCards] = aCard;
this.numCards++;
return(this.getHandSum()<= 21);
}
public int getHandSum(){
int handSum = 0;
int cardNum;
int numAces = 0;
for(int c=0; c < this.numCards; c++) {
cardNum = this.hand[c].getNumber();
if (cardNum == 1) {
numAces++;
handSum += 11;
} else if (cardNum > 10) {
handSum += 10;
} else {
handSum += cardNum;
}
}
while (handSum >21 && numAces > 0){
handSum -= 10;
numAces--;
}
return handSum;
}
public void printHand(boolean showFirstCard){
System.out.printf("%s's cards:\n", this.name);
for(int c=0; c<this.numCards; c++) {
if(c==0 && !showFirstCard) {
System.out.println(" [hidden]");
} else {
System.out.printf(" %s\n", this.hand[c].toString());
}
}
}
}
FIFTH CLASS - PROGRAM
import java.util.Scanner;
public class GameRunner{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Deck theDeck = new Deck(1, true);
theDeck.printDeck(52);
Player me = new Player("Player 1");
Player dealer = new Player("Dealer");
me.addCard(theDeck.dealNextCard());
dealer.addCard(theDeck.dealNextCard());
me.addCard(theDeck.dealNextCard());
dealer.addCard(theDeck.dealNextCard());
System.out.println("Cards are dealt\n");
me.printHand(true);
dealer.printHand(false);
System.out.println("\n");
boolean meDone = false;
boolean dealerDone = false;
String ans;
while(!meDone || !dealerDone) {
if(!meDone){
System.out.println("Hit or Stay? (Enter H or S):");
ans = sc.next();
System.out.println();
if(ans.compareToIgnoreCase("H") == 0) {
meDone = !me.addCard(theDeck.dealNextCard());
me.printHand(true);
} else {
meDone = true;
}
}
if(!dealerDone){
if (dealer.getHandSum() < 17) {
System.out.println("The Dealer hits\n");
dealerDone = !dealer.addCard(theDeck.dealNextCard());
dealer.printHand(false);
} else {
System.out.println("The Dealer stays\n");
dealerDone = true;
}
}
System.out.println();
}
sc.close();
me.printHand(true);
dealer.printHand(true);
int mySum = me.getHandSum();
int dealerSum = dealer.getHandSum();
if(mySum > dealerSum && mySum <= 21 || dealerSum>21) {
System.out.println("Your win");
} else{
System.out.println("Dealer wins!");
}
}
}

When you create each instance of class Card, you pass in a Suit and a VALUE for that card:
... = new Card(Suit.values()[s], n);
In the above example from the code, the n variable is the value of the card, and was going from 1 to 13 because of the for loops setup to create the decks of cards.
In the Constructor for class Card, we then store that value in the private member called myNumber seen below:
public class Card {
private Suit mySuit;
private int myNumber; // <-- the value of the card is stored here
public Card(Suit aSuit, int aNumber){
// ... other code ...
this.myNumber = aNumber; // <-- store the passed in value in the instance member
// ... other code ...
}
}
Finally, the getNumber() function simply returns the stored value of the card, previously put into myNumber:
public int getNumber(){
return myNumber;
}

How can I check for duplicate values without making an array?

I have a program that deals 20 cards based on the value of random numbers. So far it works to deal cards such as King of Spades, 2 of Hearts, etc. My job is to check whether or not the cards are duplicate using a method, but without an array. Here is my solution to checking duplicates which doesn't work for obvious reasons:
public class Driver {
public static void main(String [] args) {
for (int i = 0; i < 20; i++){
Cards card1 = new Cards();
Cards card2 = card1;
if (card1 == card2) {
card1 = new Cards();
}
System.out.println(card1);
}
}
}
Here is my support class:
import java.util.Random;
public class Cards {
String hearts = "Hearts";
String diamonds = "Diamonds";
String clubs = "Clubs";
String spades = "Spades";
String suit;
int cardNumber;
String numberName;
String suitName;
Random randomNum = new Random();
public Cards () {
}
public String suit() {
int theRandom = randomNum.nextInt(4);
if (theRandom == 0 ) {
suitName = "hearts";
}
else if ( theRandom == 1) {
suitName = "diamonds";
}
else if (theRandom == 2) {
suitName = "clubs";
}
else {
suitName = "spades";
}
return suitName;
}
public String number() {
int theRandomNum = randomNum.nextInt(12 + 1);
if ( theRandomNum == 1 ) {
numberName = "Ace";
}
else if ( theRandomNum == 2) {
numberName = "2";
}
else if ( theRandomNum == 3) {
numberName = "3";
}
else if ( theRandomNum == 4) {
numberName = "4";
}
else if ( theRandomNum == 5) {
numberName = "5";
}
else if ( theRandomNum == 6) {
numberName = "6";
}
else if ( theRandomNum == 7) {
numberName = "7";
}
else if ( theRandomNum == 8) {
numberName = "8";
}
else if ( theRandomNum == 9) {
numberName = "9";
}
else if ( theRandomNum == 10) {
numberName = "10";
}
else if ( theRandomNum == 11) {
numberName = "Jack";
}
else if ( theRandomNum == 12) {
numberName = "Queen";
}
else if ( theRandomNum == 13) {
numberName = "King";
}
return numberName;
}
public String toString()
{
if (number() == "null") {
return ("3" + " of " + suit());
}
return (number() + " of " + suit());
}
}

For using a large String to store the cards that have been chosen:
String cards = "";
for(int i = 0; i < 20; i++)
{
Cards card = new Cards();
while(cards.contains(card.toString()))
card = new Cards(); //keep generating a random card until it's a new card
cards += card.toString(); //add the card to the string of cards
System.out.println(card);
}
This code would go inside the main method of your Driver class

First your code has a small mistake
int theRandomNum = randomNum.nextInt(12 + 1)
while, determining from your following code you actually mean
int theRandomNum = randomNum.nextInt(12)+1
To store what cards you already had, you can just introduce a String and fill it step by step, always testing if the card you want to accept is not already contained in this String.
//This goes above the loop where you create your cards
String cards = "";
//This goes into the loop
while(cards.contains(card1.toString()){
card1 = new Cards();
}
cards += card1.toString() + "#"; //Using # as a delimiter
System.out.println(card1);
//At the end you could also print your set of cards
System.out.println(cards);
It's not a very nice approach because you're not permitted to use arrays or similar structures but should do its work.
Please also keep in mind that class names are supposed to be singular. So not Cards but Card.

Looping through array just printing classname#hascode

I am trying to work through an assignment and currently stumped as to what my issue could be. I've read through several post and attempted to resolve without success. I know a lot of my code could be simplified, but this is a progression through the text so a lot of stuff has not yet been covered...
This is my Card class
import java.util.Random;
public class Card {
private int suit,face;
private String cardS,cardF;
// Default constructor to generate random number for face and suit
public Card()
{
Random rand = new Random();
suit = rand.nextInt(4)+1;
face = rand.nextInt(13)+1;
}
// Receive card and suit values
public Card(int cardSuit, int cardFace) {
suit = cardSuit;
face = cardFace;
// Define card face and suit values
if(suit == 1){
cardS = "Clubs";
}
else if(suit == 2){
cardS = "Hearts";
}
else if(suit == 3){
cardS = "Spades";
}
else if(suit == 4){
cardS = "Diamonds";
}
if(face == 1){
cardF = "Ace";
}
else if(face == 2){
cardF = "2";
}
else if(face == 3){
cardF = "3";
}
else if(face == 4){
cardF = "4";
}
else if(face == 5){
cardF = "5";
}
else if(face == 6){
cardF = "6";
}
else if(face == 7){
cardF = "7";
}
else if(face == 8){
cardF = "8";
}
else if(face == 9){
cardF = "9";
}
else if(face == 10){
cardF = "10";
}
else if(face == 11){
cardF = "Jack";
}
else if(face == 12){
cardF = "Queen";
}
else if(face == 13){
cardF = "King";
}
//return cardF + " of " + cardS;
}
// Get numerical face value
public int getNumericFace(){
return face;
}
// Get numerical suit value
public int getNumericSuit(){
return suit;
}
}
This is my DeckOfCards class
public class DeckOfCards {
public static final int MAXDECK = 52;
int remainingDeck,suit,face;
String cardS,cardF;
private int myCard;
int cardIndex;
Card[] cardDeck;
public DeckOfCards() {
cardDeck = new Card[MAXDECK];
// Create array of 52 cards
// outer loop cardSuit
// inner loop cardFace
int index = 0;
int maxSuit = 4;
int maxFace = 13;
for (int cardSuit = 1 ; cardSuit <= maxSuit ; cardSuit++)
{
for (int cardFace = 1 ; cardFace <= maxFace ; cardFace++)
{
cardDeck[index] = new Card(cardSuit,cardFace);
index++;
}
}
}
public String getArray()
{
System.out.println(cardDeck[0]);
for (int i = 0 ; i < cardDeck.length ; i++)
{
System.out.println(cardDeck[i]);
}
return "";
}
public String toString()
{
String deckAsString = "";
int i=0;
for (int s = 1; s <= 4 ; s++)
{
for (int c = 1 ; c <= 13 ; c++ )
{
deckAsString += (cardDeck[i] + "");
i++;
}
deckAsString += "\n";
}
return (deckAsString);
}
}
This is my main class... running both methods here have the issue.
public class MainDeck {
public static void main(String[] args) {
DeckOfCards game = new DeckOfCards();
System.out.println("test getArray method");
System.out.println(game.getArray());
System.out.println("test toString method");
System.out.println(game.toString());
}
}
Thanks for your help!

As your toString method in DeckOfCards is using cardDeck array objects and adding them to the returned String:
deckAsString += (cardDeck[i] + "");
So you need to override toString method in Card class also and use it in string manipulations.

Please implement toString() method in your Card class also.

How to test my Deck class in Java

I would like to print my ArrayList FullDeckArray to see if my Deck has all 52 cards and values.
This is my Card and Deck Classes below
package blackjack;
/**
*
* #author mvisser
*/
public class Card
{
private int rank;
private int suit;
public String tostring(Card card1)
{
String result = "";
if (rank == 1) {
result = "Ace";
}
if (rank == 2) {
result = "Two";
}
if (rank == 3) {
result = "Three";
}
if (rank == 4) {
result = "Four";
}
if (rank == 5) {
result = "Five";
}
if (rank == 6) {
result = "Six";
}
if (rank == 7) {
result = "Seven";
}
if (rank == 8) {
result = "Eight";
}
if (rank == 9) {
result = "Nine";
}
if (rank == 10) {
result = "Ten";
}
if (rank == 11) {
result = "Jack";
}
if (rank == 12) {
result = "Queen";
}
if (rank == 13) {
result = "King";
}
if (suit == 1) {
result = result + " of Clubs ";
}
if (suit == 2) {
result = result + " of Diamonds ";
}
if (suit == 3) {
result = result + " of Hearts ";
}
if (suit == 4) {
result = result + " of Spades ";
}
return result;
}
public Card(int rank, int suit)
{
this.rank = rank;
this.suit = suit;
}
}
As you can see in my Deck Class I hava a ArrayList FullDeckArray and all I want to do is
print it out so see what value is bringing back
public class Deck
{
// private Card[][] fullDeck = new Card[0][0];
private Random shuffle = new Random();
public ArrayList<Card> FullDeckArray = new ArrayList<Card>();
// private int numberOfCards = 52;
public Deck()
{
for (int rank = 1; rank <= 13; rank++) {
for (int suit = 1; suit <= 4; suit++)
{
FullDeckArray.add(new Card(rank, suit));
}
}
}
public void shuffle() {
Collections.shuffle(FullDeckArray);
}
public Card DrawCard() {
int cardPosition = shuffle.nextInt(FullDeckArray.size()+1);
return FullDeckArray.remove(cardPosition);
}
public int TotalCards() {
return FullDeckArray.size();
}
public void test() {
System.out.println( ArrayList<Card>( FullDeckArray ) );
}
}

I would use enums, and with the enum.values() method, you can easily loop through all values of the enumeration.
public class Card {
public enum Rank {
ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING;
public String toString() {
switch(this) {
case ACE: return "Ace";
case TWO: return "Two";
case THREE: return "Three";
case FOUR: return "Four";
case FIVE: return "Five";
case SIX: return "Six";
case SEVEN: return "Seven";
case EIGHT: return "Eight";
case NINE: return "Nine";
case TEN: return "Ten";
case JACK: return "Jack";
case QUEEN: return "Queen";
case KING: return "King";
default: return "ERROR: no valid rank";
}
}
}
public enum Suit {
CLUBS, DIAMONDS, HEARTS, SPADES;
public String toString() {
switch(this) {
case CLUBS: return "Clubs";
case DIAMONDS: return "Diamonds";
case HEARTS: return "Hearts";
case SPADES: return "Spades";
default: return "ERROR: no valid suit";
}
}
}
private Rank rank;
private Suit suit;
public Card(Rank rank, Suit suit) {
this.rank = rank;
this.suit = suit;
}
public String toString() {
return rank.toString() + " of " + suit.toString();
}
public boolean equals(Object other) {
if (!(other instanceof Card)) return false;
Card card = (Card) other;
if (card.rank == this.rank && card.suit == this.suit) return true;
return false;
}
}
while in your deck class, you add all cards with this simple loop:
public void fill() {
for (Rank rank : Card.Rank.values()) {
for (Suit suit : Card.Suit.values()) {
Card card = new Card(rank, suit)
cards.add(card);
System.out.println(card.toString());
}
}
}
The rest of your deck class, you can maintain.
If you want to check for the cards being only added once, you can use a HashSet, as in a set, Objects can only occur once (but you need the equals() method):
HashSet<Card> set = new HashSet<Card>(cards);
cards = new ArrayList<Card>(set);
After that, you can check size with 'cards.size()'.
Update: Here's some code for evading the usage of Arrays in Card and for evading enums:
public class Deck {
private Random shuffle = new Random();
public ArrayList<Card> fullDeck = new ArrayList<Card>();
public Deck() {
for (int rank = 1; rank <= 13; rank++) {
for (int suit = 1; suit <= 4; suit++) {
fullDeck.add(new Card(rank, suit));
}
}
}
public void print() {
String deckOutput = "";
for (Card card : fullDeck) {
deckOutput += card.toString() + "\n";
}
System.out.println(deckOutput);
}
public static void main(String[] args) {
Deck deck = new Deck();
deck.print();
}
}
And for Card, use this:
public class Card {
private int rank;
private int suit;
public Card(int rank, int suit) {
this.rank = rank;
this.suit = suit;
}
public String toString() {
String Srank = "", Ssuit = "";
switch(rank) {
case 1: Srank = "Ace"; break;
case 2: Srank = "Two"; break;
case 3: Srank = "Three"; break;
case 4: Srank = "Four"; break;
case 5: Srank = "Five"; break;
case 6: Srank = "Six"; break;
case 7: Srank = "Seven"; break;
case 8: Srank = "Eight"; break;
case 9: Srank = "Nine"; break;
case 10: Srank = "Ten"; break;
case 11: Srank = "Jack"; break;
case 12: Srank = "Queen"; break;
case 13: Srank = "King"; break;
}
switch(suit) {
case 1: Ssuit = "Clubs"; break;
case 2: Ssuit = "Diamonds"; break;
case 3: Ssuit = "Hearts"; break;
case 4: Ssuit = "Spades"; break;
}
return Srank + " of " + Ssuit;
}
}
To test, you can still use the HashMap/ArrayList method stated above (only if you implement an equals method in Card as well) and check with the fulldeck.size() if there are 52 cards (which will be all different, because of the HashMap).

You should try this
public class DeckTest{
public static void main(String []args){
System.out.println(new Deck().FullDeckArray);
}
}
Your Card class should be like below code
public class Card
{
private int rank;
private int suit;
public String tostring()
{
String result = "";
if (rank == 1) {
result = "Ace";
}
if (rank == 2) {
result = "Two";
}
if (rank == 3) {
result = "Three";
}
if (rank == 4) {
result = "Four";
}
if (rank == 5) {
result = "Five";
}
if (rank == 6) {
result = "Six";
}
if (rank == 7) {
result = "Seven";
}
if (rank == 8) {
result = "Eight";
}
if (rank == 9) {
result = "Nine";
}
if (rank == 10) {
result = "Ten";
}
if (rank == 11) {
result = "Jack";
}
if (rank == 12) {
result = "Queen";
}
if (rank == 13) {
result = "King";
}
if (suit == 1) {
result = result + " of Clubs ";
}
if (suit == 2) {
result = result + " of Diamonds ";
}
if (suit == 3) {
result = result + " of Hearts ";
}
if (suit == 4) {
result = result + " of Spades ";
}
return result;
}
public Card(int rank, int suit)
{
this.rank = rank;
this.suit = suit;
}
}

you should override your tostring method like:
#override
public String toString(Card card1){
.....
}
and should just pass the arraylist name to System.out.println(). there is no need for type of the array list.
hope this helps...

There are two ways to do this: static and dynamic testing. Static is simpler and less prone to error, but it cannot be an action performed for any other purpose other than to simply verify that this part of your program works properly before moving on with the rest. Dynamic testing is slightly more complicated, but you can test a deck whenever you need to (for when the user modifies the deck in some fashion and you must validate it).
Static testing
The static testing method and the simplest way to do this would be to print out all the cards in a deck and verify it manually. To do that, you would first have to make an addition and a correction. First, you should modify the signature of your tostring method in your Card class to be "toString()" without parameters. This overrides the object method toString() which automatically converts an object to a String. Second, you need to override toString() in your Deck class:
#Override
public void toString() {
StringBuilder sb = new StringBuilder();
for(Card card : FullDeckArray) {
sb.append(card); // calls Card class's toString() method automatically.
sb.append('\n'); // newline character after each card
}
return sb.toString();
}
Now all you have to do is use Deck's toString() method.
public void test() {
System.out.println(this); // calls Deck class's toString() method automatically
}
Dyanmic testing
Testing it dynamically is a little more complicated, but not that much. To test this, how would you go about doing it manually? You'd look for missing cards or duplicates. A good way to test such things are Sets. But before you can use Sets, you must first override hashCode() and equals() methods to redefine how a Card class is considered unique. A card is only equal to another if both rank and suit match.
So add these to your Card class:
#Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + rank;
result = prime * result + suit;
return result;
}
#Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Card other = (Card) obj;
if (rank != other.rank)
return false;
if (suit != other.suit)
return false;
return true;
}
Now that we have that, we proceed with the actual logic. A simple test would go something like this:
For each card in your deck
If card is not in set
Add card to set
Else
Flag not valid! Duplicate card!
If set does not have exactly 52 cards
Flag not valid! Extra or missing cards!
So it naturally flows that the the code would then be:
public boolean test() {
boolean valid = true;
Set<Card> cardSet = new HashSet<Card>();
for(Card card : FullDeckArray) {
if(!cardSet.contains(card)) {
cardSet.add(card);
} else {
valid = false;
}
}
if(cardSet.size() != 52) {
valid = false;
}
return valid;
}
Also, you should look here for using enums. In addition to making code more readable, it also allows you to add methods like a class, and like a class, add toString() method. Also see jUnit for a decent testing library for Java.