java扑克牌

1. java 扑克牌

import java.util.Random;

/**
* 实现输出52张扑克牌 分给四个人A B C D
*/

public class Poker {
public static void main(String args[]) throws Exception {
Random random = new Random();
int[] poker = getPoker();
int j = 0;
int temp = 0;
for (int i = 0; i < 52; i++) {
temp = poker[i];
j = random.nextInt(52);
poker[i] = poker[j];
poker[j] = temp;
}
String A = "A:";
String B = "B:";
String C = "C:";
String D = "D:";
for (int i = 0; i < 52; i++) {
if (i % 4 == 0) {
A += getColor(poker[i]) + format(poker[i] % 13) + "\t";
}
if (i % 4 == 1) {
B += getColor(poker[i]) + format(poker[i] % 13) + "\t";
}
if (i % 4 == 2) {
C += getColor(poker[i]) + format(poker[i] % 13) + "\t";
}
if (i % 4 == 3) {
D += getColor(poker[i]) + format(poker[i] % 13) + "\t";
}
}
System.out.println(A);
System.out.println();
System.out.println(B);
System.out.println();
System.out.println(C);
System.out.println();
System.out.println(D);

}

// 通过数字的大小来断定颜色 从而实现 每种牌都有13张
public static String getColor(int i) {
if ((i - 1) / 13 == 0) {
return "红桃";
} else if ((i - 1) / 13 == 1) {
return "黑桃";
} else if ((i - 1) / 13 == 2) {
return "方块";
} else {
return "梅花";
}
}

// 输出格式 此处实现 1--10正常输出 11，12，0 输出对应的牌号
public static String format(int i) {
if (i == 11) {
return "J";
} else if (i == 12) {
return "Q";
} else if (i == 0) {
return "K";
} else {
return String.valueOf(i);
}
}

// 获得一副扑克
public static int[] getPoker() {
int[] poker = new int[52];
for (int i = 0; i < 52; i++) {
poker[i] = i + 1;
}
return poker;
}
}

2. Java扑克牌问题

使用JAVA编写以下程序：
1、请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit；分别描述一张牌的牌面值（如：A、K、Q、J、10、9、……3、2等）和花色（如：“黑桃”、“红桃”、“梅花”、“方块”）；定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace()，得到扑克牌的牌面值；定义protected访问权限的方法getSuit()，得到扑克牌的花色；定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”等）。

2、若应用程序的main方法中，定义字符串数组f和s；分别表示扑克牌的牌面值和花色；定义52个元素的Card类型数组deck，用来存放4个花色的52张牌。如下所示。
String f[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String s[] = {"黑桃","红桃","梅花","方块"};
Card deck = new Card[52]；
（1）使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、2、3、……、K；然后是红桃花色的A、2、3、……、K；梅花花色的A、2、3、……、K；方块花色的A、2、3、……、K。请写出实现上述功能的程序段。
（2）请编写模拟洗牌的完整程序，即把数组deck中的扑克牌随机打乱存放顺序。

原题如下：

引用内容
private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

解题，完成程序解：

程序代码
package poker;

public class Card {

private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

public static void shuffle(Card[] deck, int startIndex, int size,
int splitIndex) { //shuffle洗牌
System.out.println("startIndex:" + startIndex);
if (splitIndex * 2 > size) { //if rand is 30
Card.swap(deck, startIndex, splitIndex, size - splitIndex); //[52]、0、30、22
shuffle(deck, size - splitIndex, splitIndex, size - splitIndex); //[52]、22、30、22
} else if (splitIndex * 2 < size) { //if rnd is 10
Card.swap(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
shuffle(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
} else {
Card.swap(deck, startIndex, splitIndex, splitIndex);
}

}

public static void swap(Card[] deck, int srcIndex, int dstIndex, int size) { //交换
//SRC是在本位置显示：source的缩写，源的意思 HREF是点击后连接的目标：HyperlinkReference，超链接引用
String face = "";
String suit = "";
for (int i = 0; i < size; i++) {
face = deck[srcIndex + i].face;
suit = deck[srcIndex + i].suit;
deck[srcIndex + i].face = deck[dstIndex + i].face;
deck[srcIndex + i].suit = deck[dstIndex + i].suit;
deck[dstIndex + i].face = face;
deck[dstIndex + i].suit = suit;
}
}

/**
* @param args
*/
public static void main(String[] args) {
//第一问解答
Card[] deck = new Card[52];
String f[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J",
"Q", "K"};
String s[] = {"Spade", "Heart", "Club", "Diamond"};
for (int i = 0; i < s.length; i++) {
for (int j = 0; j < f.length; j++) {
deck[i * 13 + j] = new Card(s[i], f[j]); //依次存入数组之中，每13张一回合
}
}
//第二问解答
int rnd = 0;
int numOfShuffle = 10;
for (int i = 0; i < numOfShuffle; i++) {
rnd = (int) Math.abs(Math.random() * 52); //Math.random()返回大于或等于 0.0 但小于 1.0 的伪随机 double 值。

Card.shuffle(deck, 0, deck.length, rnd);
}
// Test
/*
for (int i=0; i<deck.length; i++)
{
System.out.println(deck[i]);
} */
}

}

3. 用java如何判断扑克牌同花顺

扑克牌有两个属性,花色和牌面大小,可以分别比较花色和牌面大小是否递增或递减来确定是不是同花顺.但是由于扑克牌会有JQKA,所以牌面大小最好以数组或者字符串的方式实现,通过比较下标来比较大小,以下是大概的代码

publicclassPuKe{
	privateStringcolor;
	privateStringnum;
	publicStringgetColor(){
		returncolor;
	}
	publicvoidsetColor(Stringcolor){
		this.color=color;
	}
	publicStringgetNum(){
		returnnum;
	}
	publicvoidsetNum(Stringnum){
		this.num=num;
	}
	
	publicPuKe(Stringcolor,Stringnum){
		super();
		this.color=color;
		this.num=num;
	}
	publicstaticvoidmain(String[]args){
		List<PuKe>card=newArrayList<PuKe>();
		card.add(newPuKe("black","2"));
		card.add(newPuKe("black","3"));
		card.add(newPuKe("black","4"));
		card.add(newPuKe("black","5"));
		card.add(newPuKe("black","6"));
		//这里因为10是两位数且牌面里面用不到1,所以直接用1代替10
		Stringcheck="234567891JQKA";
		booleanflage=true;
		//自定义比较器,用num在check里的下标大小作为比较依据排序
		Collections.sort(card,newComparator<Object>(){
			@Override
			publicintcompare(Objecto1,Objecto2){
				PuKeer1=(PuKe)o1;
				PuKeer2=(PuKe)o2;
				Integerorg1=(int)(er1.getNum()==null?0.0:check.indexOf(er1.getNum()));
				Integerorg2=(int)(er1.getNum()==null?0.0:check.indexOf(er2.getNum()));
				returnorg1.compareTo(org2);
			}
		});
		for(inti=0;i<card.size()-1;i++){
			//遍历所有的牌,如果颜色不一样直接跳出循环,不是同花顺
			if(!card.get(i).getColor().equals(card.get(i+1).getColor())){
				flage=false;
				break;
			}
			//如果上一张减去下一张的差值不是1,说明牌面不是顺子,也不是同花顺,跳出循环
			if((int)check.indexOf(card.get(i+1).getNum())-(int)check.indexOf(card.get(i).getNum())!=1){
				flage=false;
				break;
			}
		}
		if(flage){
			System.out.println("牌面是同花顺");
		}else{
			System.out.println("牌面不是同花顺");
		}
	}
}

不过这种方法唯一不好的地方是check中不能直接用10,将来展示的时候需要判定,展示的是1时直接改成10.

其实实现方法很多,我这么写是因为最近在复习,这么写用到的知识点相对会多一点.

4. JAVA扑克牌编程

1.定义扑克的对象 有两个参数a。花色，b数字Poke{ int number, String color, Poker(String color,int number) { this.color=color; this.number=number; }} 2.每一张牌都实例化一个扑克对象。 poke1= new Poke("红桃","10");poke2=new Poke("黑桃","9"); 3.定义游戏规则类，类里定义一个方法，用来比较大小。public comparePoke(Poke poke1,Poke poke2){ if(花色比较){ return 结果； } if(数字比较){ return 结果； }}。调用方法就能比较

5. java作业：随机出现一张扑克牌。包括花色和点数。【不算大王和小王】怎么写

publicclassPokerTest{
	publicstaticvoidmain(String[]args){
		Poker.show();
	}
}
classPoker{
	publicintnum;
	publicStringbreed;

	publicPoker(){
	}

	publicstaticvoidshow(){
		inti=(int)(Math.random()*13)+1;//生成1-13的随机数
		String[]s=newString[]{"红心","黑桃","方块","黑花"};
		intj=(int)(Math.random()*4);
		Pokerp=newPoker();
		p.num=i;
		p.breed=s[j];
		System.out.println(p.toString());
	}

	@Override
	publicStringtoString(){
		return"Poker[num="+num+",breed="+breed+"]";
	}
}

6. java的问题（扑克牌）

代码仅供参考，如有疑问，欢迎追问：

importjava.util.ArrayList;
importjava.util.List;
importjava.util.Scanner;

/**
*随机扑克牌
*@authorSTONE
*@version2015-10-28
*/
publicclassPoker{
	//用于记录丢失的手牌数
	privatestaticIntegerlostTotal=0;
	//用于存放已下发的扑克
	privatestaticInteger[]its1=newInteger[54];
	//用于存放当前的扑克
	privatestaticInteger[]its2=newInteger[54];
	privatestaticList<Integer>lostList=newArrayList<Integer>();
	
	publicstaticvoidmain(String[]args){
		Scannerscn=newScanner(System.in);
		for(inti=0;i<54;i++){
			its1[i]=0;
			its2[i]=0;
		}
		System.out.println("系统开始发牌...");
		givePoker(5);
		System.out.println("发牌完毕，当前手牌为：");
		printPoker(its2);
		IntegergameTotal=0;
		while(gameTotal<10){//循环跑10次，请注意此处发牌没做限制，如果循环次数过大，会导致死循环
			System.out.println("请输入需要丢弃的手牌(多张牌格式如下：黑桃1,黑桃2,黑桃3)：");
			Stringlost=scn.nextLine();
			checkLost(lost);
			System.out.println("丢失手牌完毕，当前手牌：");
			printPoker(its2);
			System.out.println("系统开始重发手牌...");
			givePoker(lostTotal);
			System.out.println("重发发牌完毕，当前手牌为：");
			printPoker(its2);
			gameTotal++;
		}
		scn.close();
	}
	
	publicstaticvoidgivePoker(Integernum){//随机分发手牌
		inttotal=0;
		while(total<num){
			intpoke=(int)(Math.random()*54);
			if(its1[poke]==0){
				its1[poke]=1;
				its2[poke]=1;
				total++;
			}
		}
		lostTotal=0;
	}
	
	publicstaticBooleancheckLost(Stringlost){//检查需要丢失的手牌
		if(lost==null||lost.equals("")){
			System.out.println("输入手牌错误，系统无法处理...");
			returnfalse;
		}
		if(lost.indexOf("黑桃")<0&&lost.indexOf("红心")<0&&lost.indexOf("梅花")<0&&lost.indexOf("方块")<0){
			System.out.println("输入手牌错误，系统无法处理...");
			returnfalse;
		}
		String[]strs=lost.split(",");
		Booleanbol=false;
		for(Stringstr:strs){
			str=str.trim();
			if(str==null||str.equals(""))continue;//去掉，防止空格
			bol=getPokerNum(str);
		}
		if(bol){
			losePoker();
		}
		returnfalse;
	}
	
	publicstaticvoidlosePoker(){//丢掉手牌
		lostTotal=lostList.size();
		for(Integeritr:lostList){//丢掉手牌
			its2[itr-1]=0;
		}
		lostList=newArrayList<Integer>();
	}
	
	(Stringstr){//获取手牌点数并去掉
		try{
			Integeritr=0;
			if(str.indexOf("黑桃")==0){
				str=str.replace("黑桃","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：黑桃"+str);
					returnfalse;
				}
				if(its2[itr-1]==1){
					lostList.add(itr);
				}
			}elseif(str.indexOf("红心")==0){
				str=str.replace("红心","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：红心"+str);
					returnfalse;
				}
				if(its2[itr+12]==1){
					lostList.add(itr+13);
				}
			}elseif(str.indexOf("梅花")==0){
				str=str.replace("梅花","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：梅花"+str);
					returnfalse;
				}
				if(its2[itr+25]==1){
					lostList.add(itr+26);
				}
			}elseif(str.indexOf("方块")==0){
				str=str.replace("方块","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：方块"+str);
					returnfalse;
				}
				if(its2[itr+38]==1){
					lostList.add(itr+39);
				}
			}elseif(str.indexOf("小王")==0){
				if(its2[52]==1){
					lostList.add(53);
				}
			}elseif(str.indexOf("大王")==0){
				if(its2[53]==1){
					lostList.add(54);
				}
			}
			returntrue;
		}catch(Exceptione){
			System.out.println("输入手牌有误...");
			returnfalse;
		}
	}
	
	publicstaticvoidprintPoker(Integer[]its){//打印当前手牌
		Stringresult="";
		for(inti=0;i<its.length;i++){
			if(its[i]==1){//等于1表示当前手牌存在
				result+=pukerCheck(i+1)+",";
			}
		}
		System.out.println(result);
	}
	
	publicstaticStringpukerCheck(Integeritr){//判断扑克类型
		/**
		*1~13黑桃花色、14~26红心花色、27~39梅花花色
		*40~52方块花色、53小王、54大王
		*/
		if(1<=itr&&itr<=13){
			return"黑桃"+itr;
		}elseif(14<=itr&&itr<=26){
			return"红心"+(itr-13);
		}elseif(27<=itr&&itr<=39){
			return"梅花"+(itr-26);
		}elseif(40<=itr&&itr<=52){
			return"方块"+(itr-39);
		}elseif(itr==53){
			return"小王";
		}elseif(itr==54){
			return"大王";
		}
		return"";
	}

}

测试运行结果：

7. java语言编程扑克牌

一：import java.util.Scanner;
public class Play {
/**
* 玩牌
*/
public static void main(String[] args) {
Poker poker = new Poker();
boolean over = false;
Scanner cin=new Scanner(System.in);
while(!over){
System.out.println("打牌输入1，展示剩余牌输入其他字符：");
String c=cin.nextLine();
if("1".equals(c)){
int index = (int) (Math.random()*poker.getSize());
poker.remove(index);
}else{
poker.ShowPages();
}
}
/*for(int i = 0;i<54;i++){
int index = (int) (Math.random()*poker.getSize());
poker.remove(index);
poker.ShowPages();
}
*/
}
}二：//牌
public class Page { private String huase = "";
private String haoma = "";
public Page(String huase,String haoma){
this.huase = huase;
this.haoma = haoma;
}
public String show(){
return this.huase+this.haoma;
}
}三：import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 一副扑克
*/
public class Poker {
private List pages = new ArrayList();
public Poker(){
String huase[] = new String[]{"黑桃","红桃","草花","方块"};
String haoma[] = new String[]{"A","2","3","4","5","6","7","8","9","10"
,"J","Q","K"};
for(int i = 0;i<haoma.length;i++){
for(int j = 0;j<huase.length;j++){
pages.add(new Page(huase[j],haoma[i]));
}
}
pages.add(new Page("","大王"));
pages.add(new Page("","小王"));
}
public void ShowPages(){
System.out.println("展示剩余牌：");
for(Iterator i = pages.iterator();i.hasNext();){
System.out.println(((Page)i.next()).show());
}
}
//打牌
public void remove(int index){
pages.remove(index);
}
//剩余牌数
public int getSize(){
return pages.size();
}
}

8. java编写一副扑克牌，并完成以下要求：

首先想一下扑克有什么属性和方法
例如：编码，标识（id），名字，图像，是否隐藏，是否正反面，分值，位置等
方法： 显示隐藏扑克，正反面扑克，点击双击扑克，鼠标拖动 等
一副扑克类
包含一个扑克数组，洗牌就是随机扑克反牌。。。派牌（规则，位置等等）