Question

我是一位在学校编写代码的朋友给了我这个项目，但我正在努力寻找一种更好的编码方式。它调用不同的布尔方法，检查是否为真，并为后一次使用添加计数。

public static void testHand(PokerHand d) {
    if (d.isRoyalFlush()) {
        royalFlush++;
    } else if (d.isStraightFlush()) {
        straightFlush++;
    } else if (d.is4OfAKind()) {
        fourtOfAKind++;
    } else if (d.isFullHouse()) {
        fullHouse++;
    } else if (d.isFlush()) {
        flush++;
    } else if (d.isStraight()) {
        straight++;
    } else if (d.is3OfAKind()) {
        threeOfAKind++;
    } else if (d.is2Pair()) {
        twoPair++;
    } else if (d.isPair()) {
        pair++;
    } else if(d.isHighCard()){
        highCard++;
    }
}

PokerHand的代码如下：

公共课PokerHand {

private Card[] hand;        // the hand of 5 cards

// the default constructor
public PokerHand() {
    hand = new Card[5];
}

// A constructor to help with testing
public PokerHand(Card c0, Card c1, Card c2, Card c3, Card c4) {
    hand = new Card[5];
    hand[0] = c0;
    hand[1] = c1;
    hand[2] = c2;
    hand[3] = c3;
    hand[4] = c4;
}

/* This methods fills the hand with cards from the deck.
   It uses an insertion sort so that the cards are ordered by rank.*/
public void fillHand(Deck deck) {
    for (int i = 0; i < 5; i++) {
        int j = i - 1;
        Card temp = deck.dealCard();
        while (j >= 0 && hand[j].getRank() > temp.getRank()) {
            hand[j + 1] = hand[j];
            j--;
        }
        hand[j + 1] = temp;
    }
}

//PLACE ADDITIONAL METHODS AFTER THIS COMMENT

/*Checking for Royal flush by first checking if straight flush
and then if highest card is an Ace.*/
public boolean isRoyalFlush() {
    return (isStraightFlush() && hand[4].getRank() == 14);
}

//Check for Straight Flush by seeing if it is both a straight and a flush
public boolean isStraightFlush() {
    return (isFlush() && isStraight());
}

/*Checking if hand is a Four-of-a-kind. Done by looking at first card and
checking if it equals next 3 cards. If not, then checking second card and
checking if it equals next three cards.*/
public boolean is4OfAKind() {
    boolean isFour = false;
    for (int i = 0; i < hand.length - 3; i++) {
        int card = hand[i].getRank();
        if (card == hand[i + 1].getRank()
                && card == hand[i + 2].getRank()
                && card == hand[i + 3].getRank()) {
            isFour = true;
        }
    }
    return isFour;
}

//Checking if hand holds a Full House By:
public boolean isFullHouse() {

    //Setting two boolean values
    boolean a1, a2;

    //First checking if it is a pair followed by a 3-of-a-kind.
    a1 = hand[0].getRank() == hand[1].getRank() && 
            hand[2].getRank() ==hand[3].getRank() && hand[3].getRank() == hand[4].getRank();

    //Second, checking if it is 3-of-a-cind followed by a pair
    a2 = hand[0].getRank() == hand[1].getRank() && hand[1].getRank() == hand[2].getRank() &&
            hand[3].getRank() == hand[4].getRank();

    //Returns true if it is either.
    return (a1 || a2);
}

/*Checking if hand is a Flush by first getting the first card's suit
and checking if it is the same for all cards.*/
public boolean isFlush() {
    String suit = hand[0].getSuit();
    return hand[1].getSuit().equals(suit)
            && hand[2].getSuit().equals(suit)
            && hand[3].getSuit().equals(suit)
            && hand[4].getSuit().equals(suit);
}

/*Checking id hand is a Straight by first getting the rank of the first
card, then checking if the following cards are incremented by 1*/
public boolean isStraight() {
    int card = hand[0].getRank();
    return (hand[1].getRank() == (card + 1) &&
            hand[2].getRank() == (card + 2) &&
            hand[3].getRank() == (card + 3) &&
            hand[4].getRank() == (card + 4));
}

/*Checking if hand is a Three-of-a-kind. Done by looking at first card and
checking if it equals next 2 cards. If not, then checking next card and
checking if it equals next 2 cards. This is done three times in total.*/
public boolean is3OfAKind() {
    boolean threeKind = false;
    for (int i = 0; i < hand.length - 2; i++) {
        int card = hand[i].getRank();
        if (card == hand[i + 1].getRank() &&
                card == hand[i + 2].getRank()) {
            threeKind = true;
        }
    }
    return threeKind;
}

//Checking hand for 2 pairs by:
public boolean is2Pair() {
    int count = 0; // Number of pairs.
    int firstPair = 0; //If pair found, store rank.

    //Go through hand
    for (int i = 0; i < hand.length - 1; i++) {
        int card = hand[i].getRank();
        //Finding pairs. Cannot be same rank pairs.
        if (card == hand[i + 1].getRank() && card != firstPair) {
            firstPair = card;
            count++;
        }
    }
    return count == 2;
}

/*Checking if hand is a Pair. Done by looking at first card and
checking if it equals the next card. If not, then it checks the next card and
sees if it equals the next card. This is done four times in total.*/
public boolean isPair() {
    boolean isPair = false;
    for (int i = 0; i < hand.length - 1; i++) {
        int card = hand[i].getRank();
        if (card == hand[i + 1].getRank()) {
            isPair = true;
        }
    }
    return isPair;
}

//If hand is not equal to anything above, it must be High Card.
public boolean isHighCard() {
    return !(isRoyalFlush() || isStraightFlush() || is4OfAKind() 
            || isFullHouse() || isFlush() || isStraight()
            || is3OfAKind() || is2Pair() || isPair());
}

}

Answer 1

您可以使用ternary operator ? :缩短代码。像

public static void testHand(PokerHand d) {
    royalFlush += d.isRoyalFlush() ? 1 : 0;
    straightFlush += d.isStraightFlush() ? 1 : 0;
    fourtOfAKind += d.is4OfAKind() ? 1 : 0; // <-- this appears to be a typo.
    fullHouse += d.isFullHouse() ? 1 : 0;
    flush += d.isFlush() ? 1 : 0;
    straight += d.isStraight() ? 1 : 0;
    threeOfAKind += d.is3OfAKind() ? 1 : 0;
    twoPair += d.is2Pair() ? 1 : 0;
    pair += d.isPair() ? 1 : 0;
    highCard += d.isHighCard() ? 1 : 0;
}

或者，您可以使用enum对手型进行编码。给PokerHand一个HandType（或创建工厂方法）。像，

enum HandType {
    ROYALFLUSH, STRAIGHTFLUSH, FOUROFAKIND, FULLHOUSE, FLUSH,
    STRAIGHT, THREEOFAKIND, TWOPAIR, PAIR, HIGHCARD;

    static HandType fromHand(PokerHand d) {
        if (d.isRoyalFlush()) {
            return ROYALFLUSH;
        } else if (d.isStraightFlush()) {
            return STRAIGHTFLUSH;
        } else if (d.is4OfAKind()) {
            return FOUROFAKIND;
        } else if (d.isFullHouse()) {
            return FULLHOUSE;
        } else if (d.isFlush()) {
            return FLUSH;
        } else if (d.isStraight()) {
            return STRAIGHT;
        } else if (d.is3OfAKind()) {
            return THREEOFAKIND;
        } else if (d.is2Pair()) {
            return TWOPAIR;
        } else if (d.isPair()) {
            return PAIR;
        } else {
            return HIGHCARD;
        }
    }
}

然后您可以为testHand创建一个计数数组，例如

private static int[] handCounts = new int[HandType.values().length];
public static void testHand(PokerHand d) {
    handCounts[HandType.fromHand(d)]++;
}

Answer 2

我建议你将潜在的手牌建模为enum。它们是一个很好的用例，因为它们有一组固定的成员。

如下所示：

enum Rank {
    ROYAL_FLUSH(Hand::isRoyalFlush),
    FOUR_OF_A_KIND(Hand::isFourOfAKind),
    ...

    public static Rank getRank(Hand hand) {
        for (Rank rank: values()) {
            if (rank.test.test(hand))
                return rank;
        }
        throw new IllegalStateException("No rank for hand " + hand.toString());
    }

    private final Predicate<Hand> test;
    Rank(Predicate<Hand> test) {
        this.test = test;
    }
}

然后，所有if语句都可以替换为Rank.getRank(hand)。

Answer 3

也许switch语句符合您的需求：

array_intersect

寻找一个更好的java OO方法来处理很多布尔if else语句

3 个答案: