Java进阶之自定义ArrayList&斗地主发牌案例

一、自定义ArrayList

/*
    自定义的ArrayList集合

    在Java中有一个接口Iterable，实现这个这个接口后，就支持增强for了
 */
public class MyArrayList<T> implements Iterable<T>{
     
    //定义数组，保存数据,初始长度为2
    private Object[] arr = new Object[2];
    //定义变量，用来记录索引，【集合的长度】
    int index = 0;

    /*
        定义方法，用来添加数据
     */
    public void add(T t){
     
        //添加时，先判断集合内部的数组是否满了，如果满了就扩容
        if (index == arr.length){
     //如果index和数组长度相等，就表示数组满了
            //创建一个新数组，长度是原数组的2倍
            Object[] newArr = new Object[arr.length * 2];
            //将原数组的内容复制到新数组中
            copyArray(arr,newArr);
            //把新数组的地址赋值给原数组，让自定义的集合使用新的数组
            arr = newArr;
        }
        arr[index++] = t;
    }

    /*
        定义方法，用来获取指定索引处的元素
     */
    public T get(int index){
     
        return (T)arr[index];
    }

    /*
        定义方法，把一个数组的内容复制到另外一个数组
     */
    private void copyArray(Object[] oldArray,Object[] newArray){
     
        for (int i = 0; i < oldArray.length; i++) {
     
            newArray[i] = oldArray[i];
        }
    }

    /*
        定义方法，输出集合的长度
     */
    public int size(){
     
        return index;
    }

    /*
        定义方法，用来获取集合的迭代器对象
     */
    public Iterator<T> iterator(){
     
        return new MyItr();
    }

    /*
        自定义迭代器
     */
    private class MyItr implements Iterator<T>{
     
        //定义变量，表示光标，最开始指向集合的起始位置
        int cursor = 0;

        /*
            判断是否有元素可以获取
         */
        @Override
        public boolean hasNext() {
     
            //index也表示集合的大小，如果光标小于集合的大小，就表示有元素可以获取
            return cursor < index;
        }

        /*
            获取元素，并把光标向后移动
         */
        @Override
        public T next() {
     
            //获取光标位置的元素
            //光标向后移动
            return (T)arr[cursor++];
        }
    }
}

二、斗地主发牌案例

斗地主排序版的实现步骤：

• 1.准备牌
• 2.洗牌
• 3.发牌
• 4.看牌

public class Demo01Poker {
     
    public static void main(String[] args) {
     
        //1. 准备牌
        //定义List集合，保存编号
        List<Integer> poker = new ArrayList<>();
        //定义Map集合，保存编号和扑克牌的对应关系
        Map<Integer, String> map = new HashMap<>();
        //向List集合添加编号，向map集合添加对应关系
        //定义数组保存花色
        String[] colors = {
     "♠", "♥", "♣", "♦"};
        //定义数组保存点数
        String[] nums = {
     "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //定义变量表示扑克牌的编号，编号从0开始
        int index = 0;
        //开始循环，在循环中向List集合添加编号，向Map集合添加编号以及扑克牌（嵌套循环）
        for (String num : nums) {
     
            for (String color : colors) {
     
                //添加编号
                poker.add(index);
                //添加编号和扑克牌的对应关系
                map.put(index, color + num);
                //编号自增
                index++;
            }
        }
        //添加小王
        poker.add(index);//添加编号
        map.put(index, "小王");
        index++;//编号自增

        //添加大王
        poker.add(index);
        map.put(index, "大王");

        //2. 洗牌
        //打乱集合中编号的顺序
        Collections.shuffle(poker);

        //3. 发牌
        //创建三个集合，保存三个玩家手里的牌（真正保存的是扑克牌的编号）
        List<Integer> playerOne = new ArrayList<>();
        List<Integer> playerTwo = new ArrayList<>();
        List<Integer> playerThree = new ArrayList<>();
        //创建集合，保存底牌（真正保存是扑克牌的编号）
        List<Integer> diPai = new ArrayList<>();
        //开始发牌，遍历集合，拿到集合中的每一张牌(编号)，根据牌(编号)在集合中的索引进行发牌。
        for (int i = 0; i < poker.size(); i++) {
     
            //获取遍历到的扑克牌（编号），变量i表示每一个扑克牌（编号）的索引
            Integer card = poker.get(i);
            //在给玩家发牌之前处理底牌
            if(i >= 51) {
     //最后三张牌的索引是51 52 53
                //如果是最后三张牌，就添加到底牌集合
                diPai.add(card);
                continue;//添加到底牌后，就跳过后面给玩家发牌的操作。
            }

            //根据索引进行发牌
            if (i % 3 == 0) {
     //将索引对3取余结果是0的牌发给第一个玩家
                playerOne.add(card);
            } else if (i % 3 == 1) {
     //强索引对3取余结果是1的牌发给第二个玩家
                playerTwo.add(card);
            } else {
     
                //否则索引对3取余肯定是2，就发给第三个玩家
                playerThree.add(card);
            }
        }
        //4. 看牌
        lookCard("发哥", playerOne, map);
        lookCard("星爷", playerTwo, map);
        lookCard("华仔", playerThree, map);
        lookCard("底牌", diPai, map);

    }

    /*
        定义方法，用来看牌
            参数：玩家姓名，玩家手中的编号，保存对应关系的map集合
            返回值：没有

        步骤：
            1. 输出玩家的姓名
            2. 对玩家手中的编号进行排序。
            3. 遍历保存编号的集合，拿到集合中的每一个编号。
            4. 去Map集合中，根据编号获取对应的扑克牌并输出。
     */
    public static void lookCard(String name, List<Integer> list, Map<Integer, String> map) {
     
        //输出玩家的姓名
        System.out.print(name + ": ");
        //对玩家手中的编号进行排序。
        Collections.sort(list);
        //遍历保存编号的集合，拿到集合中的每一个编号。
        for (Integer id : list) {
     
            //去Map集合中，根据编号获取对应的扑克牌并输出。
            String card = map.get(id);
            System.out.print(card + " ");
        }
        //输出空换行
        System.out.println();
    }
}