Comparing cards in a poker game?

Question

OK, so I was here before to ask about help for a Poker program. I got it finished thanks in large part to the people here, so I would like to say thank you very much. Now I'm furthering it by editing the Hand class to display the hand ranks (before it just displayed the hands).
I've easily edited toString to display the rankings, now its just a matter of figuring out how to compare the cards.
Basically, what I need to know is what would be the "best" why to compare the cards. Obviously this needs to be done by getting the card number and, for some rankings, the suit. I'm not sure of exactly how to go about this. If someone could maybe post code for just a pair (only comparing the first 2 cards) I'm sure I could figure out the rest of the rankings. If seeing my code would help (there is Card.java, Deck.java, and Hand.java, the one I'm editing) I will gladly post it. Thank you so much if anyone takes the time to help.

Answer 1

this is probably way overkill for you right now, but here it is anyway. this analyzes a 7 card hand (in texas hold'em style poker). but you can see it really only tests 5 cards at a time for the best hand. hopefully it'll get you started.... i have the source for the rest of my classes too if you'd like to see it....
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
* Created on Feb 22, 2005
* Notes:
* @author MCKNIGDM
public class Hand {
    private static final int ASC  = 1;
    private static final int DESC = 2;
    private Card hole1;
    private Card hole2;
    private Card flop1;
    private Card flop2;
    private Card flop3;
    private Card turn;
    private Card river;
    ArrayList cards;
    Ranking ranking;
    public Hand() {
    public Hand(Card hole1, Card hole2) {
        this.hole1 = hole1;
        this.hole2 = hole2;
    public void setFlop(Card flop1, Card flop2, Card flop3) {
        this.flop1 = flop1;
        this.flop2 = flop2;
        this.flop3 = flop3;
    public void setTurn(Card turn) {
        this.turn = turn;
    public void setRiver(Card river) {
        this.river = river;
    public void rankHand() {
        placeCardsIntoArray();
        boolean suited      = false;
        int suit          = -1;
        // check for at least 5 cards of the same suit
        int count           = 0;
        Iterator itr      = null;
        if(cards.size() >= 5) {
             for(int i=0; i<4; i++) {
                 count      = 0;
                 itr      = cards.iterator();
                 while(itr.hasNext()) { if(((Card) itr.next()).getSuit() == i) count++; }
                 if(count >= 5) {
                     suited = true;
                     suit   = i;
                     break;
        // if suited, the best hands possible are:
        //      - royal flush
        //      - straight flush
        //      - flush
        // so check for those only (the hand can't be any worse than a flush)
        if(suited) {
            // first, remove any unsuited cards from the hand
            for(int i=0; i<cards.size(); i++) {
                if(((Card) cards.get(i)).getSuit() != suit) {
                    cards.remove(i);
                    i--;
            // now order the hand ASC - place the highest cards first
            orderArray(ASC);
            // look for a royal/straight flush
            int start = 0;
            int end = 4;
            do {
                int rank = ((Card) cards.get(start)).getRank();
                boolean straightFlush = false;
                for(int i=start+1; i<=end; i++) {
                    if(((Card) cards.get(i)).getRank() == rank-1) {
                        rank--;
                    } else {
                        break;
                    if(i == end) straightFlush = true;
                if(straightFlush) {
                    // it's either a royal or straight flush
                    ranking = new Ranking((((Card) cards.get(start)).getRank() == 14 ? Ranking.ROYAL_FLUSH : Ranking.STRAIGHT_FLUSH),
                                            (Card) cards.get(start), (Card) cards.get(start+1), (Card) cards.get(start+2), (Card) cards.get(start+3), (Card) cards.get(start+4));
                    return;
                start++;
                end++;
            } while(end < cards.size());
            // check for a low straight (A-2-3-4-5)
            boolean hasAce = ((Card) cards.get(0)).getRank() == Utils.ACE;
            boolean hasTwo = ((Card) cards.get(cards.size()-1)).getRank() == Utils.TWO;
            if(hasAce && hasTwo) {
                boolean hasThree = false;
                boolean hasFour = false;
                boolean hasFive = false;
                int threeIndex = -1;
                int fourIndex = -1;
                int fiveIndex = -1;
                for(int k=1; k<cards.size()-1; k++) {
                    if(((Card) cards.get(k)).getRank() == Utils.THREE) {
                        hasThree = true; threeIndex = k;
                    } else if(((Card) cards.get(k)).getRank() == Utils.FOUR) {
                        hasFour = true; fourIndex = k;
                    } else if(((Card) cards.get(k)).getRank() == Utils.FIVE) {
                        hasFive = true; fiveIndex = k;
                if(hasAce && hasTwo && hasThree && hasFour && hasFive) {
                    ranking = new Ranking(Ranking.STRAIGHT_FLUSH, (Card) cards.get(fiveIndex), (Card) cards.get(fourIndex), (Card) cards.get(threeIndex), (Card) cards.get(cards.size()-1), (Card) cards.get(0));
                    return;
            // at this point, the hand must be a flush
            // since we have all the suited cards and they are in order, just take the first 5
            ranking = new Ranking(Ranking.FLUSH, (Card) cards.get(0), (Card) cards.get(1), (Card) cards.get(2), (Card) cards.get(3), (Card) cards.get(4));
            return;
        } // end of the suited-only rankings
        // check for four of a kind
        if(checkFourKind()) return;
        // check for full house
        if(checkFullHouse()) return;
        // check for straight
        if(checkStraight()) return;
        // check for three of a kind
        if(checkThreeKind()) return;
        // check for two pair
        if(checkTwoPair()) return;
        // check for a pair
        if(checkPair()) return;
        // check for high card
        checkHighCard();
    private boolean checkHighCard() {
        Card card1 = null;
        Card card2 = null;
        Card card3 = null;
        Card card4 = null;
        Card card5 = null;
        for(int j=0; j<cards.size(); j++) {
            if(card1 == null) {
                card1 = ((Card) cards.get(j)); continue;
            } else {
                if(card1.getRank() < ((Card) cards.get(j)).getRank()) {
                    card1 = ((Card) cards.get(j)); continue;
            if(card2 == null) {
                card2 = ((Card) cards.get(j)); continue;
            } else {
                if(card2.getRank() < ((Card) cards.get(j)).getRank()) {
                    card2 = ((Card) cards.get(j)); continue;
            if(card3 == null) {
                card3 = ((Card) cards.get(j)); continue;
            } else {
                if(card3.getRank() < ((Card) cards.get(j)).getRank()) {
                    card3 = ((Card) cards.get(j)); continue;
            if(card4 == null) {
                card4 = ((Card) cards.get(j)); continue;
            } else {
                if(card4.getRank() < ((Card) cards.get(j)).getRank()) {
                    card4 = ((Card) cards.get(j)); continue;
            if(card5 == null) {
                card5 = ((Card) cards.get(j)); continue;
            } else {
                if(card5.getRank() < ((Card) cards.get(j)).getRank()) {
                    card5 = ((Card) cards.get(j)); continue;
        ranking = new Ranking(Ranking.HIGH_CARD, card1, card2, card3, card4, card5);
        return true;
    private boolean checkPair() {
        int pairRank   = -1;
        int count;
        // look for the largest pair
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count == 2) {
                pairRank = i;
        if(pairRank == -1) return false;
        // we have a pair -- get the pair and the 3 kickers
        Card card1 = null;
        Card card2 = null;
        Card card3 = null;
        Card card4 = null;
        Card card5 = null;
        for(int j=0; j<cards.size(); j++) {
            if(((Card) cards.get(j)).getRank() == pairRank) {
                if     (card1 == null) card1 = (Card) cards.get(j);
                else if(card2 == null) card2 = (Card) cards.get(j);
                continue;
            if(((Card) cards.get(j)).getRank() != pairRank) {
                if(card3 == null) {
                    card3 = ((Card) cards.get(j)); continue;
                } else {
                    if(card3.getRank() < ((Card) cards.get(j)).getRank()) {
                        card3 = ((Card) cards.get(j)); continue;
                if(card4 == null) {
                    card4 = ((Card) cards.get(j)); continue;
                } else {
                    if(card4.getRank() < ((Card) cards.get(j)).getRank()) {
                        card4 = ((Card) cards.get(j)); continue;
                if(card5 == null) {
                    card5 = ((Card) cards.get(j)); continue;
                } else {
                    if(card5.getRank() < ((Card) cards.get(j)).getRank()) {
                        card5 = ((Card) cards.get(j)); continue;
        ranking = new Ranking(Ranking.PAIR, card1, card2, card3, card4, card5);
        return true;
    private boolean checkTwoPair() {
        int pair1Rank   = -1;
        int pair2Rank   = -1;
        int count;
        // look for the largest pair
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count == 2) {
                pair1Rank = i;
        if(pair1Rank == -1) return false;
        // look for the largest pair
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            if(i == pair1Rank) continue;
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count == 2) {
                pair2Rank = i;
        if(pair2Rank == -1) return false;
        // we have two pair -- get the pairs and the highest kicker
        Card card1 = null;
        Card card2 = null;
        Card card3 = null;
        Card card4 = null;
        Card card5 = null;
        for(int j=0; j<cards.size(); j++) {
            if(((Card) cards.get(j)).getRank() == pair1Rank) {
                if     (card1 == null) card1 = (Card) cards.get(j);
                else if(card2 == null) card2 = (Card) cards.get(j);
                continue;
            if(((Card) cards.get(j)).getRank() == pair2Rank) {
                if     (card3 == null) card3 = (Card) cards.get(j);
                else if(card4 == null) card4 = (Card) cards.get(j);
                continue;
            if(((Card) cards.get(j)).getRank() != pair1Rank && ((Card) cards.get(j)).getRank() != pair2Rank) {
                if(card5 == null) {
                    card5 = ((Card) cards.get(j));
                } else {
                    if(card5.getRank() < ((Card) cards.get(j)).getRank()) {
                        card5 = ((Card) cards.get(j));
        ranking = new Ranking(Ranking.TWO_PAIR, card1, card2, card3, card4, card5);
        return true;
    private boolean checkStraight() {
        orderArray(ASC);
        int start = 0;
        int end = 4;
        do {
            int rank = ((Card) cards.get(start)).getRank();
            boolean straight = false;
            for(int i=start+1; i<=end; i++) {
                if(((Card) cards.get(i)).getRank() == rank-1) {
                    rank--;
                } else {
                    break;
                if(i == end) straight = true;
            if(straight) {
                ranking = new Ranking(Ranking.STRAIGHT, (Card) cards.get(start), (Card) cards.get(start+1), (Card) cards.get(start+2), (Card) cards.get(start+3), (Card) cards.get(start+4));
                return true;
            start++;
            end++;
        } while(end < cards.size());
        // check for a low straight (A-2-3-4-5)
        boolean hasAce = ((Card) cards.get(0)).getRank() == Utils.ACE;
        boolean hasTwo = ((Card) cards.get(6)).getRank() == Utils.TWO;
        if(hasAce && hasTwo) {
            boolean hasThree = false;
            boolean hasFour = false;
            boolean hasFive = false;
            int threeIndex = -1;
            int fourIndex = -1;
            int fiveIndex = -1;
            for(int k=1; k<cards.size()-1; k++) {
                if(((Card) cards.get(k)).getRank() == Utils.THREE) {
                    hasThree = true; threeIndex = k;
                } else if(((Card) cards.get(k)).getRank() == Utils.FOUR) {
                    hasFour = true; fourIndex = k;
                } else if(((Card) cards.get(k)).getRank() == Utils.FIVE) {
                    hasFive = true; fiveIndex = k;
            if(hasAce && hasTwo && hasThree && hasFour && hasFive) {
                ranking = new Ranking(Ranking.STRAIGHT, (Card) cards.get(fiveIndex), (Card) cards.get(fourIndex), (Card) cards.get(threeIndex), (Card) cards.get(6), (Card) cards.get(0));
                return true;
        return false;
    private boolean checkFourKind() {
        orderArray(ASC);
        int start = 0;
        int end = 4;
        do {
            int rank = ((Card) cards.get(start)).getRank();
            boolean fourKind = false;
            for(int i=start+1; i<=end-1; i++) {
                if(((Card) cards.get(i)).getRank() == rank) {
                } else {
                    break;
                if(i == (end-1)) fourKind = true;
            if(fourKind) {
                ranking = new Ranking(Ranking.FOUR_KIND, (Card) cards.get(start), (Card) cards.get(start+1), (Card) cards.get(start+2), (Card) cards.get(start+3), (Card) cards.get((start == 0 ? 4 : 0)));
                return true;
            start++;
            end++;
        } while(end < cards.size()+1);
        return false;
    private boolean checkThreeKind() {
        int setRank   = -1;
        int count;
        // look for the largest set
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count == 3) {
                setRank = i;
        if(setRank == -1) return false;
        // we have a set -- get the 5 cards for the ranking
        Card card1 = null;
        Card card2 = null;
        Card card3 = null;
        Card card4 = null;
        Card card5 = null;
        for(int j=0; j<cards.size(); j++) {
            if(((Card) cards.get(j)).getRank() == setRank) {
                if     (card1 == null) card1 = (Card) cards.get(j);
                else if(card2 == null) card2 = (Card) cards.get(j);
                else if(card3 == null) card3 = (Card) cards.get(j);
            if(((Card) cards.get(j)).getRank() != setRank) {
                if(card4 == null) {
                    card4 = (Card) cards.get(j);
                    continue;
                } else {
                    if(card4.getRank() < ((Card) cards.get(j)).getRank()) {
                        card4 = ((Card) cards.get(j));
                        continue;
                if(card5 == null) {
                    card5 = (Card) cards.get(j);
                } else {
                    if(card5.getRank() < ((Card) cards.get(j)).getRank()) {
                        card5 = ((Card) cards.get(j));
        ranking = new Ranking(Ranking.THREE_KIND, card1, card2, card3, card4, card5);
        return true;     
    private boolean checkFullHouse() {
        int setRank   = -1;
        int pairRank   = -1;
        int count;
        // look for the largest set
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count == 3) {
                setRank = i;
        if(setRank == -1) return false;
        // look for the largest pair
        for(int i=Utils.TWO; i<=Utils.ACE; i++) {
            if(i == setRank) continue;
            count = 0;
            for(int j=0; j<cards.size(); j++) {
                if(((Card) cards.get(j)).getRank() == i) {
                    count++;
            if(count >= 2) {
                pairRank = i;
        if(pairRank == -1) return false;
        // we have a full house -- get the 5 cards for the ranking
        Card card1 = null;
        Card card2 = null;
        Card card3 = null;
        Card card4 = null;
        Card card5 = null;
        for(int j=0; j<cards.size(); j++) {
            if(((Card) cards.get(j)).getRank() == setRank) {
                if     (card1 == null) card1 = (Card) cards.get(j);
                else if(card2 == null) card2 = (Card) cards.get(j);
                else if(card3 == null) card3 = (Card) cards.get(j);
            if(((Card) cards.get(j)).getRank() == pairRank) {
                if     (card4 == null) card4 = (Card) cards.get(j);
                else if(card5 == null) card5 = (Card) cards.get(j);
        ranking = new Ranking(Ranking.FULL_HOUSE, card1, card2, card3, card4, card5);
        return true;
    public void placeCardsIntoArray() {
        cards = new ArrayList();
        if(hole1 != null) cards.add(hole1);
        if(hole2 != null) cards.add(hole2);
        if(flop1 != null) cards.add(flop1);
        if(flop2 != null) cards.add(flop2);
        if(flop3 != null) cards.add(flop3);
        if(turn  != null) cards.add(turn);
        if(river != null) cards.add(river);
    public void orderArray(int order) {
        TreeSet set = new TreeSet(new Comparator() {
            public int compare(Object obj1, Object obj2) {
                Card c1 = (Card) obj1;
                Card c2 = (Card) obj2;
                if(c1.getRank() > c2.getRank()) {
                    return -1;
                } else if(c1.getRank() <= c2.getRank()) {
                    return 1;
                } else {
                    return 0;
        // add the cards to the tree set and remove from array
        while(cards.size() >= 1) {
            set.add(cards.get(0));
            cards.remove(0);
        // put the cards from the set into the array
        cards.addAll(set);
        if(order == DESC) {
            Collections.reverse(cards);
    public void printHand() {
        placeCardsIntoArray();
        orderArray(ASC);
        Iterator itr = cards.iterator();
        while(itr.hasNext()) {
            Card c = ((Card) itr.next());
            if(c.getRank() == hole1.getRank() && c.getSuit() == hole1.getSuit()) {
                System.out.println(c.getName() + " (h1)");
            } else if(c.getRank() == hole2.getRank() && c.getSuit() == hole2.getSuit()) {
                System.out.println(c.getName() + " (h2)");
            } else {
                System.out.println(c.getName());
    public void printRanking() {
        if(ranking == null) System.out.println("Null ranking...");
        else ranking.printRanking();
    public Card getFlop1() {
        return flop1;
    public void setFlop1(Card flop1) {
        this.flop1 = flop1;
    public Card getFlop2() {
        return flop2;
    public void setFlop2(Card flop2) {
        this.flop2 = flop2;
    public Card getFlop3() {
        return flop3;
    public void setFlop3(Card flop3) {
        this.flop3 = flop3;
    public Card getHole1() {
        return hole1;
    public void setHole1(Card hole1) {
        this.hole1 = hole1;
    public Card getHole2() {
        return hole2;
    public void setHole2(Card hole2) {
        this.hole2 = hole2;
    public Card getRiver() {
        return river;
    public Card getTurn() {
        return turn;
    public Ranking getRanking() {
        return ranking;
}