Verificar letra ja digitada

eai glr blz?, to começando a aprender java e para ficar treinando eu to criando um jogo da forca, porem estou com dificuldades em verificar se a letra ja foi digitada, segue abaixo como ta meu codigo

 boolean acabarJogo = true;
        while (acabarJogo){
         //Palavra a ser adivinhada
        String palavra = "java";
        Scanner letra = new Scanner(System.in);
        //Conversão da palavra em vetor
        String converterString[] = palavra.split("");
        System.out.print("Digite uma letra: ");
        receberLetra = letra.next();
        letraArmazenada = receberLetra.split("");
        //verificar se está correto
            for (int c=0; c < converterString.length; c++) {
                if (converterString[c].equalsIgnoreCase(receberLetra)) {
                    System.out.println("acertou");
                    vencer++;
                    break;
                }
                 else { 
                    if (c == palavra.length() - 1){
                    System.out.println("Errou");
                    perder++;
                    }    
                      }
            }
    }

Bom, amigo, acho que a maneira da qual você está utilizando o método split(); é meio desnecessária, uma vez que ela utiliza uma expressão regular para dividir sua String. Funciona? Sim, funciona, mas acho que seria melhor você criar um vetor com sua palavra utilizando o método toCharArray();.

Por exemplo:

String palavra = "java";
char palavraArray[] = palavra.toCharArray();

Assim, na minha opinião, fica bem melhor.

Agora vamos a diante:
Não sei exatamente quantas tentativas temos em um jogo da forca, talvez 7? (cabeça, 2 braços, 2 pernas e torso = 6 + a ultima tentativa).
Suponha que temos 7 tentativas e a palavra que desejamos encontrar seja ‘grupo’.

Primeiro, temos que criar nossa palavra e nosso array, por exemplo:

String palavra = "GRUPO";
// criando vetor de caracteres com a palavra 'grupo'
char[] palavraVetor = palavra.toUpperCase().toCharArray();

Feito isso, podemos criar certas regras para fazer todas as verificações:

// criando um vetor de letras utilizadas (nosso alfabeto tem 26 letras)
 char[] letrasUtilizadas = new char[26];

Agora, podemos criar alguns controladores, que irão, obviamente, controlar nosso game.

// alguns controladores
int fase = 0, proxPos = 0, tentativas = 0;
boolean acertou = false

Seria legal também, criar um vetor para mostrar a formação atual da palavra, por exemplo, tenho a palavra grupo (5 letras), sua formação inicial seria: _ _ _ _ _

// criando vetor para mostrar a formação da palavra
        char[] exibePalavra = new char[palavraVetor.length];
        for (int i = 0; i < exibePalavra.length; i++)
            exibePalavra[i] = '_';

Agora, podemos iniciar nosso jogo e montar a lógica:

         while (true) {
            // mostrando uma dica
            if (fase == 0) {
                System.out.println("A palavra possui " + palavra.length() + " letras.");
                for (int i = 0; i < exibePalavra.length; i++) {
                    System.out.print(exibePalavra[i] + " ");
                }
                System.out.println();
                fase = 1;
            }

Bom, aqui estamos mostrando nossa dica, informando a quantidade de letras que a palavra possui.

Agora, vamos iniciar a fase de gameplay.
Primeiro, devemos pedir para que o jogador digite uma letra, e então iremos verifica se tal letra já foi digitada antes.
Se lembra do array de letras testadas que foi criado antes? Então, vamos utiliza-lo.
Para facilitar, irei criar um método para executar a verificação:

public static boolean verificaLetra(char a, char v[]) {
        for (int i = 0; i < v.length; i++) {
            if (a == v[i])
                return false;
        }
        return true;
    }

Agora pedimos para que o usuário informe uma letra e fazemos toda a verificação necessária:

System.out.print("\nInforme uma letra -> ");
char letra = s.next().toUpperCase().charAt(0);
// aqui, utilizamos nosso método para verificar se a letra já foi utilizada
if (verificaLetra(letra, letrasUtilizadas)) {
    // aqui, colocamos a letra digitada em nosso vetor de letras utilizadas
    letrasUtilizadas[proxPos] = letra;
    // indicamos a proxima prosição
    proxPos++;
    acertou = false; // precisamos colocar false, pois ainda não sabemos se ele acertou a letra
    // neste laço, fazemos a verificação
    for (int i = 0; i < palavraVetor.length; i++) {
        if (letra == palavraVetor[i]) {
            exibePalavra[i] = letra;
            acertou = true; // se ele acertou, então é colocamos verdadeiro
        }
    }
   // aqui montamos nossa lógica para caso ele tenha acertado
    if (acertou) {
        System.out.println("Acertou a letra!");
        System.out.println("\nFormação atual da palavra:");
        // neste laço, percorremos o vetor 'exibir palavra', para mostrar como está nossa formação
        for (int i = 0; i < exibePalavra.length; i++)
            System.out.print(exibePalavra[i] + " ");
       // verificamos se ele ganhou, com um método também criado por nós
        if (ganhou(exibePalavra)) {
            System.out.println("\n\nVocê ganhou !!!!!\nA palavra é : " + palavra.toUpperCase());
            break;
        }
    } else {
        System.out.println("Errou!");
        tentativas++; // incrementamos nossas tentativas
        if (tentativas == 7) {
            System.out.println("\nVocê perdeu!!!!");
            break;
        } else {
            System.out.println("Você tem " + (7 - tentativas) + " tentativas.");
        }
    }

} else {
    System.out.println(" >>> LETRA JÁ UTILIZADA <<< ");
}

Basicamente é isso. O código fica meio grande e não muito bonito, mas é uma das maneiras de se fazer.


Código completo (GRANDE):

import java.util.*;

public class Forca {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String palavra = "GRUPO";
        // criando vetor de caracteres com a palavra 'grupo'
        char[] palavraVetor = palavra.toUpperCase().toCharArray();
        // criando um vetor de letras acertadas (nosso alfabeto tem 26 letras)
        char[] letrasUtilizadas = new char[26];
        // alguns controladores
        int fase = 0, proxPos = 0, tentativas = 0;
        boolean acertou = false;
        // criando vetor para mostrar a formação da palavra
        char[] exibePalavra = new char[palavraVetor.length];
        for (int i = 0; i < exibePalavra.length; i++)
            exibePalavra[i] = '_';

        // iniciando o jogo
        while (true) {
            // mostrando uma dica
            if (fase == 0) {
                System.out.println("A palavra possui " + palavra.length() + " letras.");
                for (int i = 0; i < exibePalavra.length; i++) {
                    System.out.print(exibePalavra[i] + " ");
                }
                System.out.println();
                fase = 1;
            }

            System.out.print("\nInforme uma letra -> ");
            char letra = s.next().toUpperCase().charAt(0);
            // aqui, utilizamos nosso método para verificar se a letra já foi utilizada
            if (verificaLetra(letra, letrasUtilizadas)) {
                letrasUtilizadas[proxPos] = letra;
                proxPos++;
                acertou = false;
                for (int i = 0; i < palavraVetor.length; i++) {
                    if (letra == palavraVetor[i]) {
                        exibePalavra[i] = letra;
                        acertou = true;
                    }
                }
                if (acertou) {
                    System.out.println("Acertou a letra!");
                    System.out.println("\nFormação atual da palavra:");
                    for (int i = 0; i < exibePalavra.length; i++)
                        System.out.print(exibePalavra[i] + " ");
                    if (ganhou(exibePalavra)) {
                        System.out.println("\n\nVocê ganhou !!!!!\nA palavra é : " + palavra.toUpperCase());
                        break;
                    }
                } else {
                    System.out.println("Errou!");
                    tentativas++;
                    if (tentativas == 7) {
                        System.out.println("\nVocê perdeu!!!!");
                        break;
                    } else {
                        System.out.println("Você tem " + (7 - tentativas) + " tentativas.");
                    }
                }

            } else {
                System.out.println(" >>> LETRA JÁ UTILIZADA <<< ");
            }
        }
    }

    public static boolean verificaLetra(char a, char v[]) {
        for (int i = 0; i < v.length; i++) {
            if (a == v[i])
                return false;
        }
        return true;
    }

    public static boolean ganhou(char[] v) {
        for (int i = 0; i < v.length; i++) {
            if (v[i] == '_')
                return false;
        }
        return true;
    }
}

É isso, qualquer dúvida comenta ai :smiley:


Saída do código:

A palavra possui 5 letras.
_ _ _ _ _ 

Informe uma letra -> k
Errou!
Você tem 6 tentativas.

Informe uma letra -> g
Acertou a letra!

Formação atual da palavra:
G _ _ _ _ 
Informe uma letra -> o
Acertou a letra!

Formação atual da palavra:
G _ _ _ O 
Informe uma letra -> p
Acertou a letra!

Formação atual da palavra:
G _ _ P O 
Informe uma letra -> u
Acertou a letra!

Formação atual da palavra:
G _ U P O 
Informe uma letra -> r
Acertou a letra!

Formação atual da palavra:
G R U P O 

Você ganhou !!!!!
A palavra é : GRUPO