撲克牌java
importjava.util.*;
publicclassMain{
publicstaticvoidmain(String[]args){
Scannerscanner=newScanner(System.in);
List<String>list=newArrayList<String>();
while(scanner.hasNextLine()){
Stringstring=scanner.nextLine();
list.add(string);
if(list.size()==5){
intr=getCard(list);
System.out.println(r);
list.clear();
}
}
}
privatestaticintgetCard(List<String>list){
inttemp=7;
intsize=list.size();
List<String>numList=newArrayList<String>();
Set<String>numSet=newTreeSet<String>();
List<String>colourList=newArrayList<String>();
Set<String>colourSet=newTreeSet<String>();
for(inti=0;i<list.size();i++){
Stringnum=list.get(i).split("")[0];
Stringcolour=list.get(i).split("")[1];
if(num.equals("J")){
numList.add("11");
numSet.add("11");
}elseif(num.equals("Q")){
numList.add("12");
numSet.add("12");
}elseif(num.equals("K")){
numList.add("13");
numSet.add("13");
}elseif(num.equals("A")){
numList.add("14");
numSet.add("14");
}else{
numList.add(num);
numSet.add(num);
}
colourList.add(colour);
colourSet.add(colour);
}
//同花順,或者同花
if(colourSet.size()==1){
Collections.sort(numList);
for(inti=0;i<numList.size()-1;i++){
if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
if(i==numList.size()-2){
temp=1;
}
continue;
}else{
if(temp>4){
temp=4;
}
}
}
}
//四條或者葫蘆
if(numSet.size()==2){
Collections.sort(numList);
//四條
if(!numList.get(0).equals(numList.get(1))||!numList.get(size-1).equals(numList.get(size-2))){
if(temp>2){
temp=2;
}
}else{
if(temp>3){
temp=3;
}
}
}
//三條
if(numSet.size()==3){
if(temp>6){
temp=6;
}
}
//順子
if(colourSet.size()>1){
Collections.sort(numList);
for(inti=0;i<numList.size()-1;i++){
if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
if(i==numList.size()-2){
if(temp>5){
temp=5;
}
}
}else{
break;
}
}
}
returntemp;
}
}
⑵ 用Java寫一個撲克牌類，撲克牌有花色和大小，並且有一個tostring方法，返回撲克牌的信息
Card[] cards = new Card[54]; // 這是一個數組，是一個普通對象。
Player[] players = new Player[3]; // 這是一個數組，是一個普通對象。
第一行，調用了數組 cards 上索引為 0 的元素的 toString 方法，對應於 Card 類的 toString 方法。
第二行，調用了數組 cards 的 toString 方法，對應於 Card[] 類的 toString 方法，繼承自 Object 類。
第三行，調用了 Arrays 類的 toString 方法，傳入參數是數組 cards ，具體可查找該方法的源碼。
第四行，調用了數組 players 上索引為 0 的元素的 toString 方法，對應於 Player 類的 toString 方法。
第五行，調用了數組 players 的 toString 方法，對應於 Player[] 類的 toString 方法，繼承自 Object 類。
第六行，調用了 Arrays 類的 toString 方法，傳入參數是數組 players ，具體可查找該方法的源碼。
簡單說一下 Arrays.toString() ，它返回是由數組內所有元素的字元串化（toString）合並而成的字元串對象。
因此：
1. 不是同一個 toString 方法，任何對象都可調用自身的 toString 方法。
2. 因為 Player 類的 toString 方法內曾調用了「 Arrays.toString(cards) 」。
4. 任何對象都可調用自身的 toString 方法，數組是對象。
5. 數組是對象，一樣有對應的類型，其類型一樣繼承自 Object 類，繼承了 toString 方法。
最後，有任何疑問請追問。
⑶ 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]);
} */
}
}
⑷ 用java ArrayList集合編寫撲克牌洗牌與發牌
import java.util.ArrayList;
import java.util.Random;
public class PokerDemo {
ArrayList<Card> poker = new ArrayList<Card>();
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();
ArrayList<Card> tmp = new ArrayList<Card>();
while(!poker.isEmpty()) {
int index = r.nextInt(poker.size());
Card card = poker.get(index);
tmp.add(card);
poker.remove(index);
}
poker = new ArrayList<Card>(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 {
ArrayList<Card> cards = new ArrayList<Card>();
String name;
public Player(String n) {
name = n;
}
public void add(Card card) {
cards.add(card);
}
public String toString() {
return name + ":\t" + cards;
}
}
⑸ 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"";
}
}
測試運行結果：
⑹ java編寫撲克牌游戲里，洗牌時發牌時用到了隨機分配的功能，請問在那個包中哪個類哪個方法
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
/**
* Author:danagao
* java 發牌程序,
* 不含大王,小王
* 可設定發牌人數
*/
public class Pai {
HashMap<String, String> map = new HashMap<String, 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.Entry<String, 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);
}
}
⑺ java 中如何實現一副撲克牌洗牌的功能。如果無法書寫完整的代碼，可以用文字描述出自己的實現思路
1.定義牌類
public class Card{
public int id;//牌大小
public String number;//頃姿牌值名稱雀中絕
public String color;//花色
}
2.定義牌組,用ArrayList存放所有牌
ArrayList<Card> cardGroup =new ArrayList<Card>();
3.定義花色枚舉
public static final String[] COLORS=new String[]{"方塊"培胡,"梅花","紅桃","黑桃"};
4.定義牌值大小枚舉
public static fina String[] CARDVALUES=new String[]{"A","1","2","3",
"4","5","6","7","8","9","10","J","Q","K","King_Small","King_Big"};
5.初始化牌組,這就是一副新牌，沒切過，己經排好序的
public void initCardGroup(){
//加入A~K
for(int i=0;i<13;i++){
for (int j=0;j<4;j++){
//生成一張牌的對象
Card card=new Card();
card.id=i;
card.color=COLORS[j];
card.munber=CARDVALUES[i];
//將對象加入牌組
cardGroup.add(card);
}
}
//加入大小王
Card card_k1=new Card();
card_k1.id=13;
card_k1.color="King_Small";
card_k1.number="King_Small";
cardGroup.add(card_k1);
Card card_k2=new Card();
card_k2.id=14;
card_k2.color="King_big";
card_k2.number="King_big";
cardGroup.add(card_k2);
}
6. 洗牌，將原牌組打亂，得到新的牌組
public ArrayList<Card> flushCardsGroup(ArrayList<Card> src){
ArrayList<Card> result=new ArrayList<Card>();
while(src.size>0){
int size=src.size();
//以size為限，生成0~size之間的隨機數
Random r=new Random();
int index=r.nextInt(size);
//對index做個檢查
if(index>0){index=0;}
if(index>size-1){index=size-1;}
//index就是撿出來的牌，加到新的數組中，從原來數組中刪除
Card card=src.get(index);
result.add(card);
card.remove(index);
}
return result;
}
⑻ 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 結果； }}。調用方法就能比較
⑼ java怎樣從54張撲克牌中隨機產生五張 不重復的
例如：有數組a = [1,2,3,4,5,6,7,8,9,10]，使用首先產生一個0~10(不包含10)的隨機數，用來做數組下標。
Random r = new Random();
int rand = r.nextInt(10);//0~10之間的隨機數，但不包含10。
假如rand=3。我們把a[3]放到之前創建好的數組里，你蠢信要取5張牌，這個數組就5個長。
然後把a[3]與a[9]的位置交換，交換之後的數組為a=[1,2,3,10,5,6,7,8,9,4]
再次獲取隨機數，但這里獲取的數檔察是0~9之間的隨機數。
int rand = r.nextInt(9);
rand的值不可能是9，那麼下標為9的元素就不可能出現，也就不會重復。
假如這次rand=6，再把a[6]放到之前創建好的數組里。
再把a[6]與a[8]交換，交換之後的數組為a=[1,2,3,10,5,6,9,8,7,4]
再獲取隨機數時int rand = r.nextInt(8)，那麼rand就不可能是8或9。以此類推。
===========
import java.util.Arrays;
import java.util.Random;
public class Test {
public static void main(String[] args) {
int[] puKe = new int[54];
for(int i = 0; i < puKe.length; i++) {
puKe[i] = i + 1;
}
int[] pai = faPai(puKe, 5);
Arrays.sort(pai);
System.out.println(Arrays.toString(pai));
}
public static int[] faPai(int[] puKe, int num) {
int[] pai = new int[num];//用來裝載取出的牌，5個長。
int m = 0;//一共取5張，m表示當前取到第幾張
int n = puKe.length;//隨機數的范圍，默認是0~n之間取隨機數
Random r = new Random();
for(int i = 0; i < num; i++, n--) {
int rand = r.nextInt(n);//rand為0~n之間的隨機數
pai[m++] = puKe[rand];//用隨機數做下標，把牌放到pai數組中，然後m++
// rand位置上的牌與n-1位置上的牌交換，因為n再自減，所以n-1也在自減。
int temp = puKe[n - 1];
puKe[n - 1] = puKe[rand];
puKe[rand] = temp;
}
return pai;
}
}
=============
如果你有撲克牌圖片，那薯茄么就可以把獲取到的int[]中的元素做為圖片數組的下標了。
⑽ 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();
}
}