Java 手中有牌

我目前正在写一个修改版的杜松子酒拉米。我的问题是我对数组是新手，我试图让每个玩家持有我的卡类中生成的5张随机卡。我该怎么做才能在每个玩家的手上随机放5张牌？这是我的卡片课

{  
String suit;  
String rank; 
int score;
int a;  
int b;
final int CARDS_IN_SUIT = 13;
final int SUITS_IN_DECK = 4;
public GinCard(String suit, String rank, int score, int a, int b){
    this.suit = "";
    this.rank = "";
    this.score = 0;
    this.a = 0;
    this.b = 0; 
}
   //Sets up the cards(Suits and ranks)
public GinCard(){           
    switch(a){
    case 1:
        suit = "Clubs";
        break;
    case 2:
        suit = "Diamonds";
        break;
    case 3:
        suit = "Hearts";
        break;
    default:
        suit = "Spades";
        break;
    }
    switch(b){
    case 1:
        rank = "Ace";
        break;
    case 2:
        rank ="2";
        break;
    case 3:
        rank ="3";
        break;
    case 4:
        rank ="4";
        break;
    case 5:
        rank ="5";
        break;
    case 6:
        rank ="6";
        break;  
    case 7:
        rank ="7";
        break;  
    case 8:
        rank ="8";
        break;
    case 9:
        rank ="9";
        break;
    case 10:
        rank ="10";
        break;
    case 11:
        rank = "Jack";
        break;
    case 12:
        rank = "Queen";
        break;
    case 13:
        rank = "King";
        break;
    default:
        break;
        }  

    switch(score){
    case 1:
        score = 15;
        break;
    case 2:
        score = 5;
        break;
    case 3:
        score = 5;
        break;
    case 4:
        score = 5;
        break;
    case 5:
        score = 5;
        break;
    case 6:
        score = 5;
        break;
    case 7:
        score = 5;
        break;
    case 8:
        score = 5;
        break;
    case 9:
        score = 5;
        break;
    case 10:
        score = 5;
        break;
    case 11:
        score = 10;
        break;
    case 12:
        score = 10;
        break;
    case 13:
        score = 10;
        break;

    }
}
//Returns the value of the rank
int getRank(){    
    return b;  
}
//Returns the value of the suit in case of a draw in ranks
int getSuit(){
    return a;   
}  
int getScore(){
    return score;
}
public void deal() 
{
    a = ((int)(Math.random() * 100) % SUITS_IN_DECK + 1);  
    b = ((int)(Math.random() * 100) % CARDS_IN_SUIT + 1);  
}
 } 

这是我目前的主要节目

public class GinRummy {

public static final int CARDS_IN_HAND = 5;

public void RummyHand(){
    int[] hand = new int[CARDS_IN_HAND];

};

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner keyboard = new Scanner(System.in);


    GinCard player = new GinCard();
    GinCard player2 = new GinCard();

Set Set=newhashset（）；
Random randomGenerator=新的Random（）；
while（set.size（）<5）{
set.add（randomGenerator.nextInt（52））；
}

现在这套游戏包含5张玩家所需的独特卡片

---

然后将0-51转换为一副牌中的52张牌，每个玩家有5张牌。

这个简单的解决方案由两类组成。一个是卡类，另一个是卡经理类（经销商）。Card类包含描述其等级、等级和分数的字段。分数是根据排名计算的。顺便说一句，我只在这里留下字符串类型的suit和rank，因为你有这样的东西，你真的应该使用enum来存储这些东西

卡管理器包含业务逻辑。用于处理（或生成）卡的方法创建GinCard类的实例。每个实例只有在没有被添加到任何其他列表（又名，还没有发给任何人）的情况下才会被添加到五张所选卡的列表中，否则它会再次随机添加。方法为每个玩家的手部调用

在“最终经理”课程中，根据玩家手中每张牌的得分总和来评估玩家手牌的得分

卡片类别：

public class GinCard() {

private String suit; 
private String rank;
private int score = 0;

// getters and setters for those 3


public GinCard(final int suit, final int rank) {
    this.suit = getSuitString(suit);
    this.rank = getRankString(rank);
    this.score = getScoreByRank(rank);
}

private int getScoreByRank(final int rank) {
    switch(score){
    case 1:
        return 15;
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        return 5;    
    case 11:
    case 12:
    case 13:
        return 10;
    default: 
        return 0;
    }
}
private String getRankString(final int rank) {
     switch(b){
    case 1:
        return "Ace";
    case 2:
        return "2";        
    case 3:
        return "3";
    case 4:
        return "4";    
    case 5:
        return "5";        
    case 6:
        return "6";        
    case 7:
        return "7";    
    case 8:
        return ="8";  
    case 9:
        return "9";       
    case 10:
        return "10";    
    case 11:  
        return "Jack";    
    case 12:
        return "Queen";
    case 13:
        return "King";
}

private String getSuitString(final int suit) {
  switch(a){
    case 1:
        return "Clubs";
        break;
    case 2:
        return "Diamonds";
        break;
    case 3:
        return "Hearts";
        break;
    default:
        return "Spades";
        break;
   }
}

}

制作一些生成器类：

public class CardManager {

/** Generate one five-card hand */
public List<GinCard> generateHand(final List<GinCard> globallyChosenCards) {
    final Random random = new Random();
    final List<GinCard> currentChosenCards = new ArrayList<GinCard>();
    while(currentChosenCards.size < 5) {
        final int suit = rand.nextInt() * 4 + 1; 
        final int rank = rand.nextInt() * 13 + 1;

        if (!isCardChosen(globallyChosenCards, suit, rank) && !isCardChosen(chosenCards, suit, rank) {
            final GinCard chosenCard = new GinCard(suit, rank);
            currentChosenCards.add(chosenCard);
            globallyChosenCards.add(chosenCard);
        }                                    
    }
    return currentChosenCards;
}

public int evaluateScore(final List<GinCard> hand) {
    final int totalScore = 0;
    for (final GinCard card : hand) {
        totalScore += card.getScore();
    }
    return totalScore;
}

/** Check if card is already chosen by someone */
private boolean isCardChosen(final List<GinCard> chosenCards, final int chosenSuit, final int chosenRank) {
      for (final GinCard chosenCard : chosenCards) {
           if (chosenCard.getSuit().equals(chosenSuit) && chosenCard.getRank().equals(chosenRank)) {
               return true;
           }
      }
      return false;
}

公共类CardManager{
/**生成一张五张牌*/
公共列表生成和（最终列表全球社区）{
最终随机数=新随机数（）；
最终列表currentChosenCards=new ArrayList（）；
而（currentChosenCards.size<5）{
最终整数套装=rand.nextInt（）*4+1；
final int rank=rand.nextInt（）*13+1；
如果（！IsCardSelected（全球社区，套装，等级）和（！IsCardSelected（chosenCards，套装，等级）{
最终金卡选择卡=新金卡（套装、等级）；
currentChosenCards.add（chosenCard）；
globallyChosenCards.add（chosenCard）；
}                                    
}
返回当前选择卡；
}
公共int evaluateScore（最终列表）{
最终整数总分=0；
用于（最终金卡：手）{
totalScore+=card.getScore（）；
}
返回总分；
}
/**检查是否有人已经选择了卡*/
专用布尔值已选择（最终列表选择卡、最终整数选择电路、最终整数选择等级）{
用于（最终金卡chosenCard:chosenCards）{
if（chosenCard.getSuit（）.equals（chosenSuit）和&chosenCard.getRank（）.equals（chosenRank））{
返回true；
}
}
返回false；
}

}

在需要的位置创建对象和调用方法：

final CardManager cardManager = new CardManager();
final List<GinCard> allPlayersCards = new ArrayList<GinCard>();
final List<GinCard> playerOneHand = cardManager.generateHand(allPlayersCards);
final List<GinCard> playerTwoHand = cardManager.generateHand(allPlayersCards);
final int playerOneScore = cardManager.evaluateScore(playerOneHand);
final int playerTwoScore = cardManager.evaluateScore(playerTwoHand);
if (playerOneScore > playerTwoScore) {
    // player one wins
} else if (playerOneScore < playerTwoScore) {
    // player two wins
} else {
    // tie
}

final CardManager CardManager=new CardManager（）；
最终列表allPlayersCards=new ArrayList（）；
最终列表PlayerHand=cardManager.generateHand（所有玩家卡）；
最终列表playerTwoHand=cardManager.generateHand（所有玩家卡）；
最终int PlayerOnScore=cardManager.evaluateScore（PlayerOnHand）；
最终int playerTwoScore=cardManager.evaluateScore（playerTwoHand）；
如果（playerScore>playerWoScore）{
//一号选手获胜
}否则如果（playerScore

---

从理论上讲，它应该可以工作，但还没有尝试过，所以可能会有一些错误和打字错误。当然，它非常简单，例如，你应该使用枚举来表示等级和西装。

你会得到什么错误？如果你没有得到错误，它会输出什么，与你期望的相比呢？到目前为止没有错误。我正在尝试的是放置卡片我只是在学习数组，所以我需要一些关于如何做的指导。不管怎样，您已经为

GinCard

定义了两个构造函数，但都没有做您认为应该做的事情。第一个构造函数将忽略其参数，并将所有内容设置为

0

或

“”

，第二个尝试在实例化成员变量之前引用它们。首先重新考虑构造函数。我建议实现

toString（）

这样你就可以打印你的牌，看看制作后的样子。分数是每张牌的分数。所以基本上A是15分，2-10是5分，杰克、皇后、国王是10分。我的总体目标是为每位玩家抽5张牌，然后谁得分最多，谁就赢。我编辑了答案以考虑分数。

final CardManager cardManager = new CardManager();
final List<GinCard> allPlayersCards = new ArrayList<GinCard>();
final List<GinCard> playerOneHand = cardManager.generateHand(allPlayersCards);
final List<GinCard> playerTwoHand = cardManager.generateHand(allPlayersCards);
final int playerOneScore = cardManager.evaluateScore(playerOneHand);
final int playerTwoScore = cardManager.evaluateScore(playerTwoHand);
if (playerOneScore > playerTwoScore) {
    // player one wins
} else if (playerOneScore < playerTwoScore) {
    // player two wins
} else {
    // tie
}