Java模拟实现斗地主发牌

Java模拟实现斗地主发牌

本文实例为大家分享了java模拟实现斗地主发牌的具体代码，供大家参考，具体内容如下

题目：

模拟斗地主的发牌实现，54张牌，每张牌不同的花色（红心，黑桃，方块，梅花），牌的点数（3,4,5,6,7,8,9,10,J,Q,K,A,2,King,Queen）,另有三名玩家，要求(使用面向对象的方式实现)：

1、随机产生一名地主

2、随机向三名玩家发牌，最后的底牌自动发给地主

3、显示出每名玩家手中的牌

4、要求根据点数自动对玩家手中的牌排序实现（*）

提示：玩家类，牌类，游戏类（算法）

步骤分析：

1.牌类：有点数和花色的差别，其中大王和小王只有点数没有花色

2.玩家类：玩家姓名，是否是地主，手中的牌（牌类集合）

3.游戏类(实现):（首先知道发牌规则，总共54张扑克牌，每人17张，剩下3张扑克给到地主手中。）

设置一个初始化块默认一副扑克牌，初始化三名玩家，随机一名玩家为地主，三名玩家随机获得17张牌，已获得的牌要从集合中删除。

代码实现：

牌类（Poker）：

public class Poker {

/**点数*/

private String point;

/**花色*/

private String flower;

public Poker() {

}

public Poker(String point, String flower) {

this.point = point;

this.flower = flower;

}

public String getPoint() {

return point;

}

public void setPoint(String point) {

this.point = point;

}

public String getFlower() {

return flower;

}

public void setFlower(String flower) {

this.flower = flower;

}

@Override

public String toString() {

if (Objehttp://cts.isNull(flower)){

return point;

}

return flower+""+point;

}

}

玩家类（Player）：

public class Player {

/**玩家昵称*/

private String nickname;

private boolean boss;

/**手中的牌*/

private Listpokers = new ArrayList<>();

public Player() {

}

public Player(String nickname) {

this.nickname = nickname;

}

public String getNickname() {

return nickname;

}

public void setNickname(String nickname) {

this.nickname = nickname;

}

public boolean isBoss() {

return boss;

}

public void setBoss(boolean boss) {

this.boss = boss;

}

public List getPokers() {

return pokers;

}

public void setPokers(List pokers) {

this.pokers = pokers;

}

@Override

public String toString() {

return nickname+(boss?"(地主)":"(农民)")+pokers;

}

}

游戏类（Game）：

public class Game {

/**存储所有牌的集合*/

private List list = new ArrayList<>();

private String[] points = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

private String[] flowers = {"❤","♣","♦","♠"};

private List players = new ArrayList<>();

private Scanner sc = new Scanner(System.in);

private static Random randomUtils = new Random();

//一副牌(笛卡尔积)

{

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

//将带花色的扑克牌加入集合

list.add(new Poker(points[i],flowers[j]));

}

}

//加入大小王

list.add(new Poker("Queen",null));

list.add(new Poker("King",null));

}

/**

* 初始化三名玩家

*/

public void playerJoin(){

System.out.println("请输入玩家昵称1");

String p1 = sc.nextLine();

System.out.println("请输入玩家昵称2");

String p2 = sc.nextLine();

System.out.println("请输入玩家昵称3");

String p3 = sc.nextLine();

players.add(new Player(p1));

players.add(new Player(p2));

players.add(new Player(p3));

}

private void startGame(){

//玩家加入

playerJoin();

//随机一个地主索引

//nextInt(int bound)

//返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname()+"是地主!");

//开始发牌

for (int i = 0; i < players.size(); i++) {

//获取当前遍历到的玩家对象

Player player = players.get(i);

for (int j = 0; j < 17; j++) {

//随机获取一张牌给当前玩家

int n = randomUtils.nextInt(list.size());

//将随机到的牌存储到玩家的牌集合中

player.getPokers().add(list.get(n));

//将已经被取走的牌从原集合中删除

list.remove(n);

}

}

//将剩余三张牌给地主

boss.getPokers().addAll(list);

showPoker();

}

private void showPoker(){

for (Player player : players) {

System.out.println(player);

}

}

public static void main(String[] args) {

new Game().startGame();

}

}

排序：

以上实现了基础的发牌功能，但没有对牌进行排序。java集合框架出现的同时，由于实际开发的数据的排序要求，所以JDK引入用于排序的两个接口：

Comparable:自然排序

Comparator:排序比较器

使用Comparable:自然排序进行排序：

排序需要从三开始到大小王结束，所以需要新增一个进行排序比较的元素。

牌类：

//实现Comparable接口，实现其comparaTo(T t)方法

public class Poker implements Comparable

/**用于排序的属性*/

private int sort;

public Poker(String point, String flower, int sort) {

this.point = point;

this.flower = flower;

this.sort = sort;

}

public int getSort() {

ZtvFdvkfvM return sort;

}

public void setSort(int sort) {

this.sort = sort;

}

//实现方法进行排序

@Override

public int compareTo(Poker p) {

return this.sort-p.sort;

}

游戏类：

//一副牌(笛卡尔积)

{

int sort = 0;

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],sort);

//将带花色的扑克牌加入集合

list.add(p);

}

sort++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

Collections.sort(players.get(0).getPokers());

Collections.sort(players.get(1).getPokers());

Collections.sort(players.get(2).getPokers());

for (Player player : players) {

System.out.println(player);

}

}

使用Comparator:排序比较器进行排序：

牌类：

public class Poker {

/**点数*/

private String point;

/**花色*/

private String flower;

/**用于排序的属性*/

private int size;

public Poker() {

}

public Poker(String point, String flower) {

this.point = point;

this.flower = flower;

}

public Poker(String point, String flower, int size) {

this.point = point;

this.flower = flower;

this.size = size;

}

public String getPoint() {

return point;

}

public void setPoint(String point) {

this.point = point;

}

public String getFlower() {

return flower;

}

public void setFlower(String flower) {

this.flower = flower;

}

public int getSize() {

return size;

}

public void setSize(int size) {

this.size = size;

}

@Override

public String toString() {

if (Objects.isNull(flower)){

return point;

}

return flower+""+point;

}

}

游戏类：

//一副牌(笛卡尔积)

{

int size = 0;

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],size);

//将带花色的扑克牌加入集合

list.add(p);

}

//加入点数

size++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

for (int i = 0; i < players.size(); i++) {

players.get(i).getPokers().sort(new Comparator() {

@Override

public int compare(Poker p1, Poker p2) {

return p1.getSize()-p2.getSize();

}

});

System.out.println(players.get(i));

}

}

实现效果：

扩ZtvFdvkfvM展：

以上代码实现发牌原理是给每名玩家一次性随机17张牌，与现实发牌逻辑不符；按照现实发牌逻辑，需要先进行洗牌，打乱牌的顺序，然后轮流给每名玩家发牌，直到剩余三张牌发给地主。

实现原理：在jdk1.2集合框架出现的同时，新增用于对集合处理的工具类 java.util.Collections，这个类与java.util.Arrays同一时间出现；Collections中提供的所有方法都是静态的，方法包括，对集合：查找，排序，洗牌，转换，拷贝，查找最大值/最小值，集合反转，安全集合的获取等一系列静态方法。

这里用到洗牌方法，Collections.shuffle(List> list) (使用默认的随机源随机排列指定的列表)。

代码实现：（将游戏类中发牌的方法进行修改）

private void startGame() {

//玩家加入

playerJoin();

//随机一个地主索引

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname() + "是地主!");

//洗牌

Collections.shuffle(list);

//开始发牌

// for (int i = 0; i < players.size(); i++) {

// //获取当前遍历到的玩家对象

// Player player = players.get(i);

// for (int j = 0; j < 17; j++) {

// //随机获取一张牌给当前玩家

// int n = randomUtils.nextInt(list.size());

// //将随机到的牌存储到玩家的牌集合中

// player.getPokers().add(list.get(n));

// //将已经被取走的牌从原集合中删除

// list.remove(n);

// }

// }

for (int i = 0; i < list.size(); i++) {

if (i < 51) {

switch (i % 3) {

case 0:

players.get(0).getPokers().add(list.get(i));

break;

case 1:

players.get(1).getPokers().add(list.get(i));

break;

case 2:

players.get(2).getPokers().add(list.get(i));

break;

default:

break;

}

} else {

//将剩余三张牌给地主

boss.getPokers().add(list.get(i));

}

}

showPoker();

}

for (int j = 0; j < flowers.length; j++) {

//将带花色的扑克牌加入集合

list.add(new Poker(points[i],flowers[j]));

}

}

//加入大小王

list.add(new Poker("Queen",null));

list.add(new Poker("King",null));

}

/**

* 初始化三名玩家

*/

public void playerJoin(){

System.out.println("请输入玩家昵称1");

String p1 = sc.nextLine();

System.out.println("请输入玩家昵称2");

String p2 = sc.nextLine();

System.out.println("请输入玩家昵称3");

String p3 = sc.nextLine();

players.add(new Player(p1));

players.add(new Player(p2));

players.add(new Player(p3));

}

private void startGame(){

//玩家加入

playerJoin();

//随机一个地主索引

//nextInt(int bound)

//返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname()+"是地主!");

//开始发牌

for (int i = 0; i < players.size(); i++) {

//获取当前遍历到的玩家对象

Player player = players.get(i);

for (int j = 0; j < 17; j++) {

//随机获取一张牌给当前玩家

int n = randomUtils.nextInt(list.size());

//将随机到的牌存储到玩家的牌集合中

player.getPokers().add(list.get(n));

//将已经被取走的牌从原集合中删除

list.remove(n);

}

}

//将剩余三张牌给地主

boss.getPokers().addAll(list);

showPoker();

}

private void showPoker(){

for (Player player : players) {

System.out.println(player);

}

}

public static void main(String[] args) {

new Game().startGame();

}

}

排序：

以上实现了基础的发牌功能，但没有对牌进行排序。java集合框架出现的同时，由于实际开发的数据的排序要求，所以JDK引入用于排序的两个接口：

Comparable:自然排序

Comparator:排序比较器

使用Comparable:自然排序进行排序：

排序需要从三开始到大小王结束，所以需要新增一个进行排序比较的元素。

牌类：

//实现Comparable接口，实现其comparaTo(T t)方法

public class Poker implements Comparable

/**用于排序的属性*/

private int sort;

public Poker(String point, String flower, int sort) {

this.point = point;

this.flower = flower;

this.sort = sort;

}

public int getSort() {

ZtvFdvkfvM return sort;

}

public void setSort(int sort) {

this.sort = sort;

}

//实现方法进行排序

@Override

public int compareTo(Poker p) {

return this.sort-p.sort;

}

游戏类：

//一副牌(笛卡尔积)

{

int sort = 0;

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],sort);

//将带花色的扑克牌加入集合

list.add(p);

}

sort++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

Collections.sort(players.get(0).getPokers());

Collections.sort(players.get(1).getPokers());

Collections.sort(players.get(2).getPokers());

for (Player player : players) {

System.out.println(player);

}

}

使用Comparator:排序比较器进行排序：

牌类：

public class Poker {

/**点数*/

private String point;

/**花色*/

private String flower;

/**用于排序的属性*/

private int size;

public Poker() {

}

public Poker(String point, String flower) {

this.point = point;

this.flower = flower;

}

public Poker(String point, String flower, int size) {

this.point = point;

this.flower = flower;

this.size = size;

}

public String getPoint() {

return point;

}

public void setPoint(String point) {

this.point = point;

}

public String getFlower() {

return flower;

}

public void setFlower(String flower) {

this.flower = flower;

}

public int getSize() {

return size;

}

public void setSize(int size) {

this.size = size;

}

@Override

public String toString() {

if (Objects.isNull(flower)){

return point;

}

return flower+""+point;

}

}

游戏类：

//一副牌(笛卡尔积)

{

int size = 0;

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],size);

//将带花色的扑克牌加入集合

list.add(p);

}

//加入点数

size++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

for (int i = 0; i < players.size(); i++) {

players.get(i).getPokers().sort(new Comparator() {

@Override

public int compare(Poker p1, Poker p2) {

return p1.getSize()-p2.getSize();

}

});

System.out.println(players.get(i));

}

}

实现效果：

扩ZtvFdvkfvM展：

以上代码实现发牌原理是给每名玩家一次性随机17张牌，与现实发牌逻辑不符；按照现实发牌逻辑，需要先进行洗牌，打乱牌的顺序，然后轮流给每名玩家发牌，直到剩余三张牌发给地主。

实现原理：在jdk1.2集合框架出现的同时，新增用于对集合处理的工具类 java.util.Collections，这个类与java.util.Arrays同一时间出现；Collections中提供的所有方法都是静态的，方法包括，对集合：查找，排序，洗牌，转换，拷贝，查找最大值/最小值，集合反转，安全集合的获取等一系列静态方法。

这里用到洗牌方法，Collections.shuffle(List> list) (使用默认的随机源随机排列指定的列表)。

代码实现：（将游戏类中发牌的方法进行修改）

private void startGame() {

//玩家加入

playerJoin();

//随机一个地主索引

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname() + "是地主!");

//洗牌

Collections.shuffle(list);

//开始发牌

// for (int i = 0; i < players.size(); i++) {

// //获取当前遍历到的玩家对象

// Player player = players.get(i);

// for (int j = 0; j < 17; j++) {

// //随机获取一张牌给当前玩家

// int n = randomUtils.nextInt(list.size());

// //将随机到的牌存储到玩家的牌集合中

// player.getPokers().add(list.get(n));

// //将已经被取走的牌从原集合中删除

// list.remove(n);

// }

// }

for (int i = 0; i < list.size(); i++) {

if (i < 51) {

switch (i % 3) {

case 0:

players.get(0).getPokers().add(list.get(i));

break;

case 1:

players.get(1).getPokers().add(list.get(i));

break;

case 2:

players.get(2).getPokers().add(list.get(i));

break;

default:

break;

}

} else {

//将剩余三张牌给地主

boss.getPokers().add(list.get(i));

}

}

showPoker();

}

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],sort);

//将带花色的扑克牌加入集合

list.add(p);

}

sort++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

Collections.sort(players.get(0).getPokers());

Collections.sort(players.get(1).getPokers());

Collections.sort(players.get(2).getPokers());

for (Player player : players) {

System.out.println(player);

}

}

使用Comparator:排序比较器进行排序：

牌类：

public class Poker {

/**点数*/

private String point;

/**花色*/

private String flower;

/**用于排序的属性*/

private int size;

public Poker() {

}

public Poker(String point, String flower) {

this.point = point;

this.flower = flower;

}

public Poker(String point, String flower, int size) {

this.point = point;

this.flower = flower;

this.size = size;

}

public String getPoint() {

return point;

}

public void setPoint(String point) {

this.point = point;

}

public String getFlower() {

return flower;

}

public void setFlower(String flower) {

this.flower = flower;

}

public int getSize() {

return size;

}

public void setSize(int size) {

this.size = size;

}

@Override

public String toString() {

if (Objects.isNull(flower)){

return point;

}

return flower+""+point;

}

}

游戏类：

//一副牌(笛卡尔积)

{

int size = 0;

for (int i = 0; i

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],size);

//将带花色的扑克牌加入集合

list.add(p);

}

//加入点数

size++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

for (int i = 0; i < players.size(); i++) {

players.get(i).getPokers().sort(new Comparator() {

@Override

public int compare(Poker p1, Poker p2) {

return p1.getSize()-p2.getSize();

}

});

System.out.println(players.get(i));

}

}

实现效果：

扩ZtvFdvkfvM展：

以上代码实现发牌原理是给每名玩家一次性随机17张牌，与现实发牌逻辑不符；按照现实发牌逻辑，需要先进行洗牌，打乱牌的顺序，然后轮流给每名玩家发牌，直到剩余三张牌发给地主。

实现原理：在jdk1.2集合框架出现的同时，新增用于对集合处理的工具类 java.util.Collections，这个类与java.util.Arrays同一时间出现；Collections中提供的所有方法都是静态的，方法包括，对集合：查找，排序，洗牌，转换，拷贝，查找最大值/最小值，集合反转，安全集合的获取等一系列静态方法。

这里用到洗牌方法，Collections.shuffle(List> list) (使用默认的随机源随机排列指定的列表)。

代码实现：（将游戏类中发牌的方法进行修改）

private void startGame() {

//玩家加入

playerJoin();

//随机一个地主索引

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname() + "是地主!");

//洗牌

Collections.shuffle(list);

//开始发牌

// for (int i = 0; i < players.size(); i++) {

// //获取当前遍历到的玩家对象

// Player player = players.get(i);

// for (int j = 0; j < 17; j++) {

// //随机获取一张牌给当前玩家

// int n = randomUtils.nextInt(list.size());

// //将随机到的牌存储到玩家的牌集合中

// player.getPokers().add(list.get(n));

// //将已经被取走的牌从原集合中删除

// list.remove(n);

// }

// }

for (int i = 0; i < list.size(); i++) {

if (i < 51) {

switch (i % 3) {

case 0:

players.get(0).getPokers().add(list.get(i));

break;

case 1:

players.get(1).getPokers().add(list.get(i));

break;

case 2:

players.get(2).getPokers().add(list.get(i));

break;

default:

break;

}

} else {

//将剩余三张牌给地主

boss.getPokers().add(list.get(i));

}

}

showPoker();

}

for (int j = 0; j < flowers.length; j++) {

Poker p = new Poker(points[i],flowers[j],size);

//将带花色的扑克牌加入集合

list.add(p);

}

//加入点数

size++;

}

//加入大小王

list.add(new Poker("Queen", null,13));

list.add(new Poker("King", null,14));

}

private void showPoker(){

//排序实现

for (int i = 0; i < players.size(); i++) {

players.get(i).getPokers().sort(new Comparator() {

@Override

public int compare(Poker p1, Poker p2) {

return p1.getSize()-p2.getSize();

}

});

System.out.println(players.get(i));

}

}

实现效果：

扩ZtvFdvkfvM展：

以上代码实现发牌原理是给每名玩家一次性随机17张牌，与现实发牌逻辑不符；按照现实发牌逻辑，需要先进行洗牌，打乱牌的顺序，然后轮流给每名玩家发牌，直到剩余三张牌发给地主。

实现原理：在jdk1.2集合框架出现的同时，新增用于对集合处理的工具类 java.util.Collections，这个类与java.util.Arrays同一时间出现；Collections中提供的所有方法都是静态的，方法包括，对集合：查找，排序，洗牌，转换，拷贝，查找最大值/最小值，集合反转，安全集合的获取等一系列静态方法。

这里用到洗牌方法，Collections.shuffle(List> list) (使用默认的随机源随机排列指定的列表)。

代码实现：（将游戏类中发牌的方法进行修改）

private void startGame() {

//玩家加入

playerJoin();

//随机一个地主索引

int index = randomUtils.nextInt(players.size());

//设置指定位的玩家为地主

Player boss = players.get(index);

boss.setBoss(true);

System.out.println(boss.getNickname() + "是地主!");

//洗牌

Collections.shuffle(list);

//开始发牌

// for (int i = 0; i < players.size(); i++) {

// //获取当前遍历到的玩家对象

// Player player = players.get(i);

// for (int j = 0; j < 17; j++) {

// //随机获取一张牌给当前玩家

// int n = randomUtils.nextInt(list.size());

// //将随机到的牌存储到玩家的牌集合中

// player.getPokers().add(list.get(n));

// //将已经被取走的牌从原集合中删除

// list.remove(n);

// }

// }

for (int i = 0; i < list.size(); i++) {

if (i < 51) {

switch (i % 3) {

case 0:

players.get(0).getPokers().add(list.get(i));

break;

case 1:

players.get(1).getPokers().add(list.get(i));

break;

case 2:

players.get(2).getPokers().add(list.get(i));

break;

default:

break;

}

} else {

//将剩余三张牌给地主

boss.getPokers().add(list.get(i));

}

}

showPoker();

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。