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;
}