Sammeln Sie die Root -Schnittstelle in der Hierarchie. Die Sammlung repräsentiert eine Reihe von Objekten, auch als Elemente der Sammlung bezeichnet. Einige Sammlungen erlauben doppelte Elemente, andere nicht. Einige Sammlungen werden bestellt, während andere ungeordnet sind. Das JDK bietet keine direkte Implementierung dieser Schnittstelle: Es bietet spezifischere Implementierungen von Subinterfaces (z. B. Set und List). Diese Schnittstelle wird normalerweise verwendet, um Sammlungen zu bestehen und diese Sammlungen zu bedienen, an denen die maximale Universalität erforderlich ist.
Hauptinhalt: Hier verwenden wir die Sammlungskollektion, um das Pokerspiel der großen Jungs in Filmen in Hongkong zu simulieren.
1. Spielregeln: Jeder der beiden Spieler befasst sich mit zwei Karten in die Hände und vergleicht sie. Vergleichen Sie die maximalen Punkte der Karte jedes Spielers, die Größe ist A-2, die mit den größten Punkten gewinnt. Wenn die Punkte gleich sind, wird die Farbe des Anzugs verglichen, die Größe ist schwarz (4), rot (3), Pflaume (2), Quadrat (1) und die Farbe des Anzugs ist der Gewinner.
2. Implementierungsschritte:
Erstellen Sie ein Kartenspiel A-2 mit vier Farben Schwarz (4), Rot (3), Pflaume (2) und Quadrat (1) mit insgesamt 52 Karten;
Erstellen Sie zwei Spieler, darunter Spieler -ID und Name und lizenzierte Karteninformationen.
Mischen Sie die Karten und geben Sie zwei Karten an beide Spieler.
Vergleichen Sie die Größe der Karte in der Hand des Spielers, um den Gewinner zu erhalten.
3. Programmimplementierung
Kartenkategorie: Enthält die Zahlen und Farben der Karten
Package CollectionTest.games; öffentliche Klassenkarte {private Integer id; // Größe der Karte privater Ganzzahltyp; // Die Farbe der Kartenpublikumskarte (Ganzzahl -ID, Ganzzahltyp) {this.id = id; this.type = Typ; } public Integer getId () {return id; } public void setId (Integer id) {this.id = id; } public Integer gettType () {return type; } public void setType (Ganzzahltyp) {this.type = type; } @Override public String toString () {return "card [id =" + id + ", type =" + type + "]"; }} Poker-Pokerklasse: Inklusive Pokerkarte A-2
Package CollectionTest.games; public Class Poker {private karten id2; private Karten -ID3; Private Card ID4; private Karten -ID5; Private Card ID6; Private Card ID7; Private Card ID8; Private Card ID9; Private Card ID10; private Karte J; private Karte Q; private Karte K; private Karte a; public Poker () {} // vier Typen: Schwarz-4, Rot-3, Plum-2, Square-1 public Poker (Ganzzahltyp) {this.id2 = neue Karte (2, Typ); this.id3 = neue Karte (3, Typ); this.id4 = neue Karte (4, Typ); this.id5 = neue Karte (5, Typ); this.id6 = neue Karte (6, Typ); this.id7 = neue Karte (7, Typ); this.id8 = neue Karte (8, Typ); this.id9 = neue Karte (9, Typ); this.id10 = neue Karte (10, Typ); this.j = neue Karte (11, Typ); this.q = neue Karte (12, Typ); this.k = neue Karte (13, Typ); this.a = neue Karte (14, Typ); } public card getid2 () {return id2; } public void setId2 (karten id2) {this.id2 = id2; } public card getId3 () {return id3; } public void setId3 (Karten id3) {this.id3 = id3; } public card getid4 () {return id4; } public void setId4 (Karten id4) {this.id4 = id4; } public card getId5 () {return id5; } public void setID5 (Karten id5) {this.id5 = id5; } public card getId6 () {return id6; } public void setId6 (karten id6) {this.id6 = id6; } public card getId7 () {return id7; } public void setId7 (karten id7) {this.id7 = id7; } public card getId8 () {return id8; } public void setId8 (karten id8) {this.id8 = id8; } public card getId9 () {return id9; } public void setId9 (karten id9) {this.id9 = id9; } public card getid10 () {return id10; } public void setID10 (Karte ID10) {this.id10 = id10; } public card getJ () {return j; } public void setj (Karte j) {j = j; } public card getQ () {return q; } public void setQ (Karte q) {q = q; } public card getk () {return k; } public void setk (Karte k) {k = k; } public card geta () {return a; } public void seta (Karte a) {a = a; }} Spielerklasse: Enthält Player -ID und Name, Karteninformationen enthalten
Package CollectionTest.games; import Java.util.ArrayList; Import Java.util.List; Public Class Player {// Player ID private String -ID; // Name des Spielers private Zeichenfolge Name; // Spielerlizenz, die vom Player Private List <Card> PokerType gehalten wird; public Player () {} öffentlicher Player (String -ID, String -Name, List <Card> PokterType) {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.poKtype = pokerType; }} Hauptkategorie des Pokerspiels: einschließlich 1) Pokererstellung 2) Spieler Erstellung 3) Schrumpfen 4) Rabatt 5) Vergleichen Sie die Gewinner und Verluste
Package CollectionTest.games; Import Java.util.ArrayList; Import Java.util.Arrays; Import Java.util.Collections; Import Java.util.hashMap; Import Java.util.hashset; {// Spielkarten erstellen public set <Poker> cpoker () {system.out.println ("************ Starten Sie Pokerkarten *********"); // Erstellen Sie ein Deck mit Poker // Vier Typen: Schwarz-4, Rot-3, Plum-2, Quadrat-1 Set <Poker> pokers = new Hashset <> (); Poker [] Poker = {New Poker (1), New Poker (2), New Poker (3), New Poker (4)}; /** Verwendung von Sammlungs -Toolklassen* collectionss.addall (Pokers, neuer Poker (1), neuer Poker (2), neuer Poker (3), neuer Poker (4)); * * */ pokers.addall (arrays.aslist (poker)); System.out.println("****************** Poker card creation successfully****************"); Pokers zurückgeben; } // zwei Spieler public map <String, Player> CPlayer () {System.out.println ("**********************"); Karte <String, Player> map = new HashMap <String, Player> (); // steuern Sie die Zahl Integer Control = 0; System.out.println ("Zwei Spieler erstellen, gemäß der Eingabeaufforderung erstellen"); Scannerkonsole = neuer Scanner (System.in); while (true) {System.out.println ("Bitte geben Sie die"+(Steuerung+1)+"Player ID:") ein; String curseId = console.next (); if (isnumeric (cursId)) {System.out.println ("Bitte geben Sie die"+(Steuerung+1)+"Player Name"); String CourSename = console.Next (); Spieler Spieler = neuer Spieler (Cursid, CourSename, NULL); // Data map.put (CourseId, Spieler) speichern; System.out.println ("add" + (control + 1) + "player" + courSename + "Erfolg"); // Steuerung ++ nach Zahl hinzufügen; } else {System.out.println ("****** Bitte geben Sie die numerische ID *******"); weitermachen; } if (control == 2) {break; }} System.out.println ("************ erfolgreich erstellt **************"); Rückgabekarte; } // Bestimmen Sie, ob die Eingabe eine Zahl ist, Zeichen. }} return true; } / ***Shuffle: 52 verschiedene Zufallsnummern können auch generiert werden, um Shuffle*** / publiclist <karten> wpoker (set <Poker> pokers) {System.out.println ("********* SET SHUFFER ********"); // Verwenden Sie die ordnungsgemäße Art von Liste und speichern Sie die Bestellung nach dem Shuffle. List <Card> listCard = new ArrayList <> (); // Verwenden Sie die nicht ordnungsgemäße Art von Set, um Shuffle Set <Card> listSet = new Hashset <> () zu erreichen. // auf dem festgelegten Set speichern, nicht ordnungsgemäß für (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 ()); } // in der Listensammlung speichern, bestellt für (CARD CD: ListSet) {listCard.add (CD); System.out.println (CD); } System.out.println ("******************* erfolgreich umgestaltet **********"); Rückgabelistenkarte; } // public map <String, Player> pushpoker (List <Card> listCard, Map <String, Player> PMAP) {System.out.println ("**************** // jede Person kontrollieren, um zwei Karten in INT Control = 0 zu versorgen; für (Map.Entry <String, Player> Eintrag: pMAP.EntrySet ()) {if (control == 0) {für (int i = 0; i <3; i = i + 2) {// Distributionseintrag. } // MAP -Objekt pmap.put (Eintrag.Getkey (), Eintrag.getValue ()); Kontrolle ++; } else if (control == 1) {for (int i = 1; i <4; i = i + 2) {// Distributioneintrag.getValue (). getPocType (). } // MAP -Objekt pmap.put (Eintrag.Getkey (), Eintrag.getValue ()); Kontrolle ++; } else {break; } } System.out.println("****************** successful deal**********"); PMAP zurückgeben; } public void CompuMatch (MAP <String, Player> Newmap) { /* Vergleiche Siege und -verluste* 1. Holen Sie sich zuerst die ID und die Anzug -ID der größten Karte in den Händen jedes Spielers. * 2. Vergleichen Sie die ID -Größen der größten Karte in den Händen von zwei Spielern und die größere gewinnt. * 3. Wenn die IDs der beiden Karten gleich sind, wird der Anzug -ID beim Vergleich der Anzug -IDs der beiden Karten größer und der Sieg wird erzielt. * * */ List <File> Player = new ArrayList <> (); // zwei Spieler für (MAP.Entry <String, Player> Eintrag: Newmap.EntrySet ()) {Players.add (Eintrag.GetValue ()); } // Player One Information and Lizenzliste <Card> PlayerOne = Player.get (0) .GetPoKType (); // Erhalten Sie die ID und den Anzug der größten Card Integer onemaxid = math.max (PlayerOne.get (0) .getId (), PlayerOne.get (1) .getId ()); Integer OnemaxType = (Onemaxid! = PlayerOne.get (0) .GetId ())? PlayerOne.get (1) .Getype (): PlayerOne.get (0) .GetType (); // Player Zwei Informationen und Lizenzliste <Card> Playertwo = Players.get (1) .GetPoKType (); // Erhalten Sie die ID und den Anzug der größten Card 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 ("Player:" + player.get (0) .getName () + "Win !!"); } else if (onemaxid == twomaxId) {if (onemaxType> twomaxType) {System.out.println ("Player:" + Player.get (0) .getName () + "Win !!"); } else {System.out .println ("Player:" + player.get (1) .getName () + "Win!!"); }} else {System.out.println ("Player:" + player.get (1) .getName () + "Win !!"); } System.out.println ("****************************************************************** System.out.println ("Player:" + Player.get (0) .GetName () + "Die Karte von" IS: " + teamname (PlayerOne.get (0) .Getype (), 0) +"-" + teamname (PlayerOne.get (0) .getId (), 1) +" + " +" + " +" + " +". teamame (PlayerOne.get (1) .GetID (), 1)); Showame (Playertwo.get (1) .GetType (), 0) + "-" + teamname (Playertwo.get (1) .getId (), 1)); } // Der Name der privaten Zeichenfolge der Anzeigekarte (Integer I, Ganzzahltyp) {String str = ""; // Anzug anzeigen if (type == 0) {switch (i) {case 1: {str = "cube"; brechen; } case 2: {str = "Plum Blossom"; brechen; } Fall 3: {str = "Herz"; brechen; } case 4: {str = "str =" spads "; break;} Standard: {break;}}} // Zeigen Sie die Nummer if (type == 1) {if (i <11) {return i.toString ();} else {switch (i) {case 11: {str =" j "; Break; // 3. Shuffle List <Card> listCard = gb.wpoker (pokers); Auslaufergebnisse:
********* Beginnen Sie mit der Erstellung von Pokerkarten **********
************************************************
********* fangen Sie an, Spieler zu erstellen ***************
Um zwei Spieler zu erstellen, geben Sie bitte die 1. Spieler -ID ein, gemäß den Eingabeaufforderungen:
Bitte geben Sie den ersten Spielernamen ein:
Stephen Chow fügte den ersten Spieler hinzu. Stephen Chow gelang es. Bitte geben Sie die zweite Spieler -ID ein:
Bitte geben Sie den zweiten Spielernamen ein:
Chow Yun-fat fügte den zweiten Spieler hinzu, Chow Yun-fat erfolgreich
********** Kreation erfolgreich *************
************ Start Shuffle **********
Karte [ID = 9, Typ = 3]
Karte [ID = 11, Typ = 4]
Karte [ID = 13, Typ = 3]
Karte [ID = 8, Typ = 3]
Karte [ID = 5, Typ = 2]
Karte [ID = 6, Typ = 1]
Karte [ID = 4, Typ = 3]
Karte [ID = 5, Typ = 4]
Karte [ID = 2, Typ = 3]
Karte [ID = 9, Typ = 2]
Karte [ID = 9, Typ = 4]
Karte [ID = 14, Typ = 2]
Karte [ID = 9, Typ = 1]
Karte [ID = 2, Typ = 1]
Karte [ID = 2, Typ = 4]
Karte [ID = 7, Typ = 4]
Karte [ID = 11, Typ = 1]
Karte [ID = 10, Typ = 1]
Karte [ID = 14, Typ = 4]
Karte [ID = 14, Typ = 3]
Karte [ID = 12, Typ = 2]
Karte [ID = 2, Typ = 2]
Karte [ID = 10, Typ = 2]
Karte [ID = 7, Typ = 1]
Karte [ID = 7, Typ = 3]
Karte [ID = 8, Typ = 2]
Karte [ID = 4, Typ = 4]
Karte [ID = 13, Typ = 4]
Karte [ID = 14, Typ = 1]
Karte [ID = 12, Typ = 1]
Karte [ID = 5, Typ = 1]
Karte [ID = 6, Typ = 4]
Karte [ID = 12, Typ = 4]
Karte [ID = 11, Typ = 2]
Karte [ID = 10, Typ = 3]
Karte [ID = 3, Typ = 4]
Karte [ID = 12, Typ = 3]
Karte [ID = 4, Typ = 2]
Karte [ID = 4, Typ = 1]
Karte [ID = 6, Typ = 2]
Karte [ID = 5, Typ = 3]
Karte [ID = 8, Typ = 4]
Karte [ID = 3, Typ = 2]
Karte [ID = 13, Typ = 2]
Karte [ID = 7, Typ = 2]
Karte [ID = 3, Typ = 3]
Karte [ID = 3, Typ = 1]
Karte [ID = 6, Typ = 3]
Karte [ID = 8, Typ = 1]
Karte [ID = 11, Typ = 3]
Karte [ID = 13, Typ = 1]
Karte [ID = 10, Typ = 4]
************* erfolgreiche Umbau **********
*******************************************************
************* erfolgreicher Deal ***************
Spieler: Stephen Chow hat gewonnen! !
**************************************************
Spieler: Stephen Chows Karte ist: Red Peach-9 Red Peach-K
Spieler: Chow Yun-Fat's Card ist: Spades-J Red-8
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.