如何使用Java随机播放一副纸牌（尝试使用哈希图，不起作用）？

Question

I have a hashmap<Integer, Card> Card is a class. I have initialized the hashmap with keys from 0-51 and the values are array of Card , as follows

Card [] card = new Card[52]
for (int i=1; i<=13; i++)
    for (int j=0; j<4; j++)
        card[++index] = new Card( ((i*10)+j) );

and I populate the hashmap as follows:

for (int i=1; i<=13; i++)
    for (int j=0; j<4; j++)
        deck.put( ++key, card[++index] );

Now, what I want to do is to shuffle the values side of the hashmap , i do not want,for an example, the key[1] corresponds to card[0] and key[1] corresponds to card[1]. I want, for an exampel, the key[1] corresponds to card[38]. I want the values side to be shuffled. I tried the following:

Collections.shuffle(card,new Random()); But it seems it accepts only ArrayList and List .

Answer 1

HashMaps do not have a predictable order, and shuffling an unordered data structure doesn't make sense. From the Java reference docs:

This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

If you are using keys from 0-51, you should just add all of the cards to an ArrayList. Then you can use Collections.shuffle(arrayList)

Answer 2

can I shuffle an array?

Yes. Here's one way.

Integer[] t = { 1, 2, 3, 4, 5 };
Collections.shuffle(Arrays.asList(t));
System.out.println(Arrays.toString(t));

Answer 3

You should consider adjusting your design to include a Deck and Card class. Examples are shown below. Your "encoding" for a card has a potential flaw 10*suit + card will have suit 0 card 13 have the same value as suit 1, card 3. If you want to compare two cards to see which "wins", you should add a method to the Card class that does this.

Try this:

Deck Class

package com.example.cards;
import java.util.Arrays;
import java.util.Collections;

public class Deck {
    // Class fields
    // Object fields
    private Integer[] deckOrder;
    private int nextCard;
    private Card[] cards;

    public Deck() {
        deckOrder = new Integer[52];
        cards = new Card[52];
        for (int i=0; i < deckOrder.length; i++) {
            deckOrder[i] = i;
            cards[i] = new Card(i/13,i % 13);
        }
    }

    public void shuffle() {
        Collections.shuffle(Arrays.asList(deckOrder));
        nextCard = 0;
    }

    public Card deal() {
        if (nextCard < deckOrder.length) {
            nextCard++;
            return cards[deckOrder[nextCard-1]];
        } else {
            return null;
        }
    }
}

Card Class

package com.example.cards;

public class Card {
    // Class fields
    public final static String[] suit = {"Spades","Hearts","Diamonds","Clubs"};
    public final static String[] card = {"Ace","King","Queen","Jack","Ten","Nine"
                                        ,"Eight","Seven","Six","Five","Four"
                                        ,"Three","Two"};
    // Object fields
    private int suitIndex;
    private int cardIndex;

    public Card(int suit, int card) {
        suitIndex = suit;
        cardIndex = card;
    }
    public int getSuitIndex() { return suitIndex;}
    public int getCardIndex() { return cardIndex;}
    public String getSuit() { return suit[suitIndex];}
    public String getCard() { return card[cardIndex];}

    public int getEncodedCard() { return 100*suitIndex + cardIndex;}
}

Test driver

package com.example.cards;
public class TestShuffle {
    public static void main(String[] args) {
        Deck myDeck = new Deck();
        for (int deal = 1; deal < 3; deal++) {
            System.out.println("======================Deal " + deal);
            for (int i = 0; i < 52; i++) {
                Card nextCard = myDeck.deal();
                System.out.println("Card " + i + ". " + nextCard.getCard()
                        + " of " + nextCard.getSuit() + "(encoded "
                        + nextCard.getEncodedCard() + ")");
            }
            myDeck.shuffle();
        }
    }
}

Answer 4

try this:

public static void main(String args[]) {
    Map<String, Object> x = new HashMap<String, Object>();
    x.put("x", 1); x.put("y", 2); x.put("z", 3); x.put("w", 4);
    System.out.println(x);
    List<Object> vs = new ArrayList<Object>(x.values());
    Collections.shuffle(vs);
    System.out.println(vs);
    Iterator<Object> vIter = vs.iterator();
    for (String k : x.keySet()) x.put(k, vIter.next());
    System.out.println(x);
}

output :

{w=4, x=1, y=2, z=3}
[2, 3, 1, 4]
{w=2, x=3, y=1, z=4}

Answer 5

What you can do is extract your key value pairs as a List of Map.Entry and shuffle it and put your Map.Entry values in the cleared map

  Set<Map.Entry<Integer,Card> cardEntrySet= deck.entrySet();
    List<Map.Entry<Integer,Card> cardsEntryList = new ArrayList<>(cardEntrySet);
    Collections.shuffle(cardsEntryList);
    deck.clear();

    for(Map.Entry<Integer,Card> entry :cardsEntryList){
      deck.put(entry.getKey(),entry.getValue());
    }