java纸牌
A. java题目 小明左右手分别拿两张纸牌 黑桃10和红心8， 现在交换手中的牌 用程序模拟这一过程
交换牌的话只需：1.设一个中间变量赋值为左手中的纸牌10 2.把右手中的纸牌8赋值给左手中的纸牌10 3.把中间变量中的10赋值给右手中的纸牌8 就可以了
int j=10；左手中的纸牌
int k=8；右手中的纸牌
开始交换：
int i=j；
j=k；
k=i；
B. java扑克牌排序用Collections.sort()方法怎么排
有两种方式
1,class Card implements Comparable<Card>
然后实现compareTo方法,
2,Collectons.sort(result, new Comparator<Card>(){
public int compare(Card c1, Card c2)
{
//return ...
}
})
C. 用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 方法。
最后，有任何疑问请追问。
D. java 怎么写compareto方法实现扑克牌排序
importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.TreeSet;
/*
*思路：
* A:创建一个HashMap集合
* B:创建一个ArrayList集合
* C:创建花色数组和点数数组
* D:从0开始往HashMap里面存储编号，并存储对应的牌
*同时往ArrayList里面存储编号即可。
*E:洗牌(洗的是编号)
*F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
*G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
*/
publicclassPokerDemo{
publicstaticvoidmain(String[]args){
//创建一个HashMap集合
HashMap<Integer,String>hm=newHashMap<Integer,String>();
//创建一个ArrayList集合
ArrayList<Integer>array=newArrayList<Integer>();
//创建花色数组和点数数组
//定义一个花色数组
String[]colors={"♠","♥","♣","♦"};
//定义一个点数数组
String[]numbers={"3","4","5","6","7","8","9","10","J","Q",
"K","A","2",};
//从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。
intindex=0;
for(Stringnumber:numbers){
for(Stringcolor:colors){
Stringpoker=color.concat(number);
hm.put(index,poker);
array.add(index);
index++;
}
}
hm.put(index,"小王");
array.add(index);
index++;
hm.put(index,"大王");
array.add(index);
//洗牌(洗的是编号)
Collections.shuffle(array);
//发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
TreeSet<Integer>fengQingYang=newTreeSet<Integer>();
TreeSet<Integer>linQingXia=newTreeSet<Integer>();
TreeSet<Integer>liuYi=newTreeSet<Integer>();
TreeSet<Integer>diPai=newTreeSet<Integer>();
for(intx=0;x<array.size();x++){
if(x>=array.size()-3){
diPai.add(array.get(x));
}elseif(x%3==0){
fengQingYang.add(array.get(x));
}elseif(x%3==1){
linQingXia.add(array.get(x));
}elseif(x%3==2){
liuYi.add(array.get(x));
}
}
//看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
lookPoker("风清扬",fengQingYang,hm);
lookPoker("林青霞",linQingXia,hm);
lookPoker("刘意",liuYi,hm);
lookPoker("底牌",diPai,hm);
}
//写看牌的功能
publicstaticvoidlookPoker(Stringname,TreeSet<Integer>ts,
HashMap<Integer,String>hm){
System.out.print(name+"的牌是：");
for(Integerkey:ts){
Stringvalue=hm.get(key);
System.out.print(value+"");
}
System.out.println();
}
}
E. 纸牌游戏 用java实现
public class Test {
public static void main(String args[]){
int puke[][] = new int[52][2];
for(int i = 0 ; i < 52; i++){
puke[i][0] = i+1;//牌面
puke[i][1] = 0;//0表示正面,1表示背面
}
for(int i = 2; i <= 52 ;i++){
for(int j = 0 ; j < 52; j++){
if(puke[j][0]%i==0){
puke[j][1]=Math.abs(puke[j][1]-1);//1为0,0为1;
}
}
}
for(int i = 0 ; i < 52; i++){
if(puke[i][1]==0)//为正面打印
System.out.println(puke[i][0]);
}
}
}
结果为：1，4，9，16，25，36，49
F. 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]);
} */
}
}
G. JAVA蜘蛛纸牌
我们做作业，做了个扑克牌的游戏，不过不是蜘蛛牌，没有添加出牌规则算法的。发给你，你自己看看。。纸牌要自己下，把名字改成0--51的数字，背面名字改成rear,横向背面改成rearheng.jpg
package com;
import java.awt.Color;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class puke implements MouseListener,ActionListener{
public JFrame frame=new JFrame("扑克牌发牌");
public JButton button=new JButton("Start");
public JPanel pbutton=new JPanel();
public JPanel north=new JPanel();
public JPanel west=new JPanel();
public JPanel south=new JPanel();
public JPanel east=new JPanel();
public JPanel middle=new JPanel();
public Container container=frame.getContentPane();
public static JLabel[] l=new JLabel[52];
public static JLabel[] ll =new JLabel[52];
@SuppressWarnings("unchecked")
public static Set set=new HashSet();
public static JLabel[] l1=new JLabel[13];
public static JLabel[] l2 =new JLabel[13];
public static JLabel[] l3 =new JLabel[13];
public static JLabel[] l4 =new JLabel[13];
public static JLabel[] ll1 =new JLabel[13];
public static JLabel[] ll2 =new JLabel[13];
public static JLabel[] ll3 =new JLabel[13];
public static JLabel[] ll4=new JLabel[13];
boolean gstar=false;
int nn=ll.length;
int n=l.length;
int s=0;
int x=0,y=0;
@SuppressWarnings("unchecked")
public puke(){
frame.setBounds(0, 0, 1000, 750);
container.setLayout(null);
north.setLayout(null);
west.setLayout(null);
south.setLayout(null);
east.setLayout(null);
north.setBounds(200, 0, 600, 200);
north.setBackground(Color.GREEN);
west.setBounds(0,200,200,350);
west.setBackground(Color.RED);
south.setBounds(200,550,600,200);
south.setBackground(Color.PINK);
east.setBounds(800, 200, 200, 350);
east.setBackground(Color.BLUE);
pbutton.setBounds(420, 420,100, 40);
middle.setBounds(200, 200, 600, 400);
middle.setBackground(Color.YELLOW);
for(int i=0;i<l.length;i++){
l[i]=new JLabel(new ImageIcon("src/com/rear.jpg"));
l[i].setBounds(350+x,270,71,96);
container.add(l[i]);
x+=5;
}
for(int i=0;i<ll.length;i++){
ll[i]=new JLabel(new ImageIcon("src/com/"+i+".jpg"));
set.add(ll[i]);
}
button.addActionListener(this);
pbutton.add(button);
container.add(north);
container.add(west);
container.add(south);
container.add(east);
container.add(pbutton);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
compare();
}
@SuppressWarnings({ "unchecked", "unchecked" })
public void play()//分发正面52张牌
{
Iterator<JLabel> it = set.iterator();
while(it.hasNext()){
for(int i=0;i<13;i++){
if(nn%4==0){
ll1[i]=(JLabel) it.next();
nn--;}
if(nn%4==3){
ll2[i]=(JLabel) it.next();
nn--;}
if(nn%4==2){
ll3[i]=(JLabel) it.next();
nn--;}
if(nn%4==1){
ll4[i]=(JLabel) it.next();
nn--;}
}
}
}
public void move()//完成发牌，每位玩家得到13张牌
{
play();
int i;
while(n!=0){
for(i=0;i<13;i++){
if(s<52){
if(n%4==0){
l1[i]=l[s];
l1[i].setBounds(-120+x, 70, 71, 96);
north.add(l1[i]);
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
x+=10;
s++;
n--;
continue;
}
if(n%4==3){
l[s].setIcon(new ImageIcon("src/com/rearheng.jpg"));
l2[i]=l[s];
l2[i].setBounds(70, 20+y,96,71);
west.add(l2[i]);
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
y+=10;
s++;
n--;
continue;
}
if(n%4==2){
l[s].setIcon(null);
l3[i]=ll3[i];
l3[i].setBounds(640-x, 30, 71, 96);
l3[i].addMouseListener(this);
south.add(l3[i]);
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
x+=10;
s++;
n--;
continue;
}
if(n%4==1){
l[s].setIcon(new ImageIcon("src/com/rearheng.jpg"));
l4[i]=l[s];
l4[i].setBounds(30,260-y,96,71);
east.add(l4[i]);
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
y+=10;
s++;
n--;
continue;
}
}
}
}
button.setVisible(false);
pbutton.remove(button);
container.remove(pbutton);
container.add(middle);
frame.repaint();
}
public void mouseClicked(MouseEvent e)//点击鼠标出牌
{
for(int i=0;i<13;i++){
if(gstar){
middle.remove(l3[i]);
middle.remove(ll1[i]);
middle.remove(ll2[i]);
middle.remove(ll4[i]);
if(e.getSource()==l3[i]){
north.remove(l1[i]);
west.remove(l2[i]);
east.remove(l4[i]);
south.remove(l3[i]);
middle.add(l3[i]);
middle.add(ll1[i]);
middle.add(ll2[i]);
middle.add(ll4[i]);
l3[i].setBounds(l3[i].getBounds().x, 200, 71, 100);
ll1[i].setBounds(250, 50, 71, 96);
ll2[i].setBounds(150, 150, 71, 96);
ll3[i].setBounds(250, 200, 71, 96);
ll4[i].setBounds(350, 150, 71, 96);
frame.repaint();
}
}
}
}
public void mouseEntered(MouseEvent e) //选择要出的牌
{
for(int i=0;i<13;i++){
if(gstar){
if(e.getSource()==l3[i]){
l3[i].setBounds(l3[i].getBounds().x, l3[i].getBounds().y-20, 71, 96);
}
}
}
}
public void mouseExited(MouseEvent e) {
for(int i=0;i<13;i++){
if(gstar){
if(e.getSource()==l3[i]){
l3[i].setBounds(l3[i].getBounds().x,l3[i].getBounds().y+20, 71, 96);
}}}
}
public puke getthis(){
return this;
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public static void main(String[]args){
new puke();
}
public class TestThread extends Thread{
private puke g=null;
public TestThread(puke g){
this.g=g;
}
public void run() {
while(true){
g.move();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void actionPerformed(ActionEvent e) //点击按钮事件
{
if(e.getSource()==button){
gstar=true;
TestThread t= new TestThread(this);
t.start();
}
}
@SuppressWarnings("unchecked")
public int compare(){
JLabel[] lab=new JLabel[ll.length];
String[] str=new String[ll.length];
set.toArray(lab);
for(int l=0;l<ll.length;l++){
str[l]=lab[l].getIcon().toString();
System.out.println(str[l]);
}
return n;
}
}
H. 求助：用java实现的纸牌游戏
用一个list放这52个元素，每个人随机一个数作为list下标发牌，发掉的牌就从list中remove掉
小写了个来耍：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
for (int i = 1; i <= 13; i++) {//生成牌堆
list.add("红心" + i);
list.add("黑桃" + i);
list.add("梅花" + i);
list.add("方块" + i);
}
ArrayList<String> lista = new ArrayList<String>();//生成牌友
ArrayList<String> listb = new ArrayList<String>();
ArrayList<String> listc = new ArrayList<String>();
ArrayList<String> listd = new ArrayList<String>();
while (list.size() > 1) {
lista.add(find(list));
listb.add(find(list));
listc.add(find(list));
listd.add(find(list));
}
System.out.println("甲:" + lista.toString());
System.out.println("乙:" + listb.toString());
System.out.println("丙:" + listc.toString());
System.out.println("丁:" + listd.toString());
}
public static String find(ArrayList<String> list) {
Random random = new Random();
int m = list.size() - 1;//随机数范围为0到剩余牌数量-1
if (m == 0)//对最后一张牌处理
return list.get(0);
int index = Math.abs(random.nextInt()) % m;
String str = list.get(index);
list.remove(index);
return str;
}