• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 579
  • Last Modified:

How do I write a method to win in blackjack?

Here are my Card, DeckOfCards, and TwoPlayerBlackJack classes:

TwoPlayerBlackJack class:

import java.util.ArrayList;
/**
 * Write a description of class TwoPlayerBlackJack here.
 *
 * @author (your name)
 * @version (a version number or a date)
 */
public class TwoPlayerBlackJack
{
   
    private String rank;
    private ArrayList<Card> blackJack;
    private char suit;
   
    /**
     * Constructor for objects of class TwoPlayerBlackJack
     */
    public TwoPlayerBlackJack()
    {
       String[] ranks = Card.getPossibleRanks();
       char[] suites = Card.getPossibleSuits();
       blackJack = new ArrayList<Card>();
  for (int i = 0; i < Card.getPossibleRanks().length ; i++)
       {
           for (int j = 0; j < Card.getPossibleSuits().length; j++)
           {
              blackJack.add(new Card(ranks, suites[j]));
           }
       }
    }

    /**
     * The method takes an object of class Card and return an integer that represents the value of that card.
     * The values of the cards are determines as follows:
     * two is 2, three is 3, ...., nine is 9, ten is 10,  jacks, queens and kings are all 10.
     * Ace could be either 1 or 11 but for this method we will assume that the value Ace is always 1
     */
    public int getCardValue(Card c){
String rank = c.getRank();

int value = -1;
try {
value = new Integer(rank);
}catch(Exception ex){
if(rank.equals("Ace"))value = 1;
else{ value = 10;

}

}
return value;
}

/**
 * Given a hand cards (i.e. ArrayList of Cards) return an integer value that corresponds to the hand value
 * (i.e. sum of all card values).
 */
public int computeHandValue(ArrayList <Card> hand)
{
 
int sum = 0;
int numAces = 0;

for(Card c: hand){
  int value = getCardValue(c);
   sum += value;
 if(c.getRank().equals("Ace"))
 numAces++;

}
 if(sum<12 && numAces >0)sum += 10;  
   
    return sum;

}

/**
 * Method display hand value display the value of each card followed by the hand value
 */
public void printHandValue(ArrayList <Card> hand)
{
    System.out.println(computeHandValue(hand));
}

/**
 * Method that takes two Array Lists of Cards (i.e. two card hands) and determines the winner
 * of the BlackJack game.
 * 1 – the first hand won the game
 * 0 – nobody won, it is a push
 * -1 – the first hand lost the game
 */
public int isWinner(ArrayList <Card> hand01, ArrayList <Card> hand02)
{

if(computeHandValue(hand01)==computeHandValue(hand02)){
return 0;

if(computeHandValue(hand01)>computeHandValue(hand02)&&(computeHandValue(hand01)<=21))
return 1;

if(computeHandValue(hand01)<computeHandValue(hand02)&&(computeHandValue(hand02)<=21))
return 1;

if((computeHandValue(hand01)&&computeHandValue(hand02))>21)
return 0;

if((computeHandValue(hand01) <= 21) && (computeHandValue(hand02) >= 21))
return -1;

if((computeHandValue(hand02) <= 21) && (computeHandValue(hand01) >= 21))
return -1;
}
}

DeckOfCards:

import java.util.Random;
import java.util.ArrayList;
public class DeckOfCards
{
    private ArrayList<Card> deck;
    Random getRandom = new Random();
   
    /**
     * Default constructor creates an Array List of Cards and populates it with 52 different cards
     */
    public DeckOfCards()
    {
        deck = new ArrayList<Card>();
        resetDeckOfCards();
    }

    /**
     * Remove all leftover cards from the ArrayList of Cards called deck
     * Populate an empty deck with 52 new cards...
     */
    public void resetDeckOfCards()
    {
       String[] ranks = Card.getPossibleRanks();
       char[] suites = Card.getPossibleSuits();

  for (int i = 0; i < Card.getPossibleRanks().length ; i++)
       {
           for (int j = 0; j < Card.getPossibleSuits().length; j++)
           {
              deck.add(new Card(ranks, suites[j]));
           }
       }
    }

    /**
     * Remove random card of arraylist of cards and return value from method
     */
    public Card getCard()
    {
       if (deck.isEmpty())
            resetDeckOfCards();
       return deck.remove(getRandom.nextInt(deck.size()));
    }

    /**
     * Return an ArrayList of specified size (i.e. returned cards are being removed from the deck).
     */
    public ArrayList<Card> getHand(int size)
    {
        ArrayList<Card> hand = new ArrayList<Card>();
        for (int i = 0; i < size; i++)
        {
            hand.add(this.getCard());
        }
        return hand;
       
    }

}

Card class:

public class Card
{
   
    private String rank;//card rank: a number between 2 and 10, or Jack, Queen, King or Ace
    private char suit;//card suit: S,C,H,or D
    private static String[] Ranks={"2","3","4","5","6","7","8","9","10","Jack","Queen","King","Ace"};
    private static char[] Suites={'C','H','D','S'};
     
    /**
     * Default constructor: sets card rank to 2 and card suit to H
     */
    public Card()
    {
        rank="2";
        suit='H';
       
    }
   
    /**
     * Class constructor: sets card rank and suit to provided values.
     */
    public Card(String rank, char suit)
    {
        this.rank=rank;
        this.suit=suit;
    }
   
    /**
     * Gets the rank
     */
    public String getRank()
    {
        return rank;
    }
   
    /**
     * Gets the suit
     */
    public char getSuit()
    {
        return suit;
    }
   
    /**
     * Sets the rank
     */
    public void setRank(String rank)
    {
        this.rank=rank;
    }
   
    /**
     * Sets the suit
     */
    public void setSuit(char suit)
    {
        this.suit=suit;
    }
    /**
     * Returns an array of possible card ranks
     */
    public static String[] getPossibleRanks()
    {
        return Ranks;
    }
    /**
     * Returns an array of possible card suits
     */
   
    public static char[] getPossibleSuits()
    {
        return Suites;
    }
   
    /**
     * Returns string representation of the card that looks as follows:
     * 2 of Hearts, 3 of Spades, Jack of Diamonds, etc.
     */
    public String toString()
    {String suitName = "";
        switch (suit){
        case 'H':
         suitName = rank + " of Hearts";
            break;
         case 'S':
            suitName = rank + " of Spades";
             break;
              case 'D':
                suitName = rank + " of Diamonds";
                  break;
                  case 'C':
                   suitName = rank + " of Clubs";


    }
return suitName;
}
}
0
ryanbecker24
Asked:
ryanbecker24
  • 5
  • 3
1 Solution
 
for_yanCommented:
So waht do you want to get in response to this question ?
0
 
ryanbecker24Author Commented:
How to write a isWinner of my TwoPlayerBlackJack class using the ArrayList parameters and return the winner, loser, and tie (1,-1,0, respectively)
0
 
for_yanCommented:
But you have such method there?
0
VIDEO: THE CONCERTO CLOUD FOR HEALTHCARE

Modern healthcare requires a modern cloud. View this brief video to understand how the Concerto Cloud for Healthcare can help your organization.

 
ryanbecker24Author Commented:
I don't think this is right so thats why I want help

/**
 * Method that takes two Array Lists of Cards (i.e. two card hands) and determines the winner
 * of the BlackJack game.
 * 1 – the first hand won the game
 * 0 – nobody won, it is a push
 * -1 – the first hand lost the game
 */
public int isWinner(ArrayList <Card> hand01, ArrayList <Card> hand02)
{

if(computeHandValue(hand01)==computeHandValue(hand02)){
return 0;

if(computeHandValue(hand01)>computeHandValue(hand02)&&(computeHandValue(hand01)<=21))
return 1;

if(computeHandValue(hand01)<computeHandValue(hand02)&&(computeHandValue(hand02)<=21))
return 1;

if((computeHandValue(hand01)&&computeHandValue(hand02))>21)
return 0;

if((computeHandValue(hand01) <= 21) && (computeHandValue(hand02) >= 21))
return -1;

if((computeHandValue(hand02) <= 21) && (computeHandValue(hand01) >= 21))
return -1;
}
}

0
 
yo_beeDirector of ITCommented:
Why is no one using the code window?
0
 
for_yanCommented:

I don't think your method is right eirther

Assuming that compueHadnValue is right
(it is tricky to treat Ace, - I'm not sure this part is correct, but anyway);
I think this code should be better (maybe not - I'm not specialits in Blacvkjack):
public int isWinner(ArrayList <Card> hand01, ArrayList <Card> hand02)
{

if(computeHandValue(hand01) > 21) return -1;

if(computeHandValue(hand02)  > 21) return 1;

if(computeHandValue(hand01) > computeHandValue(hand02)) return 1;
else  if(computeHandValue(hand01) == computeHandValue(hand02)) return 0;
else return -1;
} 

Open in new window

0
 
for_yanCommented:
Actually in real game there can never be the situation when both > 21
in this method it is possible - so it is not defined who will be the winner in this case.
The above method  assumes that hand01 will lose in this case
0
 
ryanbecker24Author Commented:
Thank you!
0
 
for_yanCommented:
Actually if hand01 is the player and hand02 is the dealer then I guess, as soon as hand01 becomes > 21
then player loses no matter what the dealer will get - so in this sense the above method is right
0

Featured Post

Free Tool: ZipGrep

ZipGrep is a utility that can list and search zip (.war, .ear, .jar, etc) archives for text patterns, without the need to extract the archive's contents.

One of a set of tools we're offering as a way to say thank you for being a part of the community.

  • 5
  • 3
Tackle projects and never again get stuck behind a technical roadblock.
Join Now