动听的洗牌游戏（Java篇ArrayList实操）

本篇会加入个人的所谓‘鱼式疯言’

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言
而是理解过并总结出来通俗易懂的大白话,
小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.
🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念 ！！！

前言

在上篇文章中我们讲解了 ArrayList 和 顺序表 的实现

但唯一遗憾的是没有说明的具有实际运用，这次小编将带大家运用我们 ArrayList 来演示一下我们的 洗牌游戏

1. 牌面
2. 牌组
3. 洗牌
4. 抽牌

一. 牌面

public class Card {
    public  int num;

    public String color;

    public Card(int num, String color) {
        this.num = num;
        this.color = color;
    }


    @Override
    public String toString() {
        return "{" +
                 + num +" , "+
                color  +
                '}';
    }
}

我们将牌分为两者不用的属性： 数字和花色

从中我们就可以得到出 不同的牌面 了

鱼式疯言

重写 tostring（）方法 时，我们可以简单重写即可 💖 💖 💖

比如像小编这样

@Override
public String toString() {
    return "{" +
             + num +" , "+
            color  +
            '}';
}

二.牌组

public class Cards {
public String []colors={“♥”,“♣”,“♠”,“♦”};
public List createCards() {
List CardList= new ArrayList();
for (int i = 1; i <= 13; i++) {
for (int j = 0; j < colors.length; j++) {
Card card=new Card(i,colors[j]);
CardList.add(card);
}
}

    return CardList;
}

}

得到我们的牌组后我们就可以 打印其牌组观察效果了

先说明下我们这个实现的基本框架吧

在这里我们是以 card 为数据类型进行传递，我们只需要 把每一张 card 做好，然后把他都放到 CardList 的这张顺序表中即可，这样就得到我们 整个的牌组 了

鱼式疯言

从中我们打印的很顺利，主要是依靠我们的 ArrayList 来实现的，但有些细节小编就不得不提了

1. 实例化 ArrayList 对象时需要注意

List CardList= new ArrayList();

2. 每张卡牌都依次放入数字和颜色形成

Card card=new Card(i,colors[j]);

三. 洗牌

public class Cards {
   public String []colors={"♥","♣","♠","♦"};
    public List<Card> createCards() {
        List<Card> CardList= new  ArrayList<Card>();
        for (int i = 1; i <= 13; i++) {
            for (int j = 0; j < colors.length; j++) {
                Card card=new Card(i,colors[j]);
                CardList.add(card);
            }
        }

        return CardList;
    }


    public void shuffle(List<Card> CardList) {
        Random r=new Random();
        for (int j = CardList.size()-1; j > 0 ; j--) {
            int i=r.nextInt(j);
            swapCard(CardList,i,j);
        }

    }
    
    private void swapCard (List<Card> CardList,int i,int j) {

            Card tmp=CardList.get(i);
            CardList.set(i,CardList.get(j));
            CardList.set(j,tmp);

    }

    }

洗牌怎么洗，核心框架是什么

我们洗牌的还是利用了随机数的生成，讲 i 从后往前走，一直和 i 前面 的牌交换就是我们的洗牌流程

所以最终我们实现了这样的效果出来

鱼式疯言

细节一：
随机数的生成

Random r=new Random();

 int i=r.nextInt(j);

我们利用 Random 来new一个对象，然后在nextInt（i） 中传出随机数

原理是当放入 i 时，随机数的范围是 0 ~i-1 之间哦

细节二：
交换卡牌

我们这里要注意是以面向对象的思路，所以要有 取出卡牌和放置卡牌的不同动作

  Card tmp=CardList.get(i);
        CardList.set(i,CardList.get(j));
        CardList.set(j,tmp);

以上三行代码可以等效于：

tmp = CardList【i】；

CardList【i】= CardList【j】；

CardList【j】=tmp；

四. 抽牌

我们的抽牌有 两种方式

1. 固定三人抽牌

public  void getCard(List<Card> CaedList) {

    List<Card> hand1=new ArrayList<>();
    List<Card> hand2=new ArrayList<>();
    List<Card> hand3=new ArrayList<>();

    List<List<Card>> hands=new ArrayList<>();
    hands.add(hand1);
    hands.add(hand2);
    hands.add(hand3);

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {

            Card flg=CaedList.remove(0);
           List<Card> hand =hands.get(j);
           hand.add(flg);
        }
    }

    System.out.println("第一个得到的牌："+hand1);
    System.out.println("第二个得到的牌："+hand2);
    System.out.println("第三个得到的牌："+hand3);

}

最终我们得到的效果就是上面这样的

我们整体的逻辑框架就是实例化出三张手，每张手用 顺序表 hands 来管理， 然后对每张手进行从上抽牌的放入即可

鱼式疯言

这里我唯一的细节就是

1. 我们需要把每张手进行 hands 的管理的实例化细节

List<Card> hand1=new ArrayList<>();
List<Card> hand2=new ArrayList<>();
List<Card> hand3=new ArrayList<>();

List<List<Card>> hands=new ArrayList<>();
hands.add(hand1);
hands.add(hand2);
hands.add(hand3);

定义出手，其次 以每只手的类型为类型进行传入，得到 hands 进行管理

2. 怎么放细节

    Card flg=CaedList.remove(0);
   List<Card> hand =hands.get(j);
   hand.add(flg);

从上抽出，这里的抽出是用 0 直接把第一张牌删掉，然后用个变量来接收，

其次用 j 所以的手中抽取每一只手

最后 flg 放入即可

2. 一人随机抽牌

 public List<Card> getCard(List<Card> CardList) {

        List<Card> hand=new ArrayList<>();

        Random r =new Random();


        for (int i = 0; i < 5; i++) {
                int j=r.nextInt(CardList.size());
                Card c=CardList.remove(j);
                hand.add(c);
                CardList.add(c);
        }

        return hand;

    }

我们得到的牌就是这样的效果：

梳理下整体的逻辑框架吧

这里我们用了随机抽牌，只需要把五张牌都抽出放入手上，最终这些牌还得 尾插到牌组后面 ，不造成牌的丢失即可

鱼式疯言

细节注意：

1. 返回值要小心

public List getCard(List CardList)

2. 抽取的人数未知，所以我们需要返回拿到的牌，以免牌数不够

CardList.add ( c ) ;

总结

• 牌面： 熟悉的知晓了定义牌的两个属性
• 牌组： 讲牌进行整合的一个顺序表，并便于后期的管理调用
• 洗牌： 随机的理解已经面向对象的交换的本质理解
• 抽牌： 从两个维度来考虑，灵活的把发牌的灵动性体现出来。

小伙伴都 get 到了吗 💕 💕 💕

如果觉得小编写的还不错的咱可支持 三连 下 (定有回访哦) , 不妥当的咱请评论区 指正

希望我的文章能给各位宝子们带来哪怕一点点的收获就是 小编创作 的最大 动力 💖 💖 💖