Collecte l'interface racine dans la hiérarchie. La collection représente un ensemble d'objets, également appelés éléments de la collection. Certaines collections permettent des éléments en double, tandis que d'autres non. Certaines collections sont commandées, tandis que d'autres sont désordonnées. 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 passer des collections et exploiter ces collections où l'universalité maximale est requise.
Contenu principal: ici, nous utilisons la collection Collection pour simuler le jeu de poker joué par les Big Guys dans les films de Hong Kong.
1. Règles de jeu: Chacun des deux joueurs traite deux cartes entre leurs mains et les compare. Comparez les points maximaux de la carte de chaque joueur, la taille est A-2, celle avec les points les plus importants. Si les points sont les mêmes, la couleur du costume est comparée, la taille est noire (4), rouge (3), prune (2), carré (1) et la couleur du costume est le gagnant.
2. Étapes de mise en œuvre:
Créez un jeu de cartes à jouer A-2, avec quatre couleurs de noir (4), rouge (3), prune (2) et carré (1) totalisant 52 cartes;
Créez deux joueurs, y compris l'ID de joueur et le nom et les informations sur la carte sous licence;
Mercer les cartes et traiter deux cartes aux deux joueurs;
Comparez la taille de la carte dans la main du joueur pour obtenir le gagnant;
3. Implémentation du programme
Catégorie de cartes: contient les chiffres et les couleurs des cartes
Package CollectionTest.Games; Card de classe publique {ID entier privé; // Taille de la carte Type entier privé; // La couleur de la carte publique (ID entier, type entier) {this.id = id; this.type = type; } public Integer getID () {return id; } public void setid (INGER ID) {this.id = id; } public Integer getType () {return type; } public void setType (type entier) {this.type = type; } @Override public String toString () {return "carte [id =" + id + ", type =" + type + "]"; }} Classe de poker de poker: Comprend la carte de poker A-2
Package CollectionTest.Games; Public Class Poker {Private Card ID2; Carte privée ID3; carte privée ID4; Carte privée ID5; Carte privée ID6; Carte privée ID7; carte privée id8; Carte privée ID9; ID de carte privée10; Carte privée J; carte privée Q; Carte privée K; carte privée A; public poker () {} // quatre types: noir - 4, rouge - 3, plum - 2, carré - 1 poker public (type entier) {this.id2 = new card (2, type); this.id3 = new carte (3, type); this.id4 = new carte (4, type); this.id5 = nouvelle carte (5, type); this.id6 = new carte (6, type); this.id7 = new carte (7, type); this.id8 = new carte (8, type); this.id9 = new carte (9, type); this.id10 = nouvelle carte (10, type); this.j = new carte (11, type); this.q = nouvelle carte (12, type); this.k = nouvelle carte (13, type); this.a = nouvelle carte (14, type); } carte publique getID2 () {return id2; } public void setid2 (carte id2) {this.id2 = id2; } carte publique getID3 () {return id3; } public void setid3 (card id3) {this.id3 = id3; } carte publique getID4 () {return id4; } public void setid4 (carte id4) {this.id4 = id4; } carte publique getID5 () {return id5; } public void setid5 (carte id5) {this.id5 = id5; } carte publique getID6 () {return id6; } public void setid6 (card id6) {this.id6 = id6; } carte publique getID7 () {return id7; } public void setid7 (carte id7) {this.id7 = id7; } carte publique getID8 () {return id8; } public void setid8 (carte id8) {this.id8 = id8; } carte publique getID9 () {return id9; } public void setid9 (carte id9) {this.id9 = id9; } carte publique getID10 () {return id10; } public void setid10 (carte id10) {this.id10 = id10; } carte publique getj () {return j; } public void setj (carte j) {j = j; } carte publique getq () {return q; } public void setq (carte q) {q = q; } carte publique getK () {return k; } public void setk (carte k) {k = k; } Public Card geta () {return a; } public void seta (carte a) {a = a; }} Classe des joueurs: Contient l'ID et le nom du joueur, informations sur la carte
Package CollectionTest.Games; import java.util.arraylist; import java.util.list; public class Player {// ID de la chaîne Private String ID; // Nom du joueur Nom de la chaîne privée; // Licence du joueur détenu par la liste privée du joueur <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 () {Nom de retour; } public void setName (string name) {this.name = name; } public list <card> getPokerType () {return pokerType; } public void setPokerType (list <card> pokerType) {this.pokerType = pokerType; }} Catégorie principale du jeu de poker: y compris 1) Création de poker 2) Création des joueurs 3) rétractation 4) réduction 5) Comparez les gagnants et les pertes
Collection de packages.Games; import java.util.arraylist; import java.util.arrays; import java.util.collections; import java.util.list; import java.util.util.map; import java.util.scanner; import java.util.set; {// Créer des cartes à jouer ensemble public <poker> cpoker () {System.out.println ("************ Commencez à créer des cartes de poker **********"); // Créez un jeu de poker // quatre types: noir - 4, rouge - 3, prune - 2, carré - 1 set <fer> pokers = new hashset <> (); Poker [] poker = {new poker (1), nouveau poker (2), nouveau poker (3), nouveau poker (4)}; / * * Utilisation des classes d'outils de collections * Collection.Addall (Pokers, New Poker (1), New Poker (2), New Poker (3), New Poker (4)); * * * / pokers.addall (arrays.aslist (poker)); System.out.println ("******************** Création de cartes de poker avec succès ****************"); retour des pokers; } // Créer deux joueurs Public Map <String, Player> CPlayer () {System.out.println ("************ Commencez la création du joueur ****************"); Map <string, player> map = new HashMap <String, player> (); // Contrôlez le nombre de personnes entier = 0; System.out.println ("Créer deux joueurs, créer en fonction de l'invite"); Console de scanner = nouveau scanner (System.in); while (true) {System.out.println ("Veuillez saisir le" + (Control + 1) + "Player ID:"); String CourseId = Console.Next (); if (isNumeric (CourseId)) {System.out.println ("Veuillez saisir le nom du joueur" + (contrôle + 1) + ":"); String CourseName = Console.Next (); Player Players = nouveau joueur (CourseId, Coursename, NULL); // Enregistrer Data Map.put (CourseId, Players); System.out.println ("Add" + (Control + 1) + "Players" + Coursename + "Success"); // Ajouter un contrôle ++ par numéro; } else {System.out.println ("****** Veuillez saisir l'ID numérique *******"); continuer; } if (contrôle == 2) {break; }} System.out.println ("************ Player créé avec succès ****************"); carte de retour; } // Déterminez si l'entrée est un nombre, caractères.isdigit () est une méthode java publique booléen isnumeric (string str) {for (int i = 0; i <str.length (); i ++) {if (! Caractères.isdigit (str.charat (i))) {return false; }} return true; } / ** * shuffle: 52 nombres aléatoires différents peuvent également être générés pour réaliser Shuffle * ** / public list <card> wpoker (set <poker> pokers) {System.out.println ("********* start shuffle *********"); // Utilisez le type de liste ordonné et enregistrez la commande après le shuffle. List <card> listcard = new ArrayList <> (); // Utilisez le type de jeu de jeu sans commande pour réaliser SHUffle Set <card> listSet = new HashSet <> (); // Enregistrer sur l'ensemble set, non ordonné pour (poker pk: pokers) {listSet.add (pk.getId2 ()); listset.add (pk.getID3 ()); listset.add (pk.getID4 ()); listset.add (pk.getID5 ()); 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.getk ()); listset.add (pk.geta ()); } // Enregistrer dans la collection de listes, commandée pour (carte CD: listSet) {listCard.add (cd); System.out.println (CD); } System.out.println ("********************* RETRAPILLÉ AUX REMÉDIE **********"); return listcard; } // MADE PUBLIQUE DE TRAVAIL <String, joueur> pushpoker (liste <card> listcard, map <string, joueur> pmap) {System.out.println ("********************* Take Deal ****************"); // Contrôlez chaque personne pour traiter deux cartes int Control = 0; pour (map.entry <string, lecteur> entrée: pmap.entrySet ()) {if (contrôle == 0) {for (int i = 0; i <3; i = i + 2) {// Distribution entry.getValue (). getPokerType (). Add (listCard.get (i)); } // Mettez à jour l'objet Map Pmap.put (entry.getKey (), Entry.getValue ()); contrôle ++; } else if (contrôle == 1) {for (int i = 1; i <4; i = i + 2) {// Distribution entry.getValue (). getPokerType (). Add (listCard.get (i)); } // Mettez à jour l'objet Map Pmap.put (entry.getKey (), Entry.getValue ()); contrôle ++; } else {break; }} System.out.println ("****************** L'accord réussi ********"); retour PMAP; } public void Comparmatch (map <string, joueur> newmap) {/ * comparer les victoires et les pertes * 1. Obtenez d'abord l'ID et le costume ID de la plus grande carte entre les mains de chaque joueur. * 2. Comparez les tailles d'identification de la plus grande carte entre les mains de deux joueurs, et le plus grand gagne. * 3. Si les ID des deux cartes sont égaux, lors de la comparaison des ID de combinaison des deux cartes, l'ID de combinaison sera plus grande et la victoire sera obtenue. * * * / List <player> Players = new ArrayList <> (); // Obtenez deux joueurs pour (map.entry <string, joueur> entrée: newmap.entryset ()) {player.add (entry.getValue ()); } // Le joueur des informations et licences Liste <card> PlayerOne = Players.get (0) .getPokerType (); // Obtenez l'ID et la combinaison du plus grand entier de carte 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 (); // Player deux informations et licence Liste <card> playertwo = playert.get (1) .getPokerType (); // Obtenez l'ID et la combinaison du plus grand entier de carte 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 ("Player:" + Players.get (0) .getName () + "Win !!"); } else if (OneMaXId == TwoMaxid) {if (OneMaxType> TwoMaxType) {System.out.println ("Player:" + Players.get (0) .getName () + "Win !!"); } else {System.out .println ("Player:" + Players.get (1) .getName () + "Win!!"); }} else {System.out.println ("Player:" + Players.get (1) .getName () + "Win !!"); } System.out.println ("*****************************************************************"); System.out.println ("Player:" + Players.get (0) .getName () + "La carte de" est: "+ montradeName (PlayerOne.get (0) .getType (), 0) +" - "+ montage (PlayerOne.get (0) .getId (), 1) +" "+ Showe affiché (playerOne.get (1) .getId (), 1)); montradame (playertwo.get (1) .getType (), 0) + "-" + montage (playertwo.get (1) .getId (), 1)); } // Le nom de la carte d'affichage Private String affiché (entier I, type entier) {String str = ""; // affiche la combinaison if (type == 0) {switch (i) {cas 1: {str = "cube"; casser; } Cas 2: {str = "Plum Blossom"; casser; } cas 3: {str = "coeur"; casser; } Cas 4: {str = "str =" spads "; Break;} Default: {Break;}}} // Affichez le nombre if (type == 1) {if (i <11) {return i.toString ();} else {switch (i) {case 11: {str =" j ";} case 12: {str =" q "; basse;} case 13: {Str ="; Break; / / 3. Shuffle List <card> listcard = gb.wpoker (pokers); Résultats en cours:
******* commencer à créer des cartes de poker **********
************* Création de cartes de poker avec succès *************
******* commencer à créer des joueurs ***********
Pour créer deux joueurs, veuillez saisir l'ID du 1er joueur en fonction des invites:
Veuillez saisir le premier nom du joueur:
Stephen Chow a ajouté le premier joueur. Stephen Chow a réussi. Veuillez saisir le deuxième ID du joueur:
Veuillez saisir le deuxième nom du joueur:
Chow Yun-Fat a ajouté le deuxième joueur, Chow Yun-Fat avec succès
********** Création des joueurs avec succès *************
************ Commencer le shuffle **********
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]
*******.
************* L'accord de charge commence ************
************* Offre réussie ***********
Joueur: Stephen Chow a gagné! !
***************************************************
Joueur: La carte de Stephen Chow est: Red Peach-9 Red Peach-K
Joueur: La carte de Chow Yun-Fat est: Spades-J Red-8
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.