java斗地主游戏初始化牌，洗牌，发牌，给用户从大到小的顺序排牌（多知识点复习）

首先创建一个牌类

/**
 * 定义一个牌类
 */
public class Card {
	private String size; //点数
	private String color;//花色
	private int index;//实际牌的大小
	/**
	 * @return the size
	 */
	public String getSize() {
		return size;
	}
	/**
	 * @return the index
	 */
	public int getIndex() {
		return index;
	}
	/**
	 * @param index the index to set
	 */
	public void setIndex(int index) {
		this.index = index;
	}
	/**
	 * @param size the size to set
	 */
	public void setSize(String size) {
		this.size = size;
	}
	/**
	 * @return the color
	 */
	public String getColor() {
		return color;
	}
	/**
	 * @param color the color to set
	 */
	public void setColor(String color) {
		this.color = color;
	}
	public Card(String size, String color,int index) {
		super();
		this.size = size;
		this.color = color;
		this.index=index;
	}
	@Override
	public String toString() {
		return size+color;
	}
}

全局中只需使用一套牌，所以定义而一个静态的集合装牌

public static List<Card> c=new ArrayList<>(); 

使用静态代码块，在加载主函数之前把拍初始化

	//使用静态代码块初始化牌
	static {
		String[] size= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String[] color= {"红桃","黑桃","方片","梅花"};
		int index=0;//记录牌的实际大小，方便后面用比较器比较
		for (String msize : size) {
			index++;
			
			for (String mcolor : color) {
				
				Card card=new Card(msize, mcolor,index); //每一个点数和花色组成一个牌对象
				c.add(card); //把牌对象放入牌集合
				
			}
			
		}
		//把大王和小王加入到牌集合
		Card xiaowang=new Card("", "小王",++index);
		Card dawang=new Card("", "大王",++index);
		Collections.addAll(c,dawang, xiaowang); //把大王小王加入牌对象
		
	}

这里使用，index记录牌真实的大小，主要是为了，后面用比较器的时候自定义比较规则就非常的方便了

定义三个玩家，也就是三个容器分别装他们应有的牌

	//定义三个玩家，拿3个容器去装牌
		List<Card> play1=new ArrayList<>();
		List<Card> play2=new ArrayList<>();
		List<Card> play3=new ArrayList<>();

发牌
一共有54张牌，发五十一张，留3张底牌

		for (int i=0;i<c.size()-3;i++) {
			if(i%3==0) {
				play1.add(c.get(i));
			}
			if(i%3==1) {
				play2.add(c.get(i));
				
			}
			if(i%3==2) {
				play3.add(c.get(i));
			}
		}
		//三张底牌在用一个子集合容器装
		List<Card> di=new ArrayList<>();
		di=c.subList(c.size()-3, c.size());

三张底牌也用集合容器装，方便后面谁是地主，直接就把三张底牌一起注入到其他集合去

发完牌后定义，需要给玩家把拍进行排序，方便看牌，这时候前面定义的实际大小就用到了

	private static void sortCard(List<Card> player) {
		// TODO Auto-generated method stub
		Collections.sort(player,new Comparator<Card>() {
			@Override
			public int compare(Card o1, Card o2) {
				// TODO Auto-generated method stub
				return o2.getIndex()-o1.getIndex();//牌由大到小放置
			}
		});
		
	}

下面是全部代码，我放在一起，包括定义牌，洗牌，发牌，牌排序，打牌的功能我还没有学到，后面会补上，这个游戏是对集合的复习

package 斗地主;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {
	//因为全局中只有一副牌供给大家使用，所以定义为静态的
	public static List<Card> c=new ArrayList<>(); 

	//使用静态代码块初始化牌
	static {
		String[] size= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String[] color= {"红桃","黑桃","方片","梅花"};
		int index=0;//记录牌的实际大小，方便后面用比较器比较
		for (String msize : size) {
			index++;
			
			for (String mcolor : color) {
				
				Card card=new Card(msize, mcolor,index); //每一个点数和花色组成一个牌对象
				c.add(card); //把牌对象放入牌集合
				
			}
			
		}
		//把大王和小王加入到牌集合
		Card xiaowang=new Card("", "小王",++index);
		Card dawang=new Card("", "大王",++index);
		Collections.addAll(c,dawang, xiaowang); //把大王小王加入牌对象
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("原始的牌"+c);
		Collections.shuffle(c);//洗牌
		System.out.println("洗好的牌"+c);
		//定义三个玩家，拿3个容器去装牌
		List<Card> play1=new ArrayList<>();
		List<Card> play2=new ArrayList<>();
		List<Card> play3=new ArrayList<>();
		
		//发牌
		//一共有54张牌，发五十一张，留3张底牌
		for (int i=0;i<c.size()-3;i++) {
			if(i%3==0) {
				play1.add(c.get(i));
			}
			if(i%3==1) {
				play2.add(c.get(i));
				
			}
			if(i%3==2) {
				play3.add(c.get(i));
			}
		}
		//三张底牌在用一个子集合容器装
		List<Card> di=new ArrayList<>();
		di=c.subList(c.size()-3, c.size());
		

		
		//给玩家的牌由大到小排序
		sortCard(play1);
		sortCard(play2);
		sortCard(play3);
		System.out.println("玩家1的牌为："+play1);
		System.out.println("玩家2的牌为："+play2);
		System.out.println("玩家3的牌为："+play3);
		System.out.println("底牌"+di);
	
		

	}

	private static void sortCard(List<Card> player) {
		// TODO Auto-generated method stub
		Collections.sort(player,new Comparator<Card>() {
			@Override
			public int compare(Card o1, Card o2) {
				// TODO Auto-generated method stub
				return o2.getIndex()-o1.getIndex();//牌由大到小放置
			}
		});
		
	}
	

}

比较器还可以使用Lamubda进行化简

化简的规则为

参数类型可以省略不写

如果只有一个参数，参数类型可以省略，同时（也可以省略）

如果Lamubda表达式的方法体代码只有一行代码。可以省略大括号不写，同时省略分号

如果Lamubda表达式的方法体只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省省略分号不写

比较的方法就可以写为

	private static void sortCard(List<Card> player) {
		Collections.sort(player,( o1,  o2)->  o2.getIndex()-o1.getIndex());//牌由大到小放置				
	}