You only need to initialise your deck with the numbers between 0 and 51,  
you can do this without random numbers.  Another option is to use an  
enumerated type to model the playing cards.  Either way, all your  
buildDeck method needs to do is to ensure that each card is different, it  
doesn't matter if they are all in order at this point, you will shuffle  
them later.

Don't use Math.random to generate random integers, use java.util.Random  
instead.  Roedy Green has a decent discussion of generating random numbers  
in Java (here http://mindprod.com/jgloss/pseudorandom.html).

Which is more important to you here, the means or the end?  If you just  
want to shuffle a deck as easily as possible, take a look at the shuffle  
method in the java.util.Collections class.  If you want to write the  
shuffling routine yourself, search for the Fisher-Yates algorithm and try  
implementing that (I believe that the java.util.Collections shuffle method  
is an implementation of this algorithm).  Alternatively, try the trivial  
algorithm used by PokerStars and described on their site  
(http://www.pokerstars.com/poker/room/features/security/).

Dan.

[snip the code]

Well, it doesn't look all that great to me.
Here's one that looks better.

class Deck {
   final java.util.List<Card> cards;
   private static final int DECK_SIZE = Card.NUMBER_OF_CARD_TYPES;

   public Deck() {
       this.cards = new java.util.ArrayList<Card>();
       for (int i = 0; i < DECK_SIZE; ++i) {
           cards.add(Card.forOrdinal(i));
       }
   }

   public void shuffle() {
       java.util.Collections.shuffle(cards);
   }

   public void print() {
       for (Card card: cards) {
           System.out.print(" '" + card + "' ");
       }
       System.out.println();
   }
}

class Card {
   private static final int NUMBER_OF_VALUES = Value.values().length;
   private static final int NUMBER_OF_SUITS = Suit.values().length;
   public static final int NUMBER_OF_CARD_TYPES =
NUMBER_OF_SUITS*NUMBER_OF_VALUES;

   enum Suit {
       diamonds, clubs, hearts, spades;
       private static Suit forOrdinal(int ordinal) {
           return values()[ordinal / NUMBER_OF_VALUES];
       }
   }
   enum Value {
       ace, two, three, four, five, six, seven, eight, nine, ten,
jack, queen, king;

       private static Value forOrdinal(int ordinal) {
           return values()[ordinal];
       }
   }
   final Suit suit;
   final Value value;
   private Card(Suit suit, Value value) {
       this.suit = suit;
       this.value = value;
   }
   public static Card forOrdinal(int ordinal) {
       return new Card(Suit.forOrdinal(ordinal),
Value.forOrdinal(ordinal));
   }

   public String toString() {
       return value.toString() + " of " + suit.toString();
   }
}

public class Poker {
   public static void main(String[] args) {
       Deck deck = new Deck();
       deck.print();
       deck.shuffle();
       deck.print();
   }
}

Sigh..., why u guys need to implement urselves?
java.util.Collection.shuffle() can handle this ...

On Jan 24, 1:12 am, "Martin Krainer" <NOSPAMmartin.krai...@inode.at>
wrote: