Maison > Java > javaDidacticiel > le corps du texte

Exemple de jeu de poker de la collection JAVA

高洛峰
Libérer: 2017-01-23 16:54:07
original
1623 Les gens l'ont consulté

L'interface racine dans la hiérarchie Collection. La collection représente un ensemble d'objets, également appelés éléments de la collection. Certaines collections autorisent les éléments en double, d'autres non. Certaines collections sont ordonnées, tandis que d'autres ne le sont pas. Le JDK ne fournit aucune implémentation directe de cette interface : il fournit des implémentations de sous-interfaces plus spécifiques telles que Set et List. Cette interface est généralement utilisée pour transmettre des collections et les exploiter partout où une généralité maximale est requise.

Contenu principal : Collection est utilisée ici pour simuler le jeu de poker joué par les grands dans les films de Hong Kong.

1. Règles du jeu : Deux joueurs reçoivent chacun deux cartes et sont comparés. Comparez le plus grand nombre de cartes dans la main de chaque joueur, la taille est A-2, le joueur avec le plus grand nombre de points gagne. Si les points sont les mêmes, les couleurs seront comparées et les couleurs seront noire (4), rouge (3), prune (2), carrée (1), et celle avec la plus grande couleur gagne.

2. Étapes de mise en œuvre :

Créez un jeu de cartes à jouer A-2, avec quatre couleurs noir (4), rouge (3), prune (2), carré (1) , un total de 52 cartes à jouer ;
Créez deux joueurs, y compris les identifiants des joueurs, les noms et les informations sur les cartes ;
Mélangez les cartes et distribuez deux cartes à chacun des deux joueurs
Comparez la taille des cartes ; entre les mains des joueurs pour déterminer le gagnant ;

3. Mise en œuvre du programme

Classe de carte : contient le numéro et la couleur de la carte

package collectiontest.games;
public class Card {
  private Integer id; //牌的大小
  private Integer type;//牌的花色
   
  public Card(Integer id, Integer type) {
    this.id = id;
    this.type = type;
  }
  public Integer getId() {
    return id;
  }
  public void setId(Integer id) {
    this.id = id;
  }
  public Integer getType() {
    return type;
  }
  public void setType(Integer type) {
    this.type = type;
  }
  @Override
  public String toString() {
    return "Card [id=" + id + ", type=" + type + "]";
  }  
}
Copier après la connexion

Poker classe : Contient la carte à jouer Carte A- 2

package collectiontest.games;
public class Poker {
  private Card id2 ;
  private Card id3 ;
  private Card id4 ;
  private Card id5 ;
  private Card id6 ;
  private Card id7 ;
  private Card id8 ;
  private Card id9 ;
  private Card id10 ;
  private Card J ;
  private Card Q ;
  private Card K ;
  private Card A ;
   
  public Poker() {
  }    
  //四个类型:黑--4、红--3、梅--2、方--1
  public Poker(Integer type) {
    this.id2 = new Card(2, type);
    this.id3 = new Card(3, type);
    this.id4 = new Card(4, type);
    this.id5 = new Card(5, type);
    this.id6 = new Card(6, type);
    this.id7 = new Card(7, type);
    this.id8 = new Card(8, type);
    this.id9 = new Card(9, type);
    this.id10 = new Card(10, type);
    this.J = new Card(11, type);
    this.Q = new Card(12, type);
    this.K = new Card(13, type);
    this.A = new Card(14, type);
  }
  public Card getId2() {
    return id2;
  }
  public void setId2(Card id2) {
    this.id2 = id2;
  }
  public Card getId3() {
    return id3;
  }
  public void setId3(Card id3) {
    this.id3 = id3;
  }
  public Card getId4() {
    return id4;
  }
  public void setId4(Card id4) {
    this.id4 = id4;
  }
  public Card getId5() {
    return id5;
  }
  public void setId5(Card id5) {
    this.id5 = id5;
  }
  public Card getId6() {
    return id6;
  }
  public void setId6(Card id6) {
    this.id6 = id6;
  }
  public Card getId7() {
    return id7;
  }
  public void setId7(Card id7) {
    this.id7 = id7;
  }
  public Card getId8() {
    return id8;
  }
  public void setId8(Card id8) {
    this.id8 = id8;
  }
 
  public Card getId9() {
    return id9;
  }
  public void setId9(Card id9) {
    this.id9 = id9;
  }
  public Card getId10() {
    return id10;
  }
  public void setId10(Card id10) {
    this.id10 = id10;
  }
  public Card getJ() {
    return J;
  }
  public void setJ(Card j) {
    J = j;
  }
  public Card getQ() {
    return Q;
  }
  public void setQ(Card q) {
    Q = q;
  }
  public Card getK() {
    return K;
  }
  public void setK(Card k) {
    K = k;
  }
  public Card getA() {
    return A;
  }
  public void setA(Card a) {
    A = a;
  }
}
Copier après la connexion

Joueur Classe de joueur : Contient l'identifiant et le nom du joueur, les informations sur la carte détenue

package collectiontest.games;
import java.util.ArrayList;
import java.util.List;
 
public class Player {
  //玩家的ID
  private String id ;
  //玩家姓名
  private String name ;
  //玩家所持牌
  private List<Card> pokerType ;
   
  public Player() {  
  }
  public Player(String id, String name, List<Card> pokerType) {
    this.id = id;
    this.name = name;
    this.pokerType = new ArrayList<>();
  }
 
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public List<Card> getPokerType() {
    return pokerType;
  }
  public void setPokerType(List<Card> pokerType) {
    this.pokerType = pokerType;
  }  
}
Copier après la connexion

Classe principale du jeu de poker : Contient 1) Création de poker 2) Création de joueur 3) Mélangez les cartes 4) Distribuez les cartes 5) Comparez le résultat

package collectiontest.games;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
 
public class GamsBegin {
 
  // 创建扑克牌
  public Set<Poker> cPoker() {
     
    System.out.println("**********开始创建扑克牌**********");
    // 创建一副poker
    // 四个类型:黑--4、红--3、梅--2、方--1
    Set<Poker> pokers = new HashSet<>();
    Poker[] poker = { new Poker(1), new Poker(2), new Poker(3),
        new Poker(4) };
    /*
     * Collections工具类的使用
     * Collections.addAll(pokers, new Poker(1), new Poker(2), new Poker(3),new Poker(4));
     *
     * */
    pokers.addAll(Arrays.asList(poker));
 
    System.out.println("**********扑克牌创建成功**********");
 
    return pokers;
  }
 
  // 创建两个玩家
  public Map<String, Player> cPlayer() {
     
    System.out.println("**********开始创建玩家**********");
    Map<String, Player> map = new HashMap<String, Player>();
    // 控制数量
    Integer control = 0;
 
    System.out.println("创建两名玩家,根据提示创建");
    Scanner console = new Scanner(System.in);
    while (true) {
      System.out.println("请输入第 "+(control+1)+" 个玩家ID:");
      String courseId = console.next();
 
      if (isNumeric(courseId)) {
        System.out.println("请输入第 "+(control+1)+" 个玩家姓名:");
        String courseName = console.next();
 
        Player players = new Player(courseId, courseName, null);
        //保存数据
        map.put(courseId, players);
 
        System.out.println("添加第 " + (control + 1) + " 个玩家 " + courseName
            + " 成功");
        //数量自加
        control++;
      } else {
        System.out.println("*****请输入数字ID*****");
        continue;
      }
 
      if (control == 2) {
        break;
      }
 
    }
 
    System.out.println("**********玩家创建成功**********");
 
    return map;
  }
 
  // 判断输入是否为数字, Character.isDigit()为java方法
  public boolean isNumeric(String str) {
    for (int i = 0; i < str.length(); i++) {
      if (!Character.isDigit(str.charAt(i))) {
        return false;
      }
    }
    return true;
  }
 
  /**
   * 洗牌 :也可以产生52个不同随机数,实现洗牌
   *
   **/
  public List<Card> wPoker(Set<Poker> pokers) {
    System.out.println("**********开始洗牌**********");
    //利用List的有序排序,洗牌之后保存顺序不变
    List<Card> listCard = new ArrayList<>();
    // 利用Set集合的无序排序,实现洗牌
    Set<Card> listSet = new HashSet<>();
 
    //保存到Set集合,无序
    for (Poker pk : pokers) {
      listSet.add(pk.getId2());
      listSet.add(pk.getId3());
      listSet.add(pk.getId4());
      listSet.add(pk.getId5());
      listSet.add(pk.getId6());
      listSet.add(pk.getId7());
      listSet.add(pk.getId8());
      listSet.add(pk.getId9());
      listSet.add(pk.getId10());
      listSet.add(pk.getJ());
      listSet.add(pk.getQ());
      listSet.add(pk.getK());
      listSet.add(pk.getA());
    }
 
    //保存在List集合,有序
    for (Card cd : listSet) {
      listCard.add(cd);
      System.out.println(cd);
    }
     
    System.out.println("**********洗牌成功**********");
 
    return listCard;
  }
 
  // 发牌
  public Map<String, Player> pushPoker(List<Card> listCard,
      Map<String, Player> pMap) {
    System.out.println("**********发牌开始**********");
     
    // 控制每人发两张牌后结束
    int control = 0;
 
    for (Map.Entry<String, Player> entry : pMap.entrySet()) {
 
      if (control == 0) {
        for (int i = 0; i < 3; i = i + 2) {
          // 发牌
          entry.getValue().getPokerType().add(listCard.get(i));
        }
        // 更新map对象
        pMap.put(entry.getKey(), entry.getValue());
        control++;
      } else if (control == 1) {
        for (int i = 1; i < 4; i = i + 2) {
          // 发牌
          entry.getValue().getPokerType().add(listCard.get(i));
        }
        // 更新map对象
        pMap.put(entry.getKey(), entry.getValue());
        control++;
      } else {
        break;
      }
    }
 
    System.out.println("**********发牌成功**********");
 
    return pMap;
  }
 
 
  public void compareMatch(Map<String, Player> newMap) {
   
    /*比较胜负
     * 1.首先取得每个玩家手中最大牌的ID和花色ID。
     * 2.比较俩玩家手中最大牌的ID大小,牌大者获胜。
     * 3.如果两张牌的ID相等,在比较两张牌的花色ID,花色ID更大着获胜。
     * 
     * */
     
    List<Player> players = new ArrayList<>();
 
    // 获得两个玩家
    for (Map.Entry<String, Player> entry : newMap.entrySet()) {
      players.add(entry.getValue());
    }
 
    // 玩家一信息和所持牌
    List<Card> playerOne = players.get(0).getPokerType();
    //获得最大牌的ID和花色
    Integer oneMaxId = Math.max(playerOne.get(0).getId(), playerOne.get(1)
        .getId());
    Integer oneMaxType = (oneMaxId!=playerOne.get(0).getId()) ? playerOne.get(1).getType() : playerOne.get(0).getType() ;
 
    // 玩家二信息和所持牌
    List<Card> playerTwo = players.get(1).getPokerType();
    //获得最大牌的ID和花色
    Integer twoMaxId = Math.max(playerTwo.get(0).getId(), playerTwo.get(1)
        .getId());
    Integer twoMaxType = (twoMaxId!=playerTwo.get(0).getId()) ? playerTwo.get(1).getType() : playerTwo.get(0).getType() ;
 
    if (oneMaxId > twoMaxId) {
      System.out.println("玩家 : " + players.get(0).getName() + " 获胜!!");
    } else if (oneMaxId == twoMaxId) {
 
      if (oneMaxType > twoMaxType) {
        System.out
            .println("玩家 : " + players.get(0).getName() + " 获胜!!");
 
      } else {
        System.out
            .println("玩家 : " + players.get(1).getName() + " 获胜!!");
      }
 
    } else {
      System.out.println("玩家 : " + players.get(1).getName() + " 获胜!!");
    }
 
    System.out.println("**********************************************");
    System.out.println("玩家 : " + players.get(0).getName() + "的牌是:"
        + showName(playerOne.get(0).getType(), 0) + "--"
        + showName(playerOne.get(0).getId(), 1) + "  "
        + showName(playerOne.get(1).getType(), 0) + "--"
        + showName(playerOne.get(1).getId(), 1));
    System.out.println("玩家 : " + players.get(1).getName() + "的牌是:"
        + showName(playerTwo.get(0).getType(), 0) + "--"
        + showName(playerTwo.get(0).getId(), 1) + "  "
        + showName(playerTwo.get(1).getType(), 0) + "--"
        + showName(playerTwo.get(1).getId(), 1));
  }
 
  // 显示牌的名称
  private String showName(Integer i, Integer type) {
    String str = "";
 
    // 显示花色
    if (type == 0) {
      switch (i) {
      case 1: {
        str = "方块";
        break;
      }
      case 2: {
        str = "梅花";
        break;
      }
      case 3: {
        str = "红桃";
        break;
      }
      case 4: {
        str = "黑桃";
        break;
      }
 
      default: {
        break;
      }
      }
 
    }
 
    // 显示数字
    if (type == 1) {
      if (i < 11) {
        return i.toString();
      } else {
        switch (i) {
        case 11: {
          str = "J";
          break;
        }
        case 12: {
          str = "Q";
          break;
        }
        case 13: {
          str = "K";
          break;
        }
        case 14: {
          str = "A";
          break;
        }
 
        default: {
          break;
        }
        }
      }
    }
 
    return str;
  }
 
  public static void main(String[] args) {
    GamsBegin gb = new GamsBegin();
     
    // 1、创建扑克牌
    Set<Poker> pokers = gb.cPoker();
 
    // 2、创建两个玩家
    Map<String, Player> pMap = gb.cPlayer();
 
    // 3、洗牌
    List<Card> listCard = gb.wPoker(pokers);
 
    // 4、发牌
    Map<String, Player> newMap = gb.pushPoker(listCard, pMap);
 
    // 4、比较胜负
    gb.compareMatch(newMap);
 
  }
}
Copier après la connexion

Résultats en cours :

********** **Commencez à créer des cartes à jouer****** ******
************Cartes de poker créées avec succès************
************Commencez à créer des joueurs* *********
Créez deux joueurs et suivez les instructions
Veuillez saisir l'identifiant du premier joueur :
Veuillez saisir le nom du 1er joueur :
Stephen Chow
Ajouter Le 1er joueur Stephen Chow a réussi
Veuillez saisir l'ID du 2ème joueur :
Veuillez saisir le nom du 2ème joueur :
Chow Yun-fat
Ajoutez le 2ème joueur Chow Yun-fat avec succès
***** *****Joueur créé avec succès************
********* *Commencez à mélanger les cartes **********
Carte [id =9, type=3]
Carte [id=11, type=4]
Carte [id=13, type=3]
Carte [id=8, type=3]
Carte [id=5, type=2]
Carte [id=6, type=1]
Carte [id= 4, type=3]
Carte [id=5, type=4]
Carte [id=2, type=3]
Carte [id=9, type=2]
Carte [ id=9, type=4]
Carte [id=14, type=2]
Carte [id=9, type=1]
Carte [id=2, type=1]
Carte [id=2, type=4]
Carte [id=7, type= 4]
Carte [id=11, type=1]
Carte [id=10, type=1]
Carte [id=14, type=4]
Carte [id=14, type=3]
Carte [id=12, type=2]
Carte [id=2, type=2 ]
Carte [id=10, type=2]
Carte [id= 7, type=1]
Carte [id=7, type=3]
Carte [id=8, type =2]
Carte [id=4, type=4]
Carte [ id=13, type=4]
Carte [id=14, type=1]
Carte [id=12 , type=1]
Carte [id=5, type=1]
Carte [id=6, type=4]
Carte [id=12, type=4]
Carte [id =11, type=2]
Carte [id=10, type=3]
Carte [id=3, type=4]
Carte [id=12, type=3]
Carte [id=4, type=2]
Carte [id=4, type=1 ]
Carte [id=6, type=2]
Carte [id=5, type=3]
Carte [id=8, type=4]
Carte [id=3, type =2]
Carte [id=13, type=2]
Carte [id=7, type=2]
Carte [id=3, type=3]
Carte [id=3, type=1]
Carte [id=6, type=3]
Carte [id=8, type= 1]
Carte [id=11, type=3]
Carte [id =13, type=1]
Carte [id=10, type=4]
****** ******Mélangez avec succès*********
* *********La distribution des cartes a commencé************
************La distribution des cartes a réussi************
Joueur : Stephen Chow gagne ! !
************************************************
Joueur : La carte de Stephen Chow est : Hearts-9 Hearts-K
Joueur : Chow Yun-fat les cartes sont : Spades-J Hearts-8

Ce qui précède est le contenu complet de l'article, je l'espère sera utile à l'apprentissage de chacun, et j'espère également que tout le monde soutiendra le site Web PHP en chinois.

Pour plus d'articles liés aux exemples de jeux de poker de la collection JAVA, veuillez faire attention au site Web PHP chinois !

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal