Lendo e processando informações do teclado usando Java

(Last Updated On: 27 de setembro de 2017)

Fomos contratados para desenvolver um software em Java para uma empresa e a instalação do nosso programa é feita via console.

Para conseguir usufruir do nosso produto o usuário precisa ler e aceitar os termos de uso, caso contrário não podemos permitir que a instalação continue.

Além disso, para estatísticas internas da empresa, após aceitar os termos o usuário também deve nos informar seu nome completo.

Vamos então começar criando a funcionalidade do usuário poder aceitar ou não os termos de uso do nosso produto.

Após a criação, testamos e obtivemos o seguinte resultado:

Eita, como assim? O programa não nos deixou responder, simplesmente considerou que aceitamos os termos de uso e finalizou a instalação. E agora?

Precisamos que o programa, ao chegar na pergunta “Você concorda com os termos?”, espere por uma resposta do usuário e a processe de forma que, caso seja ‘S’ termine de instalar o programa, caso seja ‘N’ interrompa a instalação. Como fazer isso com Java?

Classe Scanner

Antigamente, fazer essa operação de ler informações era bem complexa. Vendo o quão recorrente essa funcionalidade era requisitada pelos desenvolvedores foi criada a classe Scanner, que tem como objetivo ler informações dentro do Java de forma mais fácil.

“Beleza cara, entendi, agora me mostre o código!”

Lendo entrada do teclado com a classe Scanner

Para usar a classe Scanner o primeiro passo é instância-la:


mensagemDeTermos();
new Scanner();
completaInstalacao();

Note que a instanciamos logo após o método que chama a mensagem de termos de uso do nosso software e antes do método que completa a instalação, pois precisamos que o usuário primeiro leia os termos antes de aceitá-los.

Ao fazer isso recebemos um erro de compilação.

O Scanner precisa saber de onde virão as informações, mas em nenhum momento informamos isso. No nosso caso precisamos que o usuário digite as entradas para que sejam lidas, ou seja, as informações virão do teclado.

Para informar que usaremos o teclado, vamos adicionar o parâmetro System.in. Ficando com o seguinte resultado:


new Scanner(System.in);

Agora que temos a instância, vamos atribuí-la para um objeto chamado leitor, pois é boa prática atribuirmos nomes que fazem referência ao objetivo do nosso objeto. Nosso Scanner nada mais é do que um leitor de entradas.


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
completaInstalacao();

Agora que temos nosso leitor, qual o próximo passo? Ler as entradas, certo? Para isso usaremos o método next(). Este método lê a próxima entrada do usuário.


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
leitor.next();
completaInstalacao();

Pronto, agora nosso leitor foi atribuído a um objeto e usamos o método next() para pedir ao usuário que ele digite uma resposta. Vamos testar:

Veja que ele espera a nossa resposta antes de finalizar a instalação. Dando continuidade ao teste, vamos aceitar os termos:

Tudo funcionando, nosso programa aguardou a resposta do usuário e instalou o software, dada a resposta positiva.

Mas e se fosse “não”? Isto é, e se o usuário não concordasse com os nossos termos? O que aconteceria? Vamos testar e conferir:

O resultado esperado não era esse, não é mesmo? Para qualquer que seja a resposta do usuário, nosso software está finalizando a instalação…

Se pararmos para pensar, estamos apenas recebendo a resposta, não estamos processando-a. Em outras palavras, não estamos verificando se a resposta é ‘S’ ou ‘N’, logo, independente da resposta o método completaInstalacao() é chamado.

Para resolvermos essa situação vamos primeiro atribuir a resposta do nosso usuário a uma variável para não perder a entrada lida pelo nosso leitor:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.next();
completaInstalacao();

Hmm… já está melhor, mas isso ainda não resolveu nosso problema, ainda temos que processar a informação recebida, pois nosso programa não é mágico, precisamos mostrar pra ele qual direção seguir, ou seja, se ele continua a instalação ou não.

Para verificar a resposta, vamos criar uma condição que vai comparar se a resposta é ‘S’ para que seja concluída a instalação. Como queremos comparar dois objetos, podemos usar o método equals, que faz exatamente isso:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.next();
if("S".equals(resposta)){
    completaInstalacao();
}

Ao olhar o código, pode não parecer natural chamar o método equals a partir de uma string hard coded, mas fazer isso é uma boa prática, pois temos certeza que a string ‘S’ não é nula, logo nos prevenimos contra NullPointerException.

Pronto, vamos testar e ver se tudo está funcionando:

Com a resposta sendo positiva nosso programa funciona. Isso já acontecia antes de alterarmos o código, mas e se recebêssemos uma resposta negativa? Ou seja, o que aconteceria se o usuário não concordasse com os termos? Vamos ver:

Nada acontece! Nosso software termina a execução e o usuário fica sem entender absolutamente nada. O problema, no caso, foi que só ensinamos o nosso software a processar o ‘S’, ou seja, precisamos fazer o mesmo caso a resposta seja ‘N’.

Então vamos criar outra condição para caso a resposta seja negativa:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.next();
if("S".equals(resposta)){
    completaInstalacao();
} else if("N".equals(resposta)){
    cancelaInstalacao();
}

Pronto, vamos testar para validar o novo comportamento que criamos:

Isso ai! Mais uma funcionalidade feita. Mas e se o usuário responder algo diferente de ‘S’ ou ‘N’? Por exemplo responder usando “s”,”n”,”sim”,”não” ou algo assim, o que acontece? Vamos ver:

Vish, ele nem sequer enviou uma resposta, imagine a cara do usuário ao ver isso? Bem confusa, né?

Precisamos enviar uma resposta caso a entrada seja diferente de ‘S’ ou ‘N’, então adicionaremos mais uma condição no nosso código. Podemos resolver essa situação da seguinte maneira:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.next();
if("S".equals(resposta)){
    completaInstalacao();
} else if("N".equals(resposta)){
    cancelaInstalacao();
}else{
    System.out.println("Resposta inválida");
}

Pronto, agora teremos uma resposta para qualquer entrada que o usuário digitar. Vamos ver se isso realmente funciona:

Boa, funcionou! Uhul, mas nosso código ficou meio feio, né? O ideal seria jogar nossa lógica de validação (os if‘s) dentro de um método e apenas chamá-lo, inclusive é uma boa prática fazer isso.

Para fazer essa refatoração, primeiro criaremos um método e jogaremos toda nossa lógica de validação de resposta dentro dele:


public static void validaResposta(String resposta) {
    if ("S".equals(resposta)) {
        completaInstalacao();
    } else if ("N".equals(resposta)) {
        cancelaInstalacao();
    } else {
        System.out.println("Resposta inválida");
    }
}

Agora vamos apenas chamar esse método:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.nextLine();
validaResposta(resposta);

Caso queira saber mais sobre refatoração, código limpo e etc, deixarei o link de um post que trata exatamente sobre esse assunto, vale a pena dar uma olhada.

Agora que já conseguimos implementar a primeira feature que consistia em receber uma resposta do usuário para aceitação ou não dos termos de uso, vamos para a segunda parte, no caso, implementar uma função para receber o nome do nosso usuário.

Começaremos pedindo ao usuário para nos fornecer seu nome, mas antes de implementar tal funcionalidade, vamos pensar: Onde devemos escrever esse código?

Faz sentido pedir o nome do usuário que digitou ‘N’ ou o usuário que digitou uma resposta inválida? Não, né? Logo, nosso programa só deve perguntar o nome para os usuários que digitaram ‘S’, portanto, devemos codificar essa nova funcionalidade dentro do bloco if onde a condição verifica se a resposta é igual a ‘S’.

Agora sim podemos implementar esse código. Como estamos fora do escopo do nosso leitor teremos que instancia-lo novamente, já que só o usaremos uma vez podemos instanciar a classe Scanner e já chamar o método que queremos, no caso o next(), e já salvar em uma variável. Por enquanto nada novo né?

Logo, dentro de validaResposta(), teremos o seguinte código:


public static void validaResposta(String resposta) {
    if ("S".equals(resposta)) {
        completaInstalacao();
        solicitaNome();
        String nome = new Scanner(System.in).next();
    }
    //resto do código
}

Repare no nosso resultado:

Funcionou, conseguimos tanto aceitar os termos quanto informar nosso nome.

Dias depois, nosso chefe veio reclamar de um bug no software. Aparentemente só estava sendo salvo a primeira palavra do nome e não o nome completo.

Para testar vamos imprimir a variável nome (não esqueça de remover essa linha de código após os testes) e ver o que realmente está sendo armazenado.


public static void validaResposta(String resposta) {
    if ("S".equals(resposta)) {
        completaInstalacao();
        solicitaNome();
        String nome = new Scanner(System.in).next();
        System.out.println("Nome digitado: " + nome);
    }
    //resto do código
}

Agora só falta testar:

Eita, o bug é real! O nome digitado foi “Mario Alvial”, mas nosso programa só considerou a primeira palavra, quando, na verdade, queríamos que ele lesse todas as palavras que o usuário digitasse.

Se olharmos a documentação da classe Scanner, o método next() lê apenas, e somente apenas, a próxima entrada, por isso, se o usuário tiver um nome composto, não vamos conseguir o resultado esperado.

Para resolver tal problema podemos usar outro cara da classe Scanner.

O método nextLine

Precisamos de um cara que leia a linha inteira e esse cara é o método nextLine(). Sendo bem técnico, ele pula a linha que está e lê tudo o que foi pulado. Vamos lá!


public static void validaResposta(String resposta) {
    if ("S".equals(resposta)) {
        completaInstalacao();
        solicitaNome();
        String nome = new Scanner(System.in).nextLine();
        System.out.println("Nome digitado: “ + nome);
    }
    //resto do código
}

Agora nos resta testar:

Opa calma aí, nosso programa passou batido pela pergunta, o que aconteceu? Ao invés de consertarmos o bug só o pioramos.

Após ler novamente a documentação (javadoc sempre salvando) consegui entender o problema. Vamos destrinchar esse erro.

O método next() é o culpado da situação, como já foi falado ele lê a próxima entrada e só. Nessa linha, onde o usuário aceita os termos, temos duas entradas a ser lidas.

“Tá doido? Só tem uma, ou é ‘S’ ou é ‘N’”

Concordo, só tem uma entrada visível a ser lida, mas após a resposta do usuário temos uma quebra de linha certo? Essa quebra de linha é representada por \n, que nada mais é do que uma sequência de escape para o compilador, isto é, quando o compilador vê o \n ele pula para a próxima linha.

Então, esse \n não foi lido pelo next() e ficou para ser lido pelo nextLine() que vem em seguida, logo o nextLine() lê o resto da linha vazia e termina a execução do nosso programa, ele nem sequer chega a ler o nome.

Para exemplificar melhor vou mostrar com um desenho de qualidade:

Para resolver isso precisamos fazer com que o resto da linha onde o usuário aceita ou não os termos seja lida antes de chamarmos o nextLine() para receber o nome.

Podemos abordar essa situação de duas formas:

Adicionando um nextLine() logo após o next() para que após a primeira resposta do usuário o nosso leitor já seja posicionado na linha seguinte, deixando nosso código desse jeito:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.next();
leitor.nextLine();
validaResposta(resposta);

Vamos testar e ver se realmente essa abordagem funciona:

Boa, agora sim, funcionou perfeitamente.

Outra abordagem seria eliminar o mal pela raiz, substituindo o nosso método next() pelo nextLine(), ficando assim:


mensagemDeTermos();
Scanner leitor = new Scanner(System.in);
String resposta = leitor.nextLine();
validaResposta(resposta);

Novamente, vamos testar e ver se conseguimos o resultado esperado:

Tudo certo aqui também. Nos dois casos, temos o mesmo resultado, mas a primeira abordagem não é recomendada, pois estamos usando um método a mais sem necessidade. Com a segunda abordagem nosso método fica mais limpo.

Parabéns!!! Conseguimos criar todas as funcionalidades pedidas e “blindamos” nossa aplicação contra cenários problemáticos que podem surgir durante o uso do nosso software.

Eai, já teve problemas em receber entradas dos seus usuários? Compartilhe sua experiência aqui nos comentários.

Expandindo seu conhecimento sobre a classe Scanner

Além de usarmos a classe Scanner para ler entradas do teclado, podemos usar também para ler arquivos externos. Para saber mais a respeito acesse esse post onde é mostrado como ler e processar arquivos externos usando a classe Scanner.

Aprenda outras funcionalidades bem úteis para o seu dia a dia na Carreira Desenvolvedor Java, onde você vai aprender técnicas tanto básicas quanto avançadas para criar suas aplicações.

Fique por dentro

  • Pedro Figueiredo

    Ótimo artigo, uma perfeita e clara abordagem do assunto, facilitado o estudo da implementação do scanner .
    Parabéns e obrigado pelo desempenho Alvial.

Próximo ArtigoAcessibilidade na Web