java實現撲克牌發牌器（用java編寫一個撲克牌的程序）

本文目錄一覽：

• 1、java編寫撲克牌發牌程序，牌正面的圖片無法顯示，求高手解答！！
• 2、java的問題（撲克牌）
• 3、java寫一個撲克牌程序
• 4、用java ArrayList集合編寫撲克牌洗牌與發牌
• 5、java 52張 撲克牌 問題
• 6、java編寫撲克牌遊戲里，洗牌時發牌時用到了隨機分配的功能，請問在那個包中哪個類哪個方法？

java編寫撲克牌發牌程序，牌正面的圖片無法顯示，求高手解答！！

不支持顏色轉換的要求 ImageIO兼容的圖片格式。JPG也分很多種的。

bmp gif jpeg jpeg-lossless jpeg2000 png pnm raw tiff wbmp

jpg的分類多 建議把圖片都改成bmp

java的問題（撲克牌）

代碼僅供參考，如有疑問，歡迎追問：

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

/**

 * 隨機撲克牌

 * @author STONE

 * @version 2015-10-28

 */

public class Poker {

//用於記錄丟失的手牌數

private static Integer lostTotal = 0;

//用於存放已下發的撲克

private static Integer[] its1 = new Integer[54];

//用於存放當前的撲克

private static Integer[] its2 = new Integer[54];

private static ListInteger lostList = new ArrayListInteger();

public static void main(String[] args) {

Scanner scn = new Scanner(System.in);

for(int i=0;i54;i++){

its1[i] = 0;

its2[i] = 0;

}

System.out.println(“系統開始發牌…”);

givePoker(5);

System.out.println(“發牌完畢，當前手牌為：”);

printPoker(its2);

Integer gameTotal = 0;

while(gameTotal10){//循環跑10次，請注意此處發牌沒做限制，如果循環次數過大，會導致死循環

System.out.println(“請輸入需要丟棄的手牌(多張牌格式如下：黑桃1,黑桃2,黑桃3)：”);

String lost = scn.nextLine();

checkLost(lost);

System.out.println(“丟失手牌完畢，當前手牌：”);

printPoker(its2);

System.out.println(“系統開始重發手牌…”);

givePoker(lostTotal);

System.out.println(“重發發牌完畢，當前手牌為：”);

printPoker(its2);

gameTotal++;

}

scn.close();

}

public static void givePoker(Integer num){//隨機分發手牌

int total = 0;

while(totalnum){

int poke = (int)(Math.random()*54);

if(its1[poke] == 0){

its1[poke] = 1;

its2[poke] = 1;

total++;

}

}

lostTotal = 0;

}

public static Boolean checkLost(String lost){//檢查需要丟失的手牌

if(lost==null || lost.equals(“”)){

System.out.println(“輸入手牌錯誤，系統無法處理…”);

return false;

}

if(lost.indexOf(“黑桃”)0  lost.indexOf(“紅心”)0  lost.indexOf(“梅花”)0  lost.indexOf(“方塊”)0){

System.out.println(“輸入手牌錯誤，系統無法處理…”);

return false;

}

String[] strs = lost.split(“,”);

Boolean bol = false;

for(String str : strs){

str = str.trim();

if(str==null || str.equals(“”)) continue;//去掉，防止空格

bol = getPokerNum(str);

}

if(bol){

losePoker();

}

return false;

}

public static void losePoker(){//丟掉手牌

lostTotal = lostList.size();

for(Integer itr : lostList){//丟掉手牌

its2[itr-1] = 0;

}

lostList = new ArrayListInteger();

}

public static Boolean getPokerNum(String str){//獲取手牌點數並去掉

try{

Integer itr = 0;

if(str.indexOf(“黑桃”)==0){

str = str.replace(“黑桃”, “”);

itr = Integer.parseInt(str);

if(itr13){

System.out.println(“輸入手牌不存在：黑桃”+str);

return false;

}

if(its2[itr-1]==1){

lostList.add(itr);

}

} else if(str.indexOf(“紅心”)==0){

str = str.replace(“紅心”, “”);

itr = Integer.parseInt(str);

if(itr13){

System.out.println(“輸入手牌不存在：紅心”+str);

return false;

}

if(its2[itr+12]==1){

lostList.add(itr+13);

}

} else if(str.indexOf(“梅花”)==0){

str = str.replace(“梅花”, “”);

itr = Integer.parseInt(str);

if(itr13){

System.out.println(“輸入手牌不存在：梅花”+str);

return false;

}

if(its2[itr+25]==1){

lostList.add(itr+26);

}

} else if(str.indexOf(“方塊”)==0){

str = str.replace(“方塊”, “”);

itr = Integer.parseInt(str);

if(itr13){

System.out.println(“輸入手牌不存在：方塊”+str);

return false;

}

if(its2[itr+38]==1){

lostList.add(itr+39);

}

} else if(str.indexOf(“小王”)==0){

if(its2[52]==1){

lostList.add(53);

}

} else if(str.indexOf(“大王”)==0){

if(its2[53]==1){

lostList.add(54);

}

}

return true;

} catch( Exception e ){

System.out.println(“輸入手牌有誤…”);

return false;

}

}

public static void printPoker(Integer[] its){//打印當前手牌

String result = “”;

for(int i=0;iits.length;i++){

if(its[i]==1){//等於1表示當前手牌存在

result+=pukerCheck(i+1)+”,”;

}

}

System.out.println(result);

}

public static String pukerCheck(Integer itr){//判斷撲克類型

/**

 * 1~13黑桃花色、14~26紅心花色、27~39梅花花色

 * 40~52方塊花色、53小王、54大王

 */

if(1=itr  itr=13){

return “黑桃”+itr;

} else if(14=itr  itr=26){

return “紅心”+(itr-13);

} else if(27=itr  itr=39){

return “梅花”+(itr-26);

} else if(40=itr  itr=52){

return “方塊”+(itr-39);

} else if(itr==53){

return “小王”;

} else if(itr==54){

return “大王”;

}

return “”;

}

}

測試運行結果：

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; ideck.length; i++)

{

System.out.println(deck[i]);

} */

}

}

用java ArrayList集合編寫撲克牌洗牌與發牌

import java.util.ArrayList;

import java.util.Random;

public class PokerDemo {

ArrayListCard poker = new ArrayListCard();

Player[] players;

int n = 4;

String[] name = {“Wang”, “Zhang”, “Li”, “Yuan”};

public PokerDemo() {

players = new Player[n];

for(int i = 0; i players.length; i++)

players[i] = new Player(name[i]);

for(int i = 0; i 4; i++)

for(int j = 0; j 13; j++)

poker.add(new Card(i, j));

System.out.println(“洗牌前: ” + poker);

xipai();

System.out.println(“洗牌後: ” + poker);

fapai();

System.out.println(“發牌後: “);

for(int i = 0; i players.length; i++)

System.out.println(players[i]);

}

public void xipai() {

Random r = new Random();

ArrayListCard tmp = new ArrayListCard();

while(!poker.isEmpty()) {

int index = r.nextInt(poker.size());

Card card = poker.get(index);

tmp.add(card);

poker.remove(index);

}

poker = new ArrayListCard(tmp);

}

public void fapai() {

int p = 0;

while(!poker.isEmpty()) {

Card card = poker.get(0);

players[p].add(card);

p = (p + 1) % n;

poker.remove(0);

}

}

public static void main(String[] args) {

new PokerDemo();

}

}

class Card {

int val, sty;

final String[] value = {“A”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K”};

final String[] style = {“黑桃”, “紅心”, “梅花”, “方塊”};

public Card(int s, int v) {

sty = s;

val = v;

}

public String toString() {

return style[sty]+ ” ” + value[val];

}

}

class Player {

ArrayListCard cards = new ArrayListCard();

String name;

public Player(String n) {

name = n;

}

public void add(Card card) {

cards.add(card);

}

public String toString() {

return name + “:\t” + cards;

}

}

java 52張 撲克牌 問題

識別類：

一張牌：public class Card{};

一副牌：public class Poker{};

帶main方法的類用於實現洗牌和切牌：public class Shuffle{};

識別屬性：

class Card:

一張牌應該具有花色和點數這兩個屬性：

private color; //花色

private value; //點數

class Poker:

一副牌有54張牌，四種花色，每種花色都有2~A的點數：

static Card[] cards=new Card[54]；// 每副撲克都有54張牌；

static String[] colors={“紅桃”,”黑桃”,”方塊”,”梅花”}； //每副牌都有四種花色；

static String values[]={“2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”,”A”};//每個花

色的點數

定義類：

public class Card{

String color;

String value;

//定義一個構造函數用於初始化點數2~A的牌

public Card(String color,String value){

this.color = color;

this.value = value;

}

//定義一個構造函數用於初始化大王和小王

public Card(String value){

this.color=””; //如果不給color賦值的話，洗牌和切牌後的大小王前面會顯示“null”

this.value = value;

}

// 取一張牌的花色

public String getcolor() {

return color;

}

// 取一張牌的值

public String getvalue() {

return value;

}

}

public class Poker{

static Card[] cards=new Card[54];

static String[] colors={“紅桃”,”黑桃”,”方塊”,”梅花”};

static String values[]={“2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”,”A”};

//構造方法Poker（）用於初始化這副撲克

public Poker() {

for (int i = 0; i colors.length; i++) {

for (int j = 0; j values.length; j++) {

cards[i * 13 + j] = new Card(colors[i], values[j]);

}

}

cards[52] = new Card(“小王”);

cards[53] = new Card(“大王”);

}

//方法getCard()用於獲取一張牌的花色和點數

public Card[] getCard() {

return Poker.cards;

}

//方法Show()用於顯示一副新的撲克

public void Show() {

……………………

}

public class Shuffle {

static Poker poker = new Poker();

static Card[] cards = new Card[54];

//方法random用於返回一個不重複的數組

public static int[] random(int length) {

int[] a = new int[length];

for (int i = 0; i length; i++) {

a[i] = (int) (Math.random() * length);//產生一個0到length的隨機數

for (int j = 0; j i; j++) {

if (a[j] == a[i]) {//比較是否相等，如果相等則重新產生

i–;

break;

}

}

}

return a;

}

//方法xipai（）用於將所得的隨機數組的值賦值給牌的下標

public static void xipai() {

int[] b = new int[54];

b = random(54);//調用random方法產生一個長度為54的不重複的隨機數組

cards = poker.getCard();

Card temp = null;

for(int i = 0; i b.length; i++){ //開始遍曆數組實現重新排列

int k = b[i];

temp = cards[k];

cards[i] = cards[k];

cards[k] = temp;}

//輸出洗牌後的撲克

……………………

……………………

}

//方法qiepai（）實現撲克的切牌操作

public static void qiepai(int length) {

int number = (int) (Math.random() * length);//產生一個隨機數

System.out.println(“隨機數為:” + number);//顯示隨機數是多少

Card[] temp = new Card[length];

int start = number;//設置切牌後的起點位置

for (int i = 0; i length – number; i++) {

temp[i] = cards[start++];//將切點後面的牌暫時放入temp數組中

}

for (int j = 0; j number; j++) {

temp[length – number + j] = cards[j];//將切點前面的牌加入temp數組中

}

for (int k = 0; k length; k++) {

cards[k] = temp[k];}

//輸出切牌後的撲克

……………………

……………………

}

//main方法

public static void main(String[] args) {

Poker newpoker = new Poker();

newpoker.Show();//調用Show()方法顯示一副新撲克

xipai();//調用xipai()方法顯示洗牌過後的撲克

qiepai(54);//調用qiepai()方法顯示切牌以後的撲克

}

}

參考資料：

java編寫撲克牌遊戲里，洗牌時發牌時用到了隨機分配的功能，請問在那個包中哪個類哪個方法？

import java.util.HashMap;

import java.util.Map;

import java.util.Random;

/**

* Author:danagao

* java 發牌程序,

* 不含大王,小王

* 可設定發牌人數

*/

public class Pai {

HashMapString, String map = new HashMapString, String();

private static final String[] colors = {“紅桃”, “方塊”, “梅花”, “黑桃”};

private static final String[] values = {“3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K”, “A”, “2”};

private String[] newpai; private int len;

//初始化52張牌

public Pai() {

len = colors.length * values.length;

newpai = new String[len];

int k = 0;

for (int i = 0; i colors.length; i++) {

for (int j = 0; j values.length; j++) {

newpai[k] = colors[i] + values[j];

k++;

}

}

}

//洗牌(把牌打亂)

private void getNums() {

Random r = new Random();

int i = r.nextInt(len);

String s;

if (i = 0 !map.containsKey(String.valueOf(i))) {

s = String.valueOf(i);

map.put(s, newpai[i]);

} else {

getNums();

}

}

//發牌

public void showResult(int p) {

for (int i = 0; i len; i++) {

getNums();

}

int l = len/p; //每人發幾張牌

int j=1;//計人數

int k=0;//計牌數

for (Map.EntryString, String entry : map.entrySet()) {

if(k%l==0 j=p){

System.out.println(“第”+j+”個人的牌:”);

j++;

} else if(len-k = len%p){

System.out.println(“剩餘的牌:”);

}

k++;

System.out.println(entry.getValue());

} }

public static void main(String[] args) {

DbColorBall dbColorBall = new DbColorBall();

dbColorBall.showResult(4);

}

}