一包扑克牌、方法难度以及 Pack 和 PlayingCard 类

Question

我必须开发一个名为Pack 的类，它需要能够生成按Suit 和Rank 排序的一包52 张扑克牌。它还需要能够用另一种方法洗牌。最后，它必须返回该卡片包的String 表示。

这是一个问题，我必须以某种方式使用我已经完成的另一个类PlayingCard，这个Pack 类。这就是我遇到死胡同的时候，我无法弄清楚我使用的数组中的牌洗牌的方法，并且由于不兼容问题我无法使用PlayingCard。

这是当前的包类：

import java.util.Random;

public class Pack {
    int[] cards = new int[52];

    public Pack() {
        // Setting up array
        String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
        String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};

        // Intialising array
        {    
            for (int i = 0; i < cards.length; i++) {
                cards[i] = i;
            }
        }
    }

    public void shuffle() {
        for (int i = 0; i < 52; i++) {
            Random random = new Random();
            int rand = random.nextInt(50)+1;
            cards[i] = rand;
        }
    }

    @Override
    public String toString() {
        return getClass().getName() + "[suit[]= " + suit[] + "rank[]= " + rank[] + "]";
    }
}

这是另一个基于建议的 Pack 类，请注意缺少 toString()：

import java.util.Random;

public class Pack {
    PlayingCard[] cards = new PlayingCard[52];

    public Pack() {
        // Setting up array
        String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
        String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};

        // Initialising array
        for (int i = 0; i < cards.length; i++) {
            cards[i] = i;
        }   
    }

    public void shuffle() {
        for (int i = 0; i < 52; i++) {
            Random random = new Random();
            int rand = random.nextInt(50) + 1;
            cards[i] = rand;   // Error 3
        }
    }

    @Override
    public String toString() {

这是我一直在使用的模板：

Using the class PlayingCard develop another class called Pack. 
An outline for this class is provided below:
public class Pack
{
PlayingCard[] cards = new PlayingCard[];
/**
* Constructs a pack of 52 cards.
* Sorted by suit Clubs, Diamonds, Hearts, Spades.
* Sorted ascending.
*/
public Pack()
{
}
/**
* Shuffles cards in pack.
*/
public void shuffle()
{
}
/**
* @return string representation of 52 card pack.
*/
public String toString()
{
}
}

最后，这是 Pack 必须以某种方式使用的 PlayingCard 类。

import java.util.Objects;

public class PlayingCard {
    private Rank rank;
    private Suit suit;

    public PlayingCard(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public Rank getRank() {   
        System.out.println(rank);
        return rank;
    }

    public Suit getSuit() {
        System.out.println(suit);
        return suit;
    }

    public String toString() {
        return getClass().getName() + "[rank= " + rank + "suit= " + suit + "]";
    }

    public void format() {
        System.out.format(rank + " OF " + suit);
        System.out.println();
    }

    @Override
    public boolean equals(Object otherObject) {
        if (otherObject == null) {
            return false;
        }

        if (!(otherObject instanceof PlayingCard)) {
            return false;
        }

        if (this == otherObject) {
            return true;
        }

        PlayingCard other = (PlayingCard) otherObject;
        return suit.equals(other.suit) && rank == other.rank;
    }

    @Override
    public int hashCode() {
        return Objects.hash(suit, rank);
    }
}

那么，我如何将 PlayingCard 类与 Pack 一起使用，以及如何让 Pack 中的 shuffle 类与我的数组等一起使用，因为目前它所要实现的只是将随机数放入卡片数组中.

如果需要更多信息，请告诉我，我会添加。

编辑 1：

针对第一个答案，这里是仅用于显示潜在问题的套装枚举，以及我在答案之前所做的当前版本的 Pack。它是如何保持的？

枚举：

public enum Suit 
{
    SPADES(-2), CLUBS(-1), HEARTS(0), DIAMONDS(1);

    private int value;

    private Suit(int value)
    {
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }
}

更新包：

import java.util.Random;

public class Pack
{
    int[] cards = new int[52];

    public void Deck()
    {
        // Setting up array
        String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
        String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", 
            "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};

        // Intialising array
        {    
            for (int i = 0; i < cards.length; i++)
            {
                cards[i] = i;
            }
        }
   }

   public void shuffle()
   {
        for (int i = 0; i < 52; i++)
        {
            Random random = new Random();
            int rand = random.nextInt(50)+1;
            int temp = cards[i];
            cards[i] = cards[rand];
            cards[rand] = temp;
        }
    }

    @Override
    public String toString()
    {
        return 
    }
}

Answer 1

注意PlayingCard 类中的Rank 和Suit。提示定义 2 个枚举类（仅显示 Suit 类）：

public enum Suit {
   SPADE("Spade"),
   HEART("Heart"),
   DIAMOND("Diamond"),
   CLUB("Club");

   private String name;
   private Suit(String name) { this.name = name; } 

   public String toString() {return name;}
}

您可以将这 2 个枚举声明为 public static enum {...} 到 Pack 类中。在这种情况下使用枚举的原因是我们事先知道所有牌，这样处理强类型对象比只处理等级和花色的Integers 或String 更安全。

然后您可以在 Suit 和 Rank 值上使用双循环初始化卡的 Pack，例如

public Pack() {
   int i = 0;
   for (Rank r : Rank.values()) {
      for (Suit s : Suit.values()) {
         cards[i] = new PlayingCard(r, s);
         i++;
      }
   }
}

要洗牌，只需使用Collections.shuffle()，例如

public void shuffle() {
    List<Card> newDeck = Arrays.asList(cards);
    Collections.shuffle(newDeck);
}

List<Card> 由数组支持；然后将洗牌传播到纸牌数组。