0


ArrayList | 简单的洗牌算法

一个洗牌程序需要包含:

  1. 创建一副扑克牌(除去大小王剩下52张,每种花色13张)。
  2. 洗牌,打乱牌的顺序。
  3. 揭牌,每位玩家轮流揭牌,从洗完后的牌组中获得自己的牌。

因此,我们可以依照以下思路来完成一个洗牌程序:

一、创建扑克牌类Poker

观察扑克牌可知,每张扑克牌都具备的属性有:花色(suit)与牌面数字(rank)。因此,我们创建的Poker类中就需包含这两个属性,以及它们对应的构造方法,getter()与setter()方法(这两个方法在本程序中用不到,之所以加上是为了体现这里的封装特性,不加也不会对程序有很大影响)。

同时,为了让程序运行之后的结果更加清楚,我们还需重写一下toString()方法。这样,一个Poker类就设计好了。

public class Poker {
    private String suit;    //花色
    private int rank;   //面值

    //构造方法
    public Poker(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }

    //getter()与setter()
    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    //重写toString()
    @Override
    public String toString() {
        return "{" + suit + " " + rank + "}";
    }
}

二、创建游戏类Game

Game类中包含创建一副扑克牌、洗牌、揭牌的各种方法,控制的是游戏的主要环节。

1、获得一副扑克牌

在Poker中,我们并没有给出扑克牌具体的花色和牌面数字。Poker类相当于只是一张扑克牌的概念,只是规定了每张Poker牌由suit和rank组成。但在Game中,我们需要真正“得到”这一整副扑克牌。

(1)花色数组

可以用一个花色数组来存放这四种花色:[ ♥ , ♠ , ♣ , ♦ ]

private static final String[] suits = {"红桃","黑桃","梅花","方片"};

(2)指定玩家人数与玩家摸牌数

我们指定有3位玩家,每位玩家共可以摸5张牌。

public final int PLAYERS_NUMBER = 3;
public final int DEFAULT_CARDS = 5;

(3)创建一副扑克

首先,我们是通过ArrayList这个容器来存储一副扑克的。可以把ArrayList想象成装牌的小方盒。因此我们要new ArrayList<>(),并把传入的数据类型指定为Poker:

List<Poker> pokerList = new ArrayList<>();

然后我们就可以根据花色与数值,将不同的牌添加进pokerList当中。扑克牌共4种花色,每种花色的数值是1~13(这里先不把11、12、13单独转换成J、Q、K)。用两个for循环嵌套即可完成这个过程。

    public List<Poker> buyPoker() {
        //通过ArrayList存放Poker
        List<Poker> pokerList = new ArrayList<>();

        //给pokerList中添加扑克牌
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                //构造单张扑克牌
                Poker poker = new Poker(suits[i],j);
                //加入
                pokerList.add(poker);
            }
        }
        return pokerList;
    }

4花色从前面的花色数组中通过suits[i]依次获取,数值则通过j的值来获取。最终返回pokerList即可。

这时我们在Test类的main()方法中调用buyPoker()方法获取扑克牌,并打印,呈现如下效果:

//Test.java

import java.util.List;

public class Test {
    public static void main(String[] args) {
        Game game = new Game();
        List<Poker> pokerList = game.buyPoker();
        System.out.println(pokerList);
    }

}

...

可以看到,52张扑克牌依次顺序展现在我们眼前。获取扑克牌的过程就完成了。

2、洗牌

接下来要做的是洗牌,也就是把牌的顺序随机打乱。通过random对象即可搞定。

下图是创建了之后的扑克牌,打乱的方式就是随机的不同的牌之间两两调换位置。我们可以用random对象获取一定范围内的随机数作为要调换的目标牌的下标,这样就能做到随机调换了。但这里有一个问题,那就是洗牌的过程中牌在不断地变化,如何方便地控制好random的范围呢?

random.nextInt(a)创出的随机数范围是[0.a)。如果从左向右遍历,那么左边的牌需要在右边随机找牌换,随着牌下标i的不断变化,在右边随机找牌这个操作相对比较繁琐。但如果我们转换思路,从最右边也就是ArrayList的最后一个元素由右向左遍历,那么控制随机数下标范围就会容易得多。用i表示下标的话,只需要random.nextInt(i),即可获得[0,i)之间的随机数,恰好是左半边的范围。

结合ArrayList获取与设置元素的方法get()和set(),可以得到如下代码:

    public void shuffle(List<Poker> pokerList) {
        for (int i = pokerList.size()-1; i > 0; i--) {
            //创建random对象
            Random random = new Random();
            int index = random.nextInt(i);
            //交换
            this.swap(pokerList,i,index);
        }
    }
    private void swap(List<Poker> pokerList,int i,int j) {
        Poker tmp = pokerList.get(i);
        pokerList.set(i,pokerList.get(j));
        pokerList.set(j,tmp);
    }

调用后结果如下:

第一行是洗牌前,第二行是洗牌后,牌已经被随机打乱。

3、揭牌

揭牌的过程实质上就是将牌从pokerList中移除的过程。想象一下现实中揭牌的过程,在洗完牌后把牌倒扣在桌面上,每个玩家依次从一堆牌的最顶上摸走一张牌。在编程中的体现就是,将0下标(也就是第一个位置)的牌移除,并将移除了的牌添加到玩家手中。

        for (int i = 0; i < DEFAULT_CARDS; i++) {
            for (int j = 0; j < PLAYERS_NUMBER; j++) {
                players.get(j).add(pokerList.remove(0));
            }
        }

但如何实现“三位玩家轮流摸牌”呢?如果把三位player视作三个ArrayList,每个player简化为存放他们各自牌的容器,那么此时这三个player是彼此独立的。如果我们再创建一个List<Poker>类型的List容器,将这三个player装入,那么它们三个也就具有顺序关系了。于是,实现代码如下:

    public List<List<Poker>> getCards(List<Poker> pokerList){
        List<List<Poker>> players = new ArrayList<>();

        List<Poker> player1 = new ArrayList<>();
        List<Poker> player2 = new ArrayList<>();
        List<Poker> player3 = new ArrayList<>();

        players.add(player1);
        players.add(player2);
        players.add(player3);

        for (int i = 0; i < DEFAULT_CARDS; i++) {
            for (int j = 0; j < PLAYERS_NUMBER; j++) {
                players.get(j).add(pokerList.remove(0));
            }
        }
        return players;
    }

运行后得:


三、完整代码

//Test.java

import java.util.List;

public class Test {
    public static void main(String[] args) {
        Game game = new Game();
        List<Poker> pokerList = game.buyPoker();
        System.out.println(pokerList);
        game.shuffle(pokerList);
        System.out.println(pokerList);
        List<List<Poker>> players = game.getCards(pokerList);
        for (int i = 0; i < game.PLAYERS_NUMBER; i++) {
            System.out.println("玩家" + (i+1) + players.get(0));
            System.out.println();
        }
        System.out.println("剩下的牌:" + pokerList);

    }

}
//Poker.java

public class Poker {
    private String suit;    //花色
    private int rank;   //面值

    //构造方法
    public Poker(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }

    //getter()与setter()
    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    //重写toString()
    @Override
    public String toString() {
        return "{" + suit + " " + rank + "}";
    }
}
//Game.java

import java.util.*;

public class Game {
    private static final String[] suits = {"红桃","黑桃","梅花","方片"};
    public final int PLAYERS_NUMBER = 3;
    public final int DEFAULT_CARDS = 5;

    public List<Poker> buyPoker() {
        List<Poker> pokerList = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                Poker poker = new Poker(suits[i],j);
                pokerList.add(poker);
            }
        }
        return pokerList;
    }

    public void shuffle(List<Poker> pokerList) {
        for (int i = pokerList.size()-1; i > 0; i--) {
            Random random = new Random();
            int index = random.nextInt(i);
            this.swap(pokerList,i,index);
        }
    }
    private void swap(List<Poker> pokerList,int i,int j) {
        Poker tmp = pokerList.get(i);
        pokerList.set(i,pokerList.get(j));
        pokerList.set(j,tmp);
    }

    //揭牌
    public List<List<Poker>> getCards(List<Poker> pokerList){
        List<List<Poker>> players = new ArrayList<>();

        List<Poker> player1 = new ArrayList<>();
        List<Poker> player2 = new ArrayList<>();
        List<Poker> player3 = new ArrayList<>();

        players.add(player1);
        players.add(player2);
        players.add(player3);

        for (int i = 0; i < DEFAULT_CARDS; i++) {
            for (int j = 0; j < PLAYERS_NUMBER; j++) {
                players.get(j).add(pokerList.remove(0));
            }
        }
        return players;
    }

}

本文转载自: https://blog.csdn.net/wyd_333/article/details/128603704
版权归原作者 碳基肥宅 所有, 如有侵权,请联系我们删除。

“ArrayList | 简单的洗牌算法”的评论:

还没有评论