扑克牌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();
}
}