java实现斗地主发牌简单逻辑（数组）

蔚落 2022-01-05 08:17 350阅读 0赞

## 斗地主 ##

[Arraliyst实现斗地主][Arraliyst]

### 1. 分析 ###

1.  生成一副牌并且分配给3个人，并且可以指定其中一个人为地主  
    一副扑克 共有54张  
    每一张扑克： 牌面值、花色（黑桃、红桃、梅花、方块）  
    特殊情况： 大王、小王
2.  牌面值  
    2、3、。。。10，j、Q、K 、A 、小王、大王  
    牌面的计算属性值：  
    j = 11  
    Q = 12  
    K = 13  
    A = 14  
    2 = 15  
    小王 = 16  
    大王 = 17

***如何产生出一副牌？***

发牌

3个人斗  
每人拿17张 如果是地主 多拿3张

发牌的过程

循环17次每次随机从数组中获取3张牌发给每个人

随机产生地主，地主获取剩余中3张牌

## 2.代码实现 ##

### 1. 数组实现 ###

**手牌类**

package com.fjh.entity;
    /** * 卡牌類型 * @author 冯佳豪 * */
    public class Cards { 
    	/** * 牌值 */
    	private int value;
    	/** * 牌面 */
    	private String text;
    	/** * 花色 */
    	private String style;
    	public int getValue() { 
    		return value;
    	}
    	public void setValue(int value) { 
    		this.value = value;
    	}
    	public String getText() { 
    		return text;
    	}
    	public void setText(String text) { 
    		this.text = text;
    	}
    	public String getStyle() { 
    		return style;
    	}
    	public void setStyle(String style) { 
    		this.style = style;
    	}
    	
    	@Override
    	public String toString() { 
    		return this.style+""+this.text+" ";
    	}
    	/** * 构造函数初始化牌的格式 * @param value 牌面值 * @param text 手牌显示内容 * @param style 花色 */
    	public Cards(int value, String text, String style) { 
    		super();
    		this.value = value;
    		switch (value) { 
    		case 11:
    			this.text = "J";
    			break;
    		case 12:
    			this.text = "Q";
    			break;
    		case 13:
    			this.text = "K";
    			break;
    		case 14:
    			this.text = "A";
    			break;
    		case 15:
    			this.text = "2";
    			break;
    		case 16:
    			this.text = "小王";
    			break;
    		case 17:
    			this.text = "大王";
    			break;
    		default:
    			this.text = value+"";
    			break;
    		}
    		this.style = style;
    	}
    	public Cards() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    }

**赌徒类**

package com.fjh.entity;
    
    public class Gambler { 
    	/** * 每个赌徒手上的牌数 */
    	private Cards[] cards= new Cards[20];
    	/** * 判断是否为地主（true），默认为平民（false） */
    	private boolean isLandlord = false;
    	
    	public Cards[] getCards() { 
    		return cards;
    	}
    	public void setCards(Cards[] cards) { 
    		this.cards = cards;
    	}
    	public boolean isLandlord() { 
    		return isLandlord;
    	}
    	public void setLandlord(boolean isLandlord) { 
    		this.isLandlord = isLandlord;
    	}
    }

**手牌操作**

package com.fjh.control;
    
    import java.util.Arrays;
    import java.util.Random;
    
    import com.fjh.entity.Cards;
    import com.fjh.entity.Gambler;
    
    /** * 卡牌操作类 * * @author 冯佳豪 * */
    public class FightTheLandlord { 
    	/** * 产生扑克牌 * * @return 扑克牌 */
    	public Cards[] Produce() { 
    		Cards[] cs = new Cards[54];// 54张扑克
    		String[] style = new String[] {  "黑桃", "红桃", "梅花", "方块" };// 四种花色
    		int cardIndex = 0;// 记录牌的下标以便于接下来赋值
    		for (int j = 0; j < style.length; j++) { // 每种花色产生13张牌,牌值是从3到15
    			for (int i = 3; i <= 15; i++) { 
    				Cards card = new Cards(i, "" + j, style[j]);// 牌值在构造函数会进行判断进行相应的转换
    				cs[cardIndex] = card;
    				cardIndex++;
    			}
    		}
    		// 添加大王小王
    		cs[cs.length - 2] = new Cards(16, "" + 16, "");
    		cs[cs.length - 1] = new Cards(17, "" + 17, "");
    
    		return cs;
    	}
    
    	/** * 随机发牌，每人17张 * * @param cards * 将要发的卡牌数组对象 * @param gambler * 赌徒 */
    	public void sendCards(Cards[] cards, Gambler[] gambler) { 
    		// 判断赌徒人数是否正确
    		if (gambler.length != 3) { 
    			System.out.println("人数错误！");
    			return;
    		}
    		// 给每个人发牌，每人17张
    		for (int i = 0; i < 17; i++) { 
    			for (int j = 0; j < gambler.length; j++) { 
    				// 随机抽取牌发给每个人，从cards数组里面抽取
    				int cardsIndex = new Random().nextInt(cards.length);
    				// 将卡牌赋值，gambler[j]表示当前赌徒，getCards()为获取赌徒的卡牌方法，返回的是数组对象
    				gambler[j].getCards()[i] = cards[cardsIndex];
    				// 将赋值的卡牌对象从数组对象中删除
    				Cards[] newcards = new Cards[cards.length - 1];// 创建一个新的卡牌数组用来接收剩余卡牌
    				if (cardsIndex == cards.length) { // 如果随机的是最后一张，则直接将数组长度缩小1
    					newcards = Arrays.copyOf(cards, cards.length - 1);
    				} else { // 不是中间的位置将这选中的卡牌用最后一张代替，卡牌数组对象长度缩小1
    					cards[cardsIndex] = cards[cards.length - 1];
    					newcards = Arrays.copyOf(cards, cards.length - 1);
    				}
    				// 重新赋值
    				cards = newcards;
    			}
    		}
    
    		// 随机产生一个地主对象将剩余三张卡牌取走
    		int index = new Random().nextInt(gambler.length);
    		gambler[index].setLandlord(true);
    
    		// 地主
    		for (int i = 0; i < gambler.length; i++) { 
    			if (gambler[i].isLandlord()) { 
    				Gambler landlord = gambler[index];
    				RasingLandlord(cards, landlord, index);
    			}
    		}
    
    		sort(gambler);
    		displayCards(gambler, index);
    	}
    
    	/** * 整理赌徒手牌（排序） * * @param gamblers * 赌徒 */
    	public void sort(Gambler[] gamblers) { 
    		// 循环给每一个赌徒整理手牌
    		for (Gambler gambler : gamblers) { 
    			for (int i = 0; i < gambler.getCards().length - 1; i++) { 
    				for (int j = 0; j < gambler.getCards().length - 1 - i; j++) { 
    					if (gambler.getCards()[j] != null && gambler.getCards()[j + 1] != null) { 
    						if (gambler.getCards()[j].getValue() > gambler.getCards()[j + 1].getValue()) { 
    							Cards temp = gambler.getCards()[j];
    							gambler.getCards()[j] = gambler.getCards()[j + 1];
    							gambler.getCards()[j + 1] = temp;
    						}
    
    					}
    
    				}
    			}
    		}
    	}
    
    	/** * 显示手牌 * * @param gamblers * 赌徒 * @param index * 地主下标 */
    	public void displayCards(Gambler[] gamblers, int index) { 
    		System.out.println("被玩家" + (index+1) + "抢到了地主！");
    		for (Gambler gambler : gamblers) { 
    			for (int i = 0; i < gambler.getCards().length; i++) { 
    				System.out.print(gambler.getCards()[i]);// 默认调用toString方法
    			}
    			System.out.println();
    		}
    	}
    
    	/** * 抢地主 * * @param cards * 手牌 * @param gambler * 赌徒 * @param index * 被选中赌徒下标 */
    	public void RasingLandlord(Cards[] cards, Gambler gambler, int index) { 
    		// 随机产生一个地主对象将剩余三张卡牌取走
    
    		gambler.getCards()[gambler.getCards().length - 1] = cards[cards.length - 1];
    		gambler.getCards()[gambler.getCards().length - 2] = cards[cards.length - 2];
    		gambler.getCards()[gambler.getCards().length - 3] = cards[cards.length - 3];
    
    	}
    
    }

**测试类**

package com.fjh.test;
    /** * 测试斗地主游戏 * @author 冯佳豪 * */
    
    import com.fjh.control.FightTheLandlord;
    import com.fjh.entity.Cards;
    import com.fjh.entity.Gambler;
    
    public class Game { 
    	
    
    	public static void main(String[] args) { 
    		
    		FightTheLandlord fight = new FightTheLandlord();
    		//产生一副扑克牌
    		Cards cs[] = fight.Produce();
    		Gambler gambler[] = { new Gambler(),new Gambler(),new Gambler()};
    	
    		//分配手牌
    		fight.sendCards(cs,gambler);
    	
    		
    	}
    }

**运行结果**  
![在这里插入图片描述][20190623155451826.png]

[Arraliyst]: https://blog.csdn.net/qq_40896997/article/details/93518169
[20190623155451826.png]: /images/20211229/2329a67daa99474cabb6d0508bb4338d.png