一个简单的计算机发牌程序
共有4个文件组成：
1、Suit.java
2、Rank.java
3、Card.java
4、CardDeal.java
Suit.java用来定义牌的套数。ENUM中的排列顺序，决定了对Card排序时的优先级。
package app.xjtu;
/**
* 定义牌的套数，共有“桃”“杏”“梅花”“方块”四套
*/
public enum Suit {
HEARTS("桃"),SPADES("杏"),CLUBS("梅花"),DIAMONDS("方块");
private String info;
Suit(String info){
this.info = info;
}
@Override
public String toString() {
return info;
}
}
Rank.java定义了每套牌的牌面。（这里省略了2张特殊的牌）。ENUM中的排列顺序，决定了对Card排序时的优先级。
package app.xjtu;
/**
* 定义每套牌的牌面
*/
public enum Rank{
ACE("A"),DEUCE("2"),THREE("3"),FOUR("4"),FIVE("5"),SIX("6"),SEVEN("7"),
EIGHT("8"),NINE("9"),TEN("10"),JACK("J"),QUEEN("Q"),KING("K");
private String info;
Rank(String info){
this.info = info;
}
@Override
public String toString() {
return info;
}
}
Card.java定义了一张牌。
package app.xjtu;
import java.util.ArrayList;
import java.util.List;
public class Card implements Comparable<Card> {
private final Rank rank;
private final Suit suit;
private Card(Rank rank, Suit suit) {
this.rank = rank;
this.suit = suit;
}
private static final List<Card> protoDeck = new ArrayList<Card>();
/**
* 完成对一副新扑克的制作
*/
static {
for (Suit suit : Suit.values()) {
for (Rank rank : Rank.values()) {
protoDeck.add(new Card(rank, suit));
}
}
}
/**
* @return 返回一副整齐的扑克
*/
public static ArrayList<Card> newDeck() {
return new ArrayList<Card>(protoDeck);
}
/**
* 排序：
* 1、不同级，按桃、杏、梅、方的顺序排列
* 2、同级，则按A 2 3 4 5 6 7 8 9 10 J Q K的顺序排列
*/
@Override
public int compareTo(Card o) {
if(this.equals(o)){
return 0;
}else{
if(this.suit.equals(o.suit)){
return this.rank.compareTo(o.rank);
}else{
return this.suit.compareTo(o.suit);
}
}
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Card) {
Card other = (Card) obj;
if (this.rank.equals(other.rank) && this.suit.equals(other.suit))
return true;
else
return false;
} else {
return false;
}
}
@Override
public String toString() {
return this.suit+":"+this.rank;
}
}
CardDeal.java包装了对Card的基本操作：
package app.xjtu;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CardDeal {
/**
* 得到一副牌（可以是整齐的、也可以是洗过的）
* @param shuffle 是否洗牌。
* @return 一副牌
*/
public static List<Card> getProtoDeck(boolean shuffle){
List<Card> deck = Card.newDeck();
if(shuffle){
Collections.shuffle(deck);
}
return deck;
}
/**
* 对指定的牌，洗牌。
* @param deck 要洗的牌
*/
public static void shuffle(List<Card> deck){
Collections.shuffle(deck);
}
/**
* 发牌给所有人。在牌数不均时，玩家序号大的，多得1张牌。
* @param deck 所有的牌
* @param n 参与的玩家
* @return 玩家的序号和玩家的牌，所组成的Map类型。
*/
public static Map<Integer, ArrayList<Card>> deal(List<Card> deck, int n) {
Map<Integer, ArrayList<Card>> map = new HashMap<Integer, ArrayList<Card>>();
int key = n;
int deckSize = deck.size();
// 每人至少有这么多的牌
int perHand = (deckSize - 1) / n;
do {
deckSize = deck.size();
List<Card> handView = deck.subList(deckSize - perHand, deckSize);
ArrayList<Card> hand = new ArrayList<Card>(handView);
map.put(key, hand);
handView.clear();
key--;
} while (key > 0);
// 发多余的牌
for (int i = 0; i < deck.size(); i++) {
map.get(n - i).add(deck.get(i));
}
return map;
}
/**
* 对一系列的Card进行排序
* @param cards 要排序的Card集合
*/
public static void sortCards(List<Card> cards){
Collections.sort(cards);
}
}
测试程序：
package app.xjtu;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class TestCard {
public static void main(String[] args) {
// 获得一副牌
List<Card> deck = CardDeal.getProtoDeck(false);
// 要求洗牌
CardDeal.shuffle(deck);
// 发牌
Map<Integer,ArrayList<Card>> hands = CardDeal.deal(deck, 5);
// 查看每个人的牌
for(Entry<Integer,ArrayList<Card>> hand : hands.entrySet()){
// 排列得到的牌
CardDeal.sortCards(hand.getValue());
// 输出每个玩家的牌
System.out.println("玩家 "+hand.getKey()+" : （共有"+hand.getValue().size()+"）的牌 ：");
System.out.println(hand.getValue());
}
}
}
测试结果信息：
