java扑克牌源码（java斗地主发牌代码）

发布时间：2022-11-09

本文目录一览：

  1. 用Java写一个扑克牌类，扑克牌有花色和大小，并且有一个tostring方法，返回扑克牌的信息？
  2. java写一个扑克牌程序
  3. Java扑克牌问题
  4. java 中如何实现一副扑克牌洗牌的功能。如果无法书写完整的代码，可以用文字描述出自己的实现思路

用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)”。
  3. 任何对象都可调用自身的 toString 方法，数组是对象。
  4. 数组是对象，一样有对应的类型，其类型一样继承自 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扑克牌问题

使用 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 中如何实现一副扑克牌洗牌的功能。如果无法书写完整的代码，可以用文字描述出自己的实现思路

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 final 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.number = 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);
        src.remove(index);
    }
    return result;
}
推荐文章