发牌程序

引用：http://xiaolongfeixiang.iteye.com/blog/575921

共有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());
        }
    }

}

测试结果信息：