【实现思路】
    1、要实现纸牌程序，首先需要完成纸牌的组装。牌面是由花色和数字（包括 J、Q、K、A 字母）两部分组成的，可以创建两个 ArrayList 集合作为花色集合和数字集合，存储时需要注意，比 10 大的牌用 J、Q、K 表示，1 用 A 来表示。
    2、将花色集合和数字集合这两个集合进行嵌套循环，将花色与数字组合，形成 52 张牌，并赋予其编号。将组合后的牌存放到一个 HashMap 集合中，集合的 key 值是编号， value 值是组装完成的纸牌。还有两张牌是大小王。由于组装规则不一致，需单独使用 add()方法将这两张牌加入到 HashMap 中。
    3、创建一个数字集合，用这个数字集合来代替纸牌完成洗牌和发牌的操作。由于纸牌的数量是 54 张，所欲创建的集合范围是 0~53。
    4、可以使用 Collectios 类的 shuffle()方法完成打乱数字集合的操作，实现洗牌效果。由于只有 3 个人，所以可以使用 for 循环，通过将数字与 3 取余的方法，将代表不同纸牌的数字分配给不同的人和底牌，实现发牌效果。
    5、洗牌和发牌完成之后，可通过 Collections 类的 sort()方法完成排序，之后通过 foreach 循环 HashMap 集合，根据数字查找对应的纸牌字符串，并存入新创建的字符串集合中，最后展示字符串集合。

    【实现代码】

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Collections;
    4. import java.util.HashMap;
    6. public class PokerShuffleCards {
    7.     public static void main(String[] args) {
    8.         //准备花色
    9.         ArrayList<String> color = new ArrayList<String>();
    10.         color.add("♠");
    11.         color.add("♥");
    12.         color.add("♦");
    13.         color.add("♣");
    14.         //准备数字，用 ArrayList 将纸牌由小到大排序
    15.         ArrayList<String> number = new ArrayList<String>();
    16.         for (int i = 3; i <= 10; i++) {
    17.             number.add(i + "");
    18.         }
    19.         number.add("J");
    20.         number.add("Q");
    21.         number.add("K");
    22.         number.add("A");
    23.         number.add("2");
    24.         //定义一个 map 集合:用来将数字与每一张牌进行对应
    25.         HashMap<Integer, String> map = new HashMap<Integer, String>();
    26.         int index = 0;    //纸牌编号
    27.         for (String thisNumber : number) {    //循环纸牌数字
    28.             for (String thisColor : color) {    //循环纸牌花色
    29.                 map.put(index++, thisColor + thisNumber);    //将花色与数字组合，形成 52 张牌，并赋予对应编号
    30.             }
    31.         }
    32.         //加入大小王
    33.         map.put(index++, "smallking");
    34.         map.put(index++, "bigking");
    35.         //创建内容为 0~53 的数字集合，代表着 54 张牌
    36.         ArrayList<Integer> cards = new ArrayList<Integer>();
    37.         for (int i = 0; i <= 53; i++) {
    38.             cards.add(i);    //此时的 cards 顺序为 0-53
    39.         }
    40.         //洗牌，使用 Collections 工具类中的 shuffle()方法
    41.         Collections.shuffle(cards);    //此时的 cards 顺序已被打乱
    42.         //创建三个玩家和底牌
    43.         ArrayList<Integer> iPlayer = new ArrayList<Integer>();
    44.         ArrayList<Integer> iPlayer2 = new ArrayList<Integer>();
    45.         ArrayList<Integer> iPlayer3 = new ArrayList<Integer>();
    46.         ArrayList<Integer> iSecretCards = new ArrayList<Integer>();
    47.         //遍历这副洗好的牌，遍历过程中，将牌发到 3 个玩家和底牌中
    48.         for (int i = 0; i < cards.size(); i++) {
    49.             if (i >= 51) {
    50.                 iSecretCards.add(cards.get(i));    //留取 3 张底牌
    51.             }else {
    52.                 if (i % 3 == 0) {
    53.                     iPlayer.add(cards.get(i));    //与 3 取余为 0 的牌发给玩家1
    54.                 }else if (i % 3 == 1) {
    55.                     iPlayer2.add(cards.get(i));    //与 3 取余为 1 的牌发给玩家2
    56.                 }else {
    57.                     iPlayer3.add(cards.get(i));    //与 3 取余为 2 的牌发给玩家3
    58.                 }
    59.             }
    60.         }
    61.         //对每个人手中的牌排序，使用 Collections 工具类中的 sort()方法
    62.         Collections.sort(iPlayer);
    63.         Collections.sort(iPlayer2);
    64.         Collections.sort(iPlayer3);
    65.         //对应数字形式的每个人手中的牌，定义字符串形式的牌
    66.         ArrayList<String> sPlayer = new ArrayList<String>();
    67.         ArrayList<String> sPlayer2 = new ArrayList<String>();
    68.         ArrayList<String> sPlayer3 = new ArrayList<String>();
    69.         ArrayList<String> sSecretCards = new ArrayList<String>();
    70.         //循环主键，从 Map 中获取纸牌
    71.         for (Integer key : iPlayer) {
    72.             sPlayer.add(map.get(key));
    73.         }
    74.         for (Integer key : iPlayer2) {
    75.             sPlayer2.add(map.get(key));
    76.         }
    77.         for (Integer key : iPlayer3) {
    78.             sPlayer3.add(map.get(key));
    79.         }
    80.         for (Integer key : iSecretCards) {
    81.             sSecretCards.add(map.get(key));
    82.         }
    83.         //看牌
    84.         System.out.println("玩家1：" + sPlayer);
    85.         System.out.println("玩家2：" + sPlayer2);
    86.         System.out.println("玩家3：" + sPlayer3);
    87.         System.out.println("底牌：" + sSecretCards);
    88.     }
    89. }

    1.既然arraylist是无序的，为什么遍历时是以存入的顺序进行遍历，15~27行。
    2.map的get()方法不是应该传入键所对应的类型吗，为什么这里可以传入interger类型，71~73