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），名字，圖像，是否隱藏，是否正反面，分值，位置等
方法： 顯示隱藏撲克，正反面撲克，點擊雙擊撲克，滑鼠拖動 等
一副撲克類
包含一個撲克數組，洗牌就是隨機撲克反牌。。。派牌（規則，位置等等）