Recopilación de la interfaz raíz en la jerarquía. La colección representa un conjunto de objetos, también llamados Elementos de la Colección. Algunas colecciones permiten elementos duplicados, mientras que otras no. Se ordenan algunas colecciones, mientras que otras están desordenadas. El JDK no proporciona ninguna implementación directa de esta interfaz: proporciona subinterfaces más específicas (como SET y LIST) implementaciones. Esta interfaz generalmente se usa para pasar colecciones y operar estas colecciones donde se requiere la máxima universalidad.
Contenido principal: aquí usamos la colección de colección para simular el juego de póker jugado por los grandes de las películas de Hong Kong.
1. Reglas del juego: cada uno de los dos jugadores trata dos cartas en sus manos y las compara. Compare los puntos máximos de la carta de cada jugador, el tamaño es A-2, el que tiene los puntos más grandes gana. Si los puntos son los mismos, se compara el color del traje, el tamaño es negro (4), rojo (3), ciruela (2), cuadrado (1) y el color del traje es el ganador.
2. Pasos de implementación:
Cree un mazo de cartas de juego A-2, con cuatro colores de negro (4), rojo (3), ciruela (2) y cuadrado (1) con un total de 52 cartas;
Cree dos jugadores, incluida la identificación y el nombre del jugador y la información con licencia de la tarjeta;
Baraja las cartas y repartir dos cartas a ambos jugadores;
Compare el tamaño de la carta en la mano del jugador para obtener el ganador;
3. Implementación del programa
Categoría de la tarjeta: contiene los números y los colores de las tarjetas
paquetes CollectionTest.games; tarjeta de clase pública {ID de entero privado; // tamaño del tipo de entero privado de tarjeta; // El color de la tarjeta de la tarjeta de la tarjeta (ID de entero, tipo entero) {this.id = id; this.type = type; } public integer getId () {return id; } public void setid (ID de entero) {this.id = id; } public Integer getType () {Tipo de retorno; } public void settype (tipo entero) {this.type = type; } @Override public String toString () {return "tarjeta [id =" + id + ", type =" + type + "]"; }} Clase de póker de póker: incluye tarjeta de póker A-2
paquetes de colección.games; public class Poker {Private Card ID2; ID3 de tarjeta privada; Tarjeta privada ID4; ID5 de tarjeta privada; Tarjeta privada ID6; ID7 de tarjeta privada; Tarjeta privada ID8; Tarjeta privada ID9; ID de tarjeta privada10; Tarjeta privada J; Tarjeta privada Q; Tarjeta privada K; tarjeta privada a; Public Poker () {} // Cuatro tipos: negro-4, rojo-3, Plum-2, cuadrado-1 Póker público (tipo entero) {this.id2 = nueva tarjeta (2, type); this.id3 = nueva tarjeta (3, tipo); this.id4 = nueva tarjeta (4, tipo); this.id5 = nueva tarjeta (5, tipo); this.id6 = nueva tarjeta (6, tipo); this.id7 = nueva tarjeta (7, tipo); this.id8 = nueva tarjeta (8, tipo); this.id9 = nueva tarjeta (9, tipo); this.id10 = nueva tarjeta (10, tipo); this.j = nueva tarjeta (11, tipo); this.q = nueva tarjeta (12, tipo); this.k = nueva tarjeta (13, tipo); this.a = nueva tarjeta (14, tipo); } tarjeta pública getId2 () {return id2; } public void setid2 (tarjeta id2) {this.id2 = id2; } tarjeta pública getId3 () {return id3; } public void setId3 (tarjeta id3) {this.id3 = id3; } tarjeta pública getId4 () {return id4; } public void setId4 (tarjeta id4) {this.id4 = id4; } tarjeta pública getId5 () {return id5; } public void setId5 (tarjeta id5) {this.id5 = id5; } tarjeta pública getId6 () {return id6; } public void setId6 (tarjeta id6) {this.id6 = id6; } tarjeta pública getId7 () {return id7; } public void setId7 (tarjeta id7) {this.id7 = id7; } tarjeta pública getId8 () {return id8; } public void setId8 (tarjeta id8) {this.id8 = id8; } tarjeta pública getId9 () {return id9; } public void setId9 (tarjeta ID9) {this.id9 = id9; } tarjeta pública getId10 () {return id10; } public void setId10 (ID de tarjeta) {this.id10 = id10; } tarjeta pública getj () {return j; } public void setj (tarjeta j) {j = j; } tarjeta pública getq () {return q; } public void setq (tarjeta q) {q = q; } tarjeta pública getk () {return k; } public void setk (tarjeta k) {k = k; } tarjeta pública geta () {return a; } public void seta (tarjeta a) {a = a; }} Clase de jugador: contiene ID y nombre del jugador, información de la carta sostenida
paquetes de recolección.games; import java.util.ArrayList; import java.util.list; Public Class Player {// ID de ID de jugador Private String ID; // Nombre del jugador Nombre de cadena privada; // Licencia de jugador mantenida por la lista privada del jugador <Card> PokerType; Public Player () {} Public Player (ID de cadena, nombre de cadena, List <Card> PokerType) {this.id = id; this.name = name; this.pokerType = new ArrayList <> (); } public String getId () {return id; } public void setid (ID de cadena) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } Lista pública <Card> getPokerType () {return pokerType; } public void setPokerType (list <ard> pokerType) {this.pokerType = pokerType; }} Juego de póker Categoría principal: incluyendo 1) Creación de póker 2) Creación de jugadores 3) Recogida 4) Descuento 5) Compare los ganadores y las pérdidas
paquetes de recolección.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 Gamsbegin {// Crear cartas de juego Set Public <Poker> CPoker () {System.out.println ("************** Comience a crear tarjetas de póker **********"); // Crear un mazo de póker // cuatro tipos: negro-4, rojo-3, ciruela-2, cuadrado-1 set <Poker> pokers = new Hashset <> (); Poker [] Poker = {New Poker (1), New Poker (2), New Poker (3), New Poker (4)}; /** Uso de clases de herramientas de colecciones* Collections.addall (Pokers, New Poker (1), New Poker (2), New Poker (3), New Poker (4)); * * */ pokers.addall (arrays.aslist (póker)); System.out.println ("******************** La creación de tarjetas de póker con éxito ****************"); Return Pokers; } // Crear dos jugadores Map público <String, Player> Cplayer () {System.out.println ("************** Comience a crear jugador ******************"); Map <string, jugador> map = new HashMap <String, Player> (); // Controle el número de Control Integer = 0; System.out.println ("Crear dos jugadores, crear de acuerdo con el aviso"); Consola de escáner = nuevo escáner (System.in); while (true) {system.out.println ("Por favor ingrese el"+(control+1)+"ID de jugador:"); String CourseId = console.next (); if (isNumeric (CourseID)) {System.out.println ("Por favor ingrese el"+(Control+1)+"Nombre del jugador:"); String CoRSEname = console.next (); Jugadores jugadores = nuevo jugador (CourseDid, Coursename, NULL); // Guardar datos MAP.put (CourseID, Players); System.out.println ("agregar" + (control + 1) + "jugadores" + Coursename + "éxito"); // Agregar control ++ por número; } else {System.out.println ("****** Por favor ingrese la identificación numérica *******"); continuar; } if (control == 2) {break; }} System.out.println ("************* Jugador creado con éxito ****************"); mapa de retorno; } // Determine si la entrada es un número, caracteres.isDigit () es un método java público boolean isnumeric (string str) {for (int i = 0; i <str.length (); i ++) {if (! Caracteres.isDigit (str.charat (i)) {return false; }} return verdadero; } / ***Shuffle: 52 también se pueden generar diferentes números aleatorios para lograr Shuffle*** / Public List <Card> Wpoker (Set <Poker> Pokers) {System.out.println ("********* Comience Shuffle **********"); // Use el tipo de lista ordenada y guarde el pedido después de la baraja. List <Card> listCard = new ArrayList <> (); // use el tipo de conjunto desordenado para lograr el set de Shuffle <ard> listset = new Hashset <> (); // Guardar en el conjunto establecido, desordenado para (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 ()); } // Guardar en la colección de listas, ordenada para (CD CD: Listset) {listCard.Add (CD); System.out.println (CD); } System.out.println ("********************* Resaltado correctamente ************"); devuelve listcard; } // Dejar el mapa público <String, Player> Pushpoker (List <Card> Listcard, Map <String, Player> PMAP) {System.out.println ("********************* Tomar el trato ****************"); // Controle a cada persona para tratar dos tarjetas int control = 0; for (map.Entry <String, Player> Entry: PMAP.ENTRYSET ()) {if (control == 0) {for (int i = 0; i <3; i = i + 2) {// distribución entry.getValue (). getPokerType (). add (list.get (i)); } // Actualizar el objeto MAP PMAP.put (Entry.getKey (), Entry.getValue ()); control ++; } else if (control == 1) {for (int i = 1; i <4; i = i + 2) {// distribución entry.getValue (). getPokerType (). add (listCard.get (i)); } // Actualizar el objeto MAP PMAP.put (Entry.getKey (), Entry.getValue ()); control ++; } else {break; }} System.out.println ("******************* ALTA exitoso **********"); devolver PMAP; } Public void Comparematch (map <string, jugador> newmap) { /* Compare las victorias y pérdidas* 1. Primero obtenga la identificación y la identificación del traje de la tarjeta más grande en manos de cada jugador. * 2. Compare los tamaños de identificación de la carta más grande en manos de dos jugadores, y el más grande gana. * 3. Si los ID de las dos cartas son iguales, al comparar las ID de traje de las dos cartas, la identificación del traje será mayor y la victoria se logrará. * * */ List <Player> Players = New ArrayList <> (); // Obtener dos jugadores para (MAP.Entry <String, Player> Entry: NewMap.EntrySet ()) {Players.Add (Entry.getValue ()); } // Jugador One Información y lista de licencias <Card> PlayerOne = Players.get (0) .getPokerType (); // Obtenga la identificación y el traje del entero de cartas más grande OneMaxid = Math.max (PlayerOne.get (0) .getId (), PlayerOn.get (1) .getId ()); Integer OnEmxtype = (OneMaxid! = PlayerOne.get (0) .getId ())? PlayerOne.get (1) .GetType (): PlayerOne.get (0) .GetType (); // Jugador dos información y lista de licencias <Card> playertwo = jugadores.get (1) .getPokerType (); // Obtenga la identificación y el traje del entero de cartas más grande 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 ("jugador:" + jugadores.get (0) .getName () + "win !!"); } else if (onemaxid == twomaxid) {if (onEmextype> twomaxtype) {system.out.println ("jugador:" + jugadores.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() + "The card of "is: " + showName(playerOne.get(0).getType(), 0) + "--" + showName(playerOne.get(0).getId(), 1) + " " + showName(playerOne.get(1).getType(), 0) + "--" + Showeame (PlayerOne.get (1) .getId (), 1)); showeame (playertwo.get (1) .gettype (), 0) + "-" + showingame (playertwo.get (1) .getId (), 1)); } // El nombre de la tarjeta de visualización de la cadena privada Showeame (Integer I, Tipo Integer) {String Str = ""; // Mostrar traje if (type == 0) {switch (i) {case 1: {str = "cubo"; romper; } caso 2: {str = "Plum Blossom"; romper; } caso 3: {str = "corazón"; romper; } caso 4: {str = "str =" spads "; break;} default: {break;}}} // muestra el número if (type == 1) {if (i <11) {return i.ToString ();} else {switch (i) {case 11: {str =" j "; break;} case 12: {str =" q ";} break;} Break; GB.CPlayer (); Resultados de ejecución:
********* Comience a crear tarjetas de póker **********
*************** La creación de tarjetas de póker con éxito **************
********* Comience a crear jugadores *************
Para crear dos jugadores, ingrese la ID del primer jugador de acuerdo con las indicaciones:
Ingrese el nombre del primer jugador:
Stephen Chow agregó el primer jugador. Stephen Chow tuvo éxito. Ingrese la ID del segundo jugador:
Ingrese el nombre del segundo jugador:
Chow Yun-Fat agregó el segundo jugador, Chow Yun-Fat con éxito
************ Creación de jugadores con éxito **************
*************
Tarjeta [id = 9, tipo = 3]
Tarjeta [id = 11, tipo = 4]
Tarjeta [id = 13, tipo = 3]
Tarjeta [id = 8, tipo = 3]
Tarjeta [id = 5, tipo = 2]
Tarjeta [id = 6, tipo = 1]
Tarjeta [id = 4, tipo = 3]
Tarjeta [id = 5, tipo = 4]
Tarjeta [id = 2, tipo = 3]
Tarjeta [id = 9, tipo = 2]
Tarjeta [id = 9, tipo = 4]
Tarjeta [id = 14, tipo = 2]
Tarjeta [id = 9, tipo = 1]
Tarjeta [id = 2, tipo = 1]
Tarjeta [id = 2, tipo = 4]
Tarjeta [id = 7, tipo = 4]
Tarjeta [id = 11, tipo = 1]
Tarjeta [id = 10, tipo = 1]
Tarjeta [id = 14, tipo = 4]
Tarjeta [id = 14, tipo = 3]
Tarjeta [id = 12, tipo = 2]
Tarjeta [id = 2, tipo = 2]
Tarjeta [id = 10, tipo = 2]
Tarjeta [id = 7, tipo = 1]
Tarjeta [id = 7, tipo = 3]
Tarjeta [id = 8, tipo = 2]
Tarjeta [id = 4, tipo = 4]
Tarjeta [id = 13, tipo = 4]
Tarjeta [id = 14, tipo = 1]
Tarjeta [id = 12, tipo = 1]
Tarjeta [id = 5, tipo = 1]
Tarjeta [id = 6, tipo = 4]
Tarjeta [id = 12, tipo = 4]
Tarjeta [id = 11, tipo = 2]
Tarjeta [id = 10, tipo = 3]
Tarjeta [id = 3, tipo = 4]
Tarjeta [id = 12, tipo = 3]
Tarjeta [id = 4, tipo = 2]
Tarjeta [id = 4, tipo = 1]
Tarjeta [id = 6, tipo = 2]
Tarjeta [id = 5, tipo = 3]
Tarjeta [id = 8, tipo = 4]
Tarjeta [id = 3, tipo = 2]
Tarjeta [id = 13, tipo = 2]
Tarjeta [id = 7, tipo = 2]
Tarjeta [id = 3, tipo = 3]
Tarjeta [id = 3, tipo = 1]
Tarjeta [id = 6, tipo = 3]
Tarjeta [id = 8, tipo = 1]
Tarjeta [id = 11, tipo = 3]
Tarjeta [id = 13, tipo = 1]
Tarjeta [id = 10, tipo = 4]
*************** Extracción exitosa ************
*************** La oferta de carga comienza **************
************* OFERTA exitosa ***************
Jugador: Stephen Chow ganó! !
********************************************************
Jugador: la tarjeta de Stephen Chow es: Red Peach-9 Red Peach-K
Jugador: la carta de Chow Yun-Fat es: Spades-J Red-8
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.