Verificar qual o vencedor

Programação Java
#1

Boas pessoal.

Eu estou com uma duvida que é a seguinte: eu estou a fazer o jogo do 21 e queria saber como fasso para ver qual dos jogadores tem a pontuação mais perto ou igual de 21. Para tal eu tenho um atributo na classe jogador que é a pontuaçao mas eu agora não sei como fazer para comparar os valores desse atributo.

#2 
if(jogador1.getAtributo() != 21 && jogador1.getAtributo() > jogador2.getAtributo()){
      //faz algo
}
#3

Pois isso eu ja tinha tentado mas neste caso e o minimo de jogadores é 3 logo esse cilclo ja nao da

#4

Faz o seguinte, cria um classe com dois atributos, guarde a identificação do jogador e o numero dele que foi sorteado.

Depois adicione esses objetos em uma collection, ordene pelo maior numero sorteado e retirando os jogadores que tiverem um numero sorteado maior que 21. tera o ganhador.

Blz? a logica ta ai, se precisar de mais só falar.
abraço…

#5

outro exemplo

se(if) o jogador1.pontos for menor ou igual a 21(=<) e(&&) jogador1.pontos for maior que jogador2.pontos e jogador1.pontos for maior que jogador3.pontos
//ele ganha

mas isso ia enche de if seu código é só pensa numa solução melhor mas essa é uma lógica para que os jogadores parem de pedir cartas e não esperarem passar 21

#6

Não tou a conseguir fazer como tu disseste, será que me podes dar um exemplo atraves de codigo

#7

Coloca seus codigos, principalmente o bean de jogador.

#8

public void vencedor(){
for(int i=0;i<jogador21.size();i++){
if(jogador21.get(i).getPontuacao()==21)
System.out.println(“O vencedor é”+jogador21.get(i).getNome());

		else
			verifica(i);
		  
	}
}

public void verifica(int i){
	if(jogador21.get(i).getPontuacao()>21)
		System.out.println("perdeu");
	else

o resto é que eu nao tou a conseguir fazer

#9 


public void vencedor(){

       Collection<Jogador> vencedores = determinaVencedores(jogadores21);
 
      System.out.println("Os vencedores são:");
       // itera a colecção e mostra os nomes..   

}
private Collection<Jogador> determinaVencedores(Collection<Jogador> jogadores){
        
          // 'clona'
         List sel = new ArrayList(jogadores);
  
         // ordena os jogadores pelo quanto mais se aproximou de 21.
         // quem mais se aproximou fica primeiro na colecção
         Collections.sort(sel, new Comparator<Jogador>(){

                  public int compare(Jogador a, Jogador b){
                         // está mais perto quem tem diferença para 21 menor e  positiva           
                           int difA = 21 - a.getPontuacao();
                           int difB= 21 - a.getPontuacao();
                             
                           if (difA <0 ){
                                    if (difB <0){
                                         return 0; // iguais    
                                    } else {
                                         return 1; // a > b // b é mais proximo
                                    }
                           } else {
                                    if (difB <0){
                                         return -1; // a < b // a é mais proximo
                                    } else {
                                         // ambos são positivos 
                                         // retorna a diferença dos valores 
                                        return difA - difB  ;
                                    }
                            }
                  }
         }); 
         
          // aqui, sel está ordenado , sendo que o primeiro é o mais proximo de 21 , sem ter ultrapassado 21.
// so que pode ter havido empate. Então os vencedores são os primeiros N que tiverem a mesma pontuação

         int pontos = sel.get(0).getPontuacao();

         for (Iterator<Jogador> it = sel.iterator();it.hasNext();){
                   if (it.next().getPontaucao()!=pontos){
                         it.remove();
                   } 
        }
         
        return sel;
    }
#10