Coleta a interface raiz na hierarquia. A coleção representa um conjunto de objetos, também chamados de elementos de coleção. Algumas coleções permitem elementos duplicados, enquanto outros não. Algumas coleções são ordenadas, enquanto outras são desordenadas. O JDK não fornece nenhuma implementação direta dessa interface: fornece implementações de subinterfaces mais específicas (como set e list). Essa interface é geralmente usada para passar coleções e operar essas coleções onde a universalidade máxima é necessária.
Conteúdo principal: aqui usamos a coleção de coleções para simular o jogo de pôquer jogado pelos grandes filmes de Hong Kong.
1. Regras do jogo: Cada um dos dois jogadores lida com duas cartas nas mãos e as compara. Compare os pontos máximos da carta de cada jogador, o tamanho é A-2, aquele com os maiores pontos de pontos. Se os pontos forem iguais, a cor do traje é comparada, o tamanho é preto (4), vermelho (3), ameixa (2), quadrado (1) e a cor do traje é o vencedor.
2. Etapas de implementação:
Crie um baralho de cartas A-2, com quatro cores de preto (4), vermelho (3), ameixa (2) e quadrado (1) totalizando 52 cartas;
Crie dois jogadores, incluindo ID de jogador e nome e informações de cartão licenciado;
Embaralhar as cartas e lidar com duas cartas para os dois jogadores;
Compare o tamanho da carta na mão do jogador para obter o vencedor;
3. Implementação do programa
Categoria de cartão: contém os números e cores dos cartões
pacote collectiontest.games; cartão público {private integer id; // tamanho do tipo inteiro privado do cartão; // a cor do cartão público cartão (ID inteiro, tipo inteiro) {this.id = id; this.type = type; } public integer getId () {return id; } public void SetId (ID inteiro) {this.id = id; } public integer getType () {return type; } public void setType (tipo inteiro) {this.type = type; } @Override public String tostring () {return "Card [id =" + id + ", type =" + type + "]"; }} Classe de pôquer: inclui cartão de pôquer A-2
pacote collectiontest.games; public class poker {private cartão id2; ID3 do cartão privado 3; ID4 do cartão privado4; ID5 do cartão privado5; ID do cartão privado6; ID de cartão privado7; ID de cartão privado8; ID do cartão privado9; ID1 de cartão privado10; cartão privado j; cartão privado q; cartão privado k; cartão privado a; public poker () {} // quatro tipos: preto-4, vermelho-3, ameixa-2, quadrado-1 Public poker (tipo inteiro) {this.id2 = novo cartão (2, tipo); this.id3 = novo cartão (3, tipo); this.id4 = novo cartão (4, tipo); this.id5 = novo cartão (5, tipo); this.id6 = novo cartão (6, tipo); this.id7 = novo cartão (7, tipo); this.id8 = novo cartão (8, tipo); this.id9 = novo cartão (9, tipo); this.id10 = novo cartão (10, tipo); this.j = novo cartão (11, tipo); this.q = novo cartão (12, tipo); this.k = novo cartão (13, tipo); this.a = novo cartão (14, tipo); } cartão público getId2 () {return id2; } public void SetId2 (cartão ID2) {this.id2 = id2; } cartão público getId3 () {return id3; } public void SetId3 (cartão ID3) {this.id3 = id3; } cartão público getId4 () {return id4; } public void SetId4 (cartão ID4) {this.id4 = id4; } cartão público getId5 () {return id5; } public void SetId5 (cartão ID5) {this.id5 = id5; } cartão público getId6 () {return id6; } public void SetId6 (cartão ID6) {this.id6 = id6; } cartão público getId7 () {return id7; } public void SetId7 (cartão ID7) {this.id7 = id7; } cartão público getId8 () {return id8; } public void SetId8 (cartão ID8) {this.id8 = id8; } cartão público getId9 () {return id9; } public void SetId9 (cartão ID9) {this.id9 = id9; } cartão público getId10 () {return id10; } public void SetId10 (cartão ID10) {this.id10 = id10; } cartão público getj () {return j; } public void setj (cartão j) {j = j; } cartão público getq () {return q; } public void setq (cartão q) {q = q; } cartão público getk () {return k; } public void setk (cartão k) {k = k; } cartão público getA () {return a; } public void seta (cartão a) {a = a; }} Classe de jogador: contém identificação e nome do jogador, informações de cartão mantidas
pacote collectionTest.games; importar java.util.ArrayList; importar java.util.list; public class Player {// ID do ID do Player Private String ID; // Nome do jogador Nome da sequência privada; // Licença de jogador mantida pela Lista Privada do Jogador <Card> PokerType; public player () {} public player (string id, nome da string, list <cart> pokertype) {this.id = id; this.name = nome; 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 (nome da string) {this.name = name; } Lista pública <Card> getPokerType () {return PokerType; } public void setPokerType (List <Card> PokerType) {this.pokerType = PokerType; }} Categoria principal do jogo de pôquer: incluindo 1) criação de poker 2) Criação do jogador 3) encolhimento 4) desconto 5) Compare os vencedores e perdas
Coleção de pacotes de coleta de pacotes.games; importar java.util.ArrayList; importar java.util.arrays; importar java.util.Collections; importar java.util.hashmap; import java.util.hashset; Gamsbegin {// Crie cartões de jogo public Set <poker> cpoker () {System.out.println ("************ Comece a criar cartões de pôquer **********"); // Crie um baralho de poker // quatro tipos: preto-4, vermelho-3, ameixa-2, quadrado-1 conjunto <Poker> pokers = novo hashset <> (); Poker [] poker = {new poker (1), novo poker (2), novo poker (3), novo poker (4)}; /** Uso de aulas de ferramentas de coleções* Coleções.addall (Pokers, New Poker (1), New Poker (2), New Poker (3), New Poker (4)); * * */ pokers.addall (Arrays.aslist (poker)); System.out.println ("***************** retornar Pokers; } // Crie dois jogadores mapa público <string, player> cplayer () {System.out.println ("************ Comece a criar jogador ******************"); Mapa <string, player> map = new hashmap <string, player> (); // Controle o número inteiro controle = 0; System.out.println ("Crie dois jogadores, crie de acordo com o prompt"); Scanner Console = New Scanner (System.in); while (true) {System.out.println ("Por favor, digite o"+(controle+1)+"ID do jogador:"); String CourseId = Console.Next (); if (isnumeric (CourseId)) {System.out.println ("Por favor, digite o"+(controle+1)+"nome do jogador:"); String coursename = console.next (); Jogadores jogadores = novo jogador (CourseId, CourseName, NULL); // Salvar mapa de dados.put (CourseId, jogadores); System.out.println ("Add" + (Control + 1) + "Players" + Coursename + "Success"); // Adicionar controle ++ por número; } else {System.out.println ("****** Por favor, digite o ID numérico *********"); continuar; } if (control == 2) {break; }} System.out.println ("************ Jogador criado com sucesso ****************"); mapa de retorno; } // Determine se a entrada é um número, caractere.isdigit () é um método java public boolean isnumeric (string str) {for (int i = 0; i <str.Length (); i ++) {if (! Caractere.isdigit (str.charat (i))) {return false; }} retornar true; } / ***Shuffle: 52 números aleatórios diferentes também podem ser gerados para alcançar o Shuffle*** / public list <Card> wpoker (set <poker> Pokers) {System.out.println ("********* Comece a Shuffle **********"); // Use o tipo de lista ordenado e salve o pedido após o Shuffle. List <Card> listcard = new ArrayList <> (); // Use o conjunto não ordensamente de conjunto para obter o shuffle set <ard> listSet = new HashSet <> (); // Salvar no conjunto, não ordenado 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 ()); } // Salvar na coleção de listas, encomendada para (CD CD: ListSet) {listcard.add (CD); System.out.println (CD); } System.out.println ("******************* retornar listcard; } // lidando mapa public <string, player> pushPoker (list <Card> listcard, mapa <string, player> pmap) {System.out.println ("********************* // Controle cada pessoa para lidar com dois cartões int control = 0; para (map.entry <string, player> entrada: pmap.entrySet ()) {if (control == 0) {for (int i = 0; i <3; i = i + 2) {// distribuição entradas.getValue (). getPokerType (). Add (listcard.get (i)); } // Atualize o mapa objeto pmap.put (Entry.getKey (), Entry.getValue ()); controle ++; } else if (Control == 1) {for (int i = 1; i <4; i = i + 2) {// distribuição de distribuição.getValue (). getPokerType (). Add (listcard.get (i)); } // Atualize o mapa objeto pmap.put (Entry.getKey (), Entry.getValue ()); controle ++; } else {break; }} System.out.println ("***************** retornar pmap; } public void comparematch (map <string, player> newmap) { /* Compare vitórias e perdas* 1. Primeiro, obtenha o ID e o ID do maiores da maior carta nas mãos de cada jogador. * 2. Compare os tamanhos de ID da maior carta nas mãos de dois jogadores, e o maior vence. * 3. Se os IDs dos dois cartões forem iguais, ao comparar os IDs do processo das duas cartas, o ID do processo será maior e a vitória será alcançada. * * */ List <Player> players = new ArrayList <> (); // Obtenha dois jogadores para (map.entry <string, player> entrada: newmap.entryset ()) {players.add (entrada.getValue ()); } // Lista de informações e licença do Player One <Card> playerone = players.get (0) .getPokerType (); // Obtenha o ID e o terno da maior carta inteira onemaxid = Math.max (playerone.get (0) .getId (), playerone.get (1) .getId ()); Inteiro onemaxType = (onemaxid! = Playerone.get (0) .getId ())? playerone.get (1) .getType (): playerone.get (0) .getType (); // Lista de informações e licença do jogador duas informações <Card> playertwo = players.get (1) .getPokerType (); // Obtenha o ID e o terno da maior carta inteira twomaxid = Math.max (playertwo.get (0) .getId (), playertwo.get (1) .getId ()); Inteiro 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 () + "A carta de" é: " + mostroukame (playerone.get.get (0) .gettype (), 0) +"-" + mostroune.getOne.get.get.get (0) .getId (), 1) +" " + (playerone.get.get (1). Mostrado (PlayerOne.get (1) .getId (), 1)); mostrado nome (playertwo.get (1) .gettype (), 0) + "-" + mostrado nome (playertwo.get (1) .getId (), 1)); } // O nome da placa de exibição Private String mostrou -se (número inteiro i, tipo inteiro) {String str = ""; // Mostre o terno if (type == 0) {switch (i) {case 1: {str = "cubo"; quebrar; } Caso 2: {str = "Plum Blossom"; quebrar; } caso 3: {str = "coração"; quebrar; } caso 4: {str = "str =" spads "; break;} padrão: {break;}}} // mostra o número if (type == 1) {if (i <11) {return i.tostring (); mais {string (i) {{case 11: {str =" j "; break;}; Break; GB.Cplayer (); Resultados em execução:
********* Comece a criar cartões de pôquer **********
************* Criação de cartão de pôquer com sucesso *************
********* Comece a criar jogadores *************
Para criar dois jogadores, insira o ID do 1º jogador de acordo com os prompts:
Por favor, insira o nome do primeiro jogador:
Stephen Chow acrescentou o primeiro jogador. Stephen Chow conseguiu. Por favor, insira o segundo ID do jogador:
Por favor, insira o nome do segundo jogador:
Chow Yun-Fat adicionou o segundo jogador, Chow Yun-Fat com sucesso
********** Criação de jogadores com sucesso *************
************ Comece a embaralhar **********
Cartão [id = 9, tipo = 3]
Cartão [id = 11, tipo = 4]
Cartão [id = 13, tipo = 3]
Cartão [id = 8, tipo = 3]
Cartão [id = 5, tipo = 2]
Cartão [id = 6, tipo = 1]
Cartão [id = 4, tipo = 3]
Cartão [id = 5, tipo = 4]
Cartão [id = 2, tipo = 3]
Cartão [id = 9, tipo = 2]
Cartão [id = 9, tipo = 4]
Cartão [id = 14, tipo = 2]
Cartão [id = 9, tipo = 1]
Cartão [id = 2, tipo = 1]
Cartão [id = 2, tipo = 4]
Cartão [id = 7, tipo = 4]
Cartão [id = 11, tipo = 1]
Cartão [id = 10, tipo = 1]
Cartão [id = 14, tipo = 4]
Cartão [id = 14, tipo = 3]
Cartão [id = 12, tipo = 2]
Cartão [id = 2, tipo = 2]
Cartão [id = 10, tipo = 2]
Cartão [id = 7, tipo = 1]
Cartão [id = 7, tipo = 3]
Cartão [id = 8, tipo = 2]
Cartão [id = 4, tipo = 4]
Cartão [id = 13, tipo = 4]
Cartão [id = 14, tipo = 1]
Cartão [id = 12, tipo = 1]
Cartão [id = 5, tipo = 1]
Cartão [id = 6, tipo = 4]
Cartão [id = 12, tipo = 4]
Cartão [id = 11, tipo = 2]
Cartão [id = 10, tipo = 3]
Cartão [id = 3, tipo = 4]
Cartão [id = 12, tipo = 3]
Cartão [id = 4, tipo = 2]
Cartão [id = 4, tipo = 1]
Cartão [id = 6, tipo = 2]
Cartão [id = 5, tipo = 3]
Cartão [id = 8, tipo = 4]
Cartão [id = 3, tipo = 2]
Cartão [id = 13, tipo = 2]
Cartão [id = 7, tipo = 2]
Cartão [id = 3, tipo = 3]
Cartão [id = 3, tipo = 1]
Cartão [id = 6, tipo = 3]
Cartão [id = 8, tipo = 1]
Cartão [id = 11, tipo = 3]
Cartão [id = 13, tipo = 1]
Cartão [id = 10, tipo = 4]
************* RESTAFULHA DE SUCESSO **********
************* O acordo de cobrança começa ************
************* Negócio de sucesso ***************
Jogador: Stephen Chow venceu! !
*******************************************************
Jogador: O cartão de Stephen Chow é: Red Peach-9 Red Peach-K
Jogador: O cartão de Chow Yun-Fat é: Spades-J Red-8
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.