如何得到一副洗过的牌的集合呢,如果用JAVA实现,最方便的就是调用Collections的方法[b]shuffle[/b]来进行洗牌。一个很简单的随机产生纸牌的思路如下:
根据纸牌的张数(length),上千次产生0~ length-1的随机数,然后产生随机数对应位置的纸牌与第一张纸牌进行交换,经过上千次的交换,足以达到使纸牌乱序的效果。
该小程序能够产生一副或者多幅随即牌。
具体的程序如下.
几个测试的结果如下:
************** 一副牌(包括大小王)洗牌后的结果 (start)******************
方块 12
梅花 9
红桃 1
梅花 1
红桃 6
黑桃 8
红桃 4
黑桃 6
方块 3
方块 1
黑桃 3
红桃 2
红桃 13
方块 8
梅花 3
红桃 7
方块 2
梅花 2
方块 11
梅花 4
方块 13
方块 7
梅花 11
红桃 8
红桃 5
方块 9
方块 10
红桃 3
方块 4
梅花 8
黑桃 4
黑桃 10
黑桃 9
梅花 6
黑桃 7
黑桃 2
方块 5
黑桃 11
红桃 12
红桃 11
大王 0
梅花 5
梅花 13
黑桃 13
梅花 7
梅花 10
梅花 12
红桃 9
黑桃 5
黑桃 1
红桃 10
方块 6
小王 0
黑桃 12
************** 一副牌(包括大小王)洗牌后的结果 (end)******************
************** 一副牌(不包括大小王)洗牌后的结果 (start)******************
方块 3
方块 4
红桃 1
红桃 6
方块 5
方块 7
方块 1
黑桃 3
方块 2
梅花 3
红桃 12
梅花 12
方块 12
黑桃 4
方块 11
黑桃 12
黑桃 8
红桃 8
梅花 7
红桃 10
方块 6
梅花 2
黑桃 6
红桃 11
黑桃 7
黑桃 2
梅花 1
梅花 13
红桃 9
梅花 5
黑桃 5
方块 9
方块 13
黑桃 11
方块 8
梅花 9
梅花 6
梅花 4
梅花 8
黑桃 1
红桃 13
黑桃 10
红桃 3
红桃 2
红桃 5
红桃 4
红桃 7
方块 10
黑桃 13
梅花 11
黑桃 9
梅花 10
************** 一副牌(不包括大小王)洗牌后的结果 (end)******************
************** 两副牌(包括大小王)洗牌后的结果 (start)******************
方块 5
梅花 6
梅花 12
红桃 6
方块 4
红桃 11
黑桃 8
梅花 6
梅花 5
红桃 6
红桃 7
红桃 2
梅花 11
梅花 4
梅花 10
梅花 1
黑桃 8
小王 0
方块 7
黑桃 9
红桃 4
方块 1
红桃 8
黑桃 10
红桃 1
梅花 7
梅花 13
方块 10
方块 10
红桃 3
方块 11
大王 0
方块 13
方块 6
方块 3
黑桃 3
方块 1
黑桃 7
方块 4
方块 2
黑桃 6
红桃 4
方块 9
红桃 13
梅花 10
方块 13
黑桃 10
黑桃 4
方块 7
大王 0
红桃 10
方块 8
梅花 9
梅花 2
方块 12
红桃 12
方块 6
黑桃 7
红桃 5
方块 12
黑桃 11
红桃 2
黑桃 3
黑桃 4
红桃 10
梅花 8
黑桃 6
小王 0
黑桃 12
黑桃 13
红桃 5
红桃 13
梅花 3
方块 5
方块 2
方块 3
黑桃 13
红桃 7
梅花 4
黑桃 2
梅花 3
方块 9
黑桃 1
梅花 13
黑桃 11
红桃 9
梅花 11
方块 8
梅花 7
梅花 5
方块 11
红桃 12
梅花 2
黑桃 2
梅花 1
黑桃 5
红桃 3
黑桃 5
红桃 11
黑桃 12
红桃 1
黑桃 1
梅花 8
黑桃 9
梅花 9
梅花 12
红桃 8
红桃 9
************** 两副牌(包括大小王)洗牌后的结果 (end)******************
************** 两副牌(不包括大小王)洗牌后的结果 (start)******************
梅花 10
红桃 6
梅花 13
红桃 12
方块 6
红桃 10
红桃 3
梅花 7
方块 13
红桃 9
黑桃 13
梅花 1
黑桃 3
黑桃 5
方块 12
梅花 12
红桃 12
梅花 6
方块 10
黑桃 1
红桃 8
黑桃 10
红桃 11
梅花 5
红桃 8
梅花 3
红桃 1
梅花 2
红桃 13
方块 8
梅花 4
梅花 12
方块 5
黑桃 4
梅花 5
红桃 7
红桃 3
黑桃 4
梅花 9
梅花 10
方块 12
黑桃 5
方块 9
梅花 6
梅花 3
黑桃 11
方块 8
红桃 2
方块 10
方块 1
梅花 11
黑桃 7
黑桃 8
红桃 4
方块 5
黑桃 12
梅花 2
黑桃 8
方块 2
红桃 5
红桃 13
方块 11
梅花 8
黑桃 3
红桃 7
黑桃 9
方块 2
黑桃 10
梅花 8
方块 9
梅花 11
红桃 6
黑桃 12
方块 13
红桃 2
方块 7
梅花 7
方块 7
黑桃 11
红桃 1
黑桃 2
黑桃 7
方块 11
梅花 9
黑桃 1
方块 3
黑桃 2
梅花 13
红桃 9
方块 4
方块 1
黑桃 13
红桃 11
梅花 4
红桃 4
方块 4
梅花 1
方块 3
黑桃 6
黑桃 9
红桃 5
红桃 10
黑桃 6
方块 6
************** 两副牌(不包括大小王)洗牌后的结果 (end)******************
根据纸牌的张数(length),上千次产生0~ length-1的随机数,然后产生随机数对应位置的纸牌与第一张纸牌进行交换,经过上千次的交换,足以达到使纸牌乱序的效果。
该小程序能够产生一副或者多幅随即牌。
具体的程序如下.
package cards.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* <code>CardsUtil</code>是一个随机产生纸牌的工具类
* <p>
* 1. 利用Collections的方法shuffle来进行洗牌 2. 根据纸牌的长度(length),上千次产生0~ length-1的随机数,
* 然后产生随机数的纸牌与第一张纸牌进行交换,经过上千次的交换 足以达到使纸牌乱序的效果。
* </p>
*
* @author Eric
* @version 1.0
*
*/
public final class CardsUtil {
/**
* @param includeJoker
* 是否需要包括大小王
* @return
*/
private static List<Card> initCards(boolean includeJoker) {
List<Card> cardList = new ArrayList<Card>();
for (int i = 1; i <= 13; i++) {
cardList.add(new Card(i, CardType.SPADES));
cardList.add(new Card(i, CardType.HEARTS));
cardList.add(new Card(i, CardType.DIAMONDS));
cardList.add(new Card(i, CardType.CLUBS));
}
if (includeJoker) {
cardList.add(new Card(0, CardType.LITTLE_JOKER));
cardList.add(new Card(0, CardType.BIG_JOKER));
}
return cardList;
}
/**
*
* @param number
* 牌的数量(2副,3副.....)
* @param includeJoker
* 是否需要包括大小王
* @return
*/
private static List<Card> initCards(int number, boolean includeJoker) {
List<Card> cardList = new ArrayList<Card>();
for (int i = 0; i < number; i++) {
cardList.addAll(initCards(includeJoker));
}
return cardList;
}
/**
* 调用Collections的shuffle方法来达到乱序的效果
*
* @param list
* @return
*/
public static List<Card> shuffleByCollections(List<Card> list) {
Collections.shuffle(list);
return list;
}
/**
* 根据纸牌的长度(length),上千次产生0~ length-1的随机数, 然后产生随机数的纸牌与第一张纸牌进行交换,经过上千次的交换
* 足以达到使纸牌乱序的效果。 (此方法适用于一副牌的时候)
*
* @param list
* @param includeJoker
* @return
*/
public static List<Card> shuffle(List<Card> list, boolean includeJoker) {
int seed = includeJoker ? 54 : 52;
Random random = new Random();
int randomNumber = 0;
for (int i = 0; i < 1000; i++) {
randomNumber = random.nextInt(seed);
swapCard(list, randomNumber);
}
return list;
}
private static List<Card> swapCard(List<Card> list, int randomNumber) {
Card temp = list.get(0);
list.set(0, list.get(randomNumber));
list.set(randomNumber, temp);
return list;
}
/**
* 根据纸牌的长度(length),上千次产生0~ length-1的随机数, 然后产生随机数的纸牌与第一张纸牌进行交换,经过上千次的交换
* 足以达到使纸牌乱序的效果。 (此方法适用于一副牌或者多幅牌的时候)
*
* @param list
* @param number
* @param includeJoker
* @return
*/
private static List<Card> shuffle(List<Card> list, int number,
boolean includeJoker) {
int seed = includeJoker ? 54 * number : 52 * number;
Random random = new Random();
int randomNumber = 0;
for (int i = 0; i < 1000 * number; i++) {
randomNumber = random.nextInt(seed);
swapCard(list, randomNumber);
}
return list;
}
/**
* 获取一副牌,洗牌后的结果
*
* @param includeJoker
* @return
*/
public static List<Card> retrieveShuffledCards(boolean includeJoker) {
return shuffle(initCards(includeJoker), includeJoker);
}
/**
* 获取一副牌或者多副牌,洗牌后的结果
*
* @param number
* @param includeJoker
* @return
*/
public static List<Card> retrieveShuffledCards(int number,
boolean includeJoker) {
return shuffle(initCards(number, includeJoker), number, includeJoker);
}
/**
* 调用Collectios 的shuffle方法, 获取一副牌,洗牌后的结果
*
* @param includeJoker
* @return
*/
public static List<Card> retrieveShuffledCardsByCollections(
boolean includeJoker) {
List<Card> cardList = initCards(includeJoker);
Collections.shuffle(cardList);
return cardList;
}
/**
* 调用Collectios 的shuffle方法, 获取一副牌或者多副牌,洗牌后的结果
*
* @param number
* @param includeJoker
* @return
*/
public static List<Card> retrieveShuffledCardsByCollections(int number,
boolean includeJoker) {
List<Card> cardList = initCards(number, includeJoker);
Collections.shuffle(cardList);
return cardList;
}
}
package cards.util;
import java.util.HashMap;
import java.util.Map;
public enum CardType {
SPADES("S", "黑桃"), HEARTS("H", "红桃"), DIAMONDS("D", "方块"), CLUBS("P", "梅花"), BIG_JOKER(
"BJ", "大王"), LITTLE_JOKER("LJ", "小王"), UNKNOWN("U", "UNKNOWN");
private static final Map<String, CardType> MAP = new HashMap<String, CardType>();
static {
for (CardType cardType : CardType.values()) {
MAP.put(cardType.getCardTypeCode(), cardType);
}
}
private String cardTypeCode = null;
private String cardTypeDescription = null;
public CardType getCardTypeByCode(String cardTypeCode) {
return MAP.containsKey(cardTypeCode) ? MAP.get(cardTypeCode) : UNKNOWN;
}
/**
* @return the cardTypeCode
*/
public String getCardTypeCode() {
return cardTypeCode;
}
/**
* @param cardTypeCode
* the cardTypeCode to set
*/
public void setCardTypeCode(String cardTypeCode) {
this.cardTypeCode = cardTypeCode;
}
/**
* @return the cardTypeDescription
*/
public String getCardTypeDescription() {
return cardTypeDescription;
}
/**
* @param cardTypeDescription
* the cardTypeDescription to set
*/
public void setCardTypeDescription(String cardTypeDescription) {
this.cardTypeDescription = cardTypeDescription;
}
/**
* @param cardTypeCode
* @param cardTypeDescription
*/
private CardType(String cardTypeCode, String cardTypeDescription) {
this.cardTypeCode = cardTypeCode;
this.cardTypeDescription = cardTypeDescription;
}
}
package cards.util;
import java.io.Serializable;
public class Card implements Serializable {
private static final long serialVersionUID = 4709869689433952388L;
// 纸牌的点数
private int points = 0;
// 纸牌类型
private CardType cardType = null;
public Card() {
}
/**
* @param points
* @param cardType
*/
public Card(int points, CardType cardType) {
this.points = points;
this.cardType = cardType;
}
/**
* @return the points
*/
public int getPoints() {
return points;
}
/**
* @param points
* the points to set
*/
public void setPoints(int points) {
this.points = points;
}
/**
* @return the cardType
*/
public CardType getCardType() {
return cardType;
}
/**
* @param cardType
* the cardType to set
*/
public void setCardType(CardType cardType) {
this.cardType = cardType;
}
}
package cards.util;
import java.util.List;
public class CardsTest {
public static void main(String[] args) {
boolean includeJoker = true;//true代表包括大小王,false则不包括
int number = 1;//number代表几幅牌,默认为一副牌
System.out.println("************** 一副牌(包括大小王)洗牌后的结果 (start)******************");
printCards(CardsUtil.retrieveShuffledCards(number, includeJoker));
System.out.println("************** 一副牌(包括大小王)洗牌后的结果 (end)******************");
System.out.println();
includeJoker = false;
System.out.println("************** 一副牌(不包括大小王)洗牌后的结果 (start)******************");
printCards(CardsUtil.retrieveShuffledCards(number, includeJoker));
System.out.println("************** 一副牌(不包括大小王)洗牌后的结果 (end)******************");
System.out.println();
includeJoker = true;
number=2;
System.out.println("************** 两副牌(包括大小王)洗牌后的结果 (start)******************");
printCards(CardsUtil.retrieveShuffledCards(number, includeJoker));
System.out.println("************** 两副牌(包括大小王)洗牌后的结果 (end)******************");
System.out.println();
includeJoker = false;
System.out.println("************** 两副牌(不包括大小王)洗牌后的结果 (start)******************");
printCards(CardsUtil.retrieveShuffledCards(number, includeJoker));
System.out.println("************** 两副牌(不包括大小王)洗牌后的结果 (end)******************");
System.out.println();
}
private static void printCards(List<Card> list) {
for (Card card : list) {
System.out.print(card.getCardType().getCardTypeDescription());
System.out.print(" ");
System.out.println(card.getPoints());
}
}
}
几个测试的结果如下:
************** 一副牌(包括大小王)洗牌后的结果 (start)******************
方块 12
梅花 9
红桃 1
梅花 1
红桃 6
黑桃 8
红桃 4
黑桃 6
方块 3
方块 1
黑桃 3
红桃 2
红桃 13
方块 8
梅花 3
红桃 7
方块 2
梅花 2
方块 11
梅花 4
方块 13
方块 7
梅花 11
红桃 8
红桃 5
方块 9
方块 10
红桃 3
方块 4
梅花 8
黑桃 4
黑桃 10
黑桃 9
梅花 6
黑桃 7
黑桃 2
方块 5
黑桃 11
红桃 12
红桃 11
大王 0
梅花 5
梅花 13
黑桃 13
梅花 7
梅花 10
梅花 12
红桃 9
黑桃 5
黑桃 1
红桃 10
方块 6
小王 0
黑桃 12
************** 一副牌(包括大小王)洗牌后的结果 (end)******************
************** 一副牌(不包括大小王)洗牌后的结果 (start)******************
方块 3
方块 4
红桃 1
红桃 6
方块 5
方块 7
方块 1
黑桃 3
方块 2
梅花 3
红桃 12
梅花 12
方块 12
黑桃 4
方块 11
黑桃 12
黑桃 8
红桃 8
梅花 7
红桃 10
方块 6
梅花 2
黑桃 6
红桃 11
黑桃 7
黑桃 2
梅花 1
梅花 13
红桃 9
梅花 5
黑桃 5
方块 9
方块 13
黑桃 11
方块 8
梅花 9
梅花 6
梅花 4
梅花 8
黑桃 1
红桃 13
黑桃 10
红桃 3
红桃 2
红桃 5
红桃 4
红桃 7
方块 10
黑桃 13
梅花 11
黑桃 9
梅花 10
************** 一副牌(不包括大小王)洗牌后的结果 (end)******************
************** 两副牌(包括大小王)洗牌后的结果 (start)******************
方块 5
梅花 6
梅花 12
红桃 6
方块 4
红桃 11
黑桃 8
梅花 6
梅花 5
红桃 6
红桃 7
红桃 2
梅花 11
梅花 4
梅花 10
梅花 1
黑桃 8
小王 0
方块 7
黑桃 9
红桃 4
方块 1
红桃 8
黑桃 10
红桃 1
梅花 7
梅花 13
方块 10
方块 10
红桃 3
方块 11
大王 0
方块 13
方块 6
方块 3
黑桃 3
方块 1
黑桃 7
方块 4
方块 2
黑桃 6
红桃 4
方块 9
红桃 13
梅花 10
方块 13
黑桃 10
黑桃 4
方块 7
大王 0
红桃 10
方块 8
梅花 9
梅花 2
方块 12
红桃 12
方块 6
黑桃 7
红桃 5
方块 12
黑桃 11
红桃 2
黑桃 3
黑桃 4
红桃 10
梅花 8
黑桃 6
小王 0
黑桃 12
黑桃 13
红桃 5
红桃 13
梅花 3
方块 5
方块 2
方块 3
黑桃 13
红桃 7
梅花 4
黑桃 2
梅花 3
方块 9
黑桃 1
梅花 13
黑桃 11
红桃 9
梅花 11
方块 8
梅花 7
梅花 5
方块 11
红桃 12
梅花 2
黑桃 2
梅花 1
黑桃 5
红桃 3
黑桃 5
红桃 11
黑桃 12
红桃 1
黑桃 1
梅花 8
黑桃 9
梅花 9
梅花 12
红桃 8
红桃 9
************** 两副牌(包括大小王)洗牌后的结果 (end)******************
************** 两副牌(不包括大小王)洗牌后的结果 (start)******************
梅花 10
红桃 6
梅花 13
红桃 12
方块 6
红桃 10
红桃 3
梅花 7
方块 13
红桃 9
黑桃 13
梅花 1
黑桃 3
黑桃 5
方块 12
梅花 12
红桃 12
梅花 6
方块 10
黑桃 1
红桃 8
黑桃 10
红桃 11
梅花 5
红桃 8
梅花 3
红桃 1
梅花 2
红桃 13
方块 8
梅花 4
梅花 12
方块 5
黑桃 4
梅花 5
红桃 7
红桃 3
黑桃 4
梅花 9
梅花 10
方块 12
黑桃 5
方块 9
梅花 6
梅花 3
黑桃 11
方块 8
红桃 2
方块 10
方块 1
梅花 11
黑桃 7
黑桃 8
红桃 4
方块 5
黑桃 12
梅花 2
黑桃 8
方块 2
红桃 5
红桃 13
方块 11
梅花 8
黑桃 3
红桃 7
黑桃 9
方块 2
黑桃 10
梅花 8
方块 9
梅花 11
红桃 6
黑桃 12
方块 13
红桃 2
方块 7
梅花 7
方块 7
黑桃 11
红桃 1
黑桃 2
黑桃 7
方块 11
梅花 9
黑桃 1
方块 3
黑桃 2
梅花 13
红桃 9
方块 4
方块 1
黑桃 13
红桃 11
梅花 4
红桃 4
方块 4
梅花 1
方块 3
黑桃 6
黑桃 9
红桃 5
红桃 10
黑桃 6
方块 6
************** 两副牌(不包括大小王)洗牌后的结果 (end)******************