JAVA====发扑克牌的简单实现

要求：模拟挖坑游戏发牌，不带大小王共52张牌，将牌随机分发给三个人，留四张作为底牌，牌的花色从大到小依次为：黑桃，红桃，梅花，方块；每个人十六牌，将牌排序。

1.定义牌的属性

扑克牌有俩种属性，一为牌的数字，二位牌的花色，在挖坑游戏中4最小，3最大，所以当牌的数字大于10的时候需要将后面的数字进行替换，11为”J“，12为“Q”，13为“K“，14为“A”，15为“2”，16为“3”。

public class Pai implements Comparable<Pai>{
	private final int num;
	private final HuaSe color;
	public Pai(int num,HuaSe color) {
		this.num=num;
		this.color=color;
	}
	public HuaSe getColor() {
		return color;
	}
	public int getNum() {
		return this.num;
	}
	public String toString() {
		String aa=""+num;
		if(num>10) {
			if(num==11)
				aa="J";
			else if(num==12)
				aa="Q";
			else if(num==13)
				aa="K";
			else if(num==14)
				aa="A";
			else if(num==15)
				aa="2";
			else if(num==16)
				aa="3";
			}
		String res="("+num+color+")";
		return res;
	}
	@Override
	public int compareTo(Pai o) {
		// TODO Auto-generated method stub
		return 0;
	}
	

}

2.牌花色的定义

牌有四种花色，在这里用到枚举类型

public enum HuaSe {
	黑桃,红桃,梅花,方块;
}

3.存放牌的数组定义

由于需要将牌进行比较排序，所以在这里引用了JAVA中自带的排序接口Comparable来定义数组；

同时在数组类中还需要添加牌的方法，删除牌的方法，以及排序方法

public class ArrayList {
	private Comparable[] arr;
	private int size=0;
	public ArrayList() {
		this(10);
	}
	public ArrayList(int length) {
		arr=new Comparable[length];
	}
	public void add(Comparable data) {
		arr[size++]=data;
		if(size>=arr.length)
			resize();
	}
	public Comparable delete(int index) {
		Comparable res=arr[index];
		System.arraycopy(arr, index+1, arr, index, arr.length-index-1);
		arr[size-1]=null;
		size--;
		return res;
	}
	public void update(int index,Comparable data) {
		arr[index]=data;
	}
	
	public Comparable[] getData() {
		return this.arr;
	}
	public int size() {
		return this.size;
	}
	public String toString() {
		return Arrays.toString(arr);
	}
	public Comparable[] sort() {
		Comparable[] res=getData();
		Arrays.sort(res);
		return res;
	}
	private void resize() {
		Comparable[] res=new Comparable[arr.length*3/2];
		System.arraycopy(arr, 0, res, 0, arr.length);
		this.arr=res;
	}

}

4.所有牌的牌盒

需要将四种花色，4到16的数字，共52张牌放入牌盒的数组中，添加发牌的方法，发牌时随机发放，并且每发出一张牌盒中的减少一张，发牌方法类型为牌数组的类型，返回三个人得到牌的数组

public class PaiHe {
private ArrayList pais=new ArrayList(53);
public PaiHe(){
	for(HuaSe tmp:HuaSe.values()) {
		for(int k=4;k<17;k++) {
			pais.add(new Pai(k, tmp));
		}
	}
}
public Pai[] faPai() {
	Random r=new Random();
	Pai[] res=new Pai[16];
	for(int i=0;i<3;i++) {
		int pos=r.nextInt(pais.size());
		Object p=pais.delete(pos);
		if(p!=null && p instanceof Pai) {
			Pai pp=(Pai)p;
			res[i]=pp;
		}
	}
	return res;
}
}

5.主方法实现发牌

将牌平均发给三个人，留下四张作为底牌，用到Comparator排序方法

public static void main(String[] args) {
	PaiHe ph=new PaiHe();
	for(int i=0;i<3;i++) {
		Pai[] arr=ph.faPai();
		Arrays.sort(arr, new Comparator<Pai>() {
			public int compare(Pai o1,Pai o2) {
				int res=o1.getNum()-o2.getNum();
				if(res==0) {
					res=o1.getColor().compareTo(o2.getColor());
				}
				return res;
			}
		});
		System.out.println(Arrays.toString(arr));
	}
	System.out.println("底牌:");
	System.out.println(Arrays.toString(ph.getPais().getData()));
}
public ArrayList getPais() {
	return pais;
}
}

Comparator<T>:T为范型的限定，compare(Pai o1,Pai o2)中o1表示前面的对象，o2表示后面的对象，res返回-1不需要交换位置，返回1交换o1与o2的位置，自定义在res为0的时候比较花色。