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

斗地主

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);
	
		
	}
}

运行结果