Ferramentas de Utilizador

Ferramentas de Site


dev_geral:java:lercmdinput

Ler a partir do Teclado

Apesar de cada vez mais as aplicações serem orientadas para interacções que impliquem o uso de interfaces gráficas, é muito importante o conhecimento de como ler eficientemente dados directamente do teclado, aquando do desenvolvimento de aplicações que usem apenas a consola.

Ler dados da consola, e neste caso do standard input, tem tanto de simples como de complicado :), embora o processo seja simples, nem sempre a formas mais directas nos permitem os resultados desejados. Coisas como detectar introdução de dígitos por parte do utilizador, ou até conversão de caracteres1), podem muitas vezes complicar a estrutura do nosso programa.

No decorrer do tutorial serão apresentadas duas formas genéricas de ler dados, uma usando as streams típicas, outra usando um objecto especifico para a leitura de dados da consola. Nos dois casos as soluções apresentadas poderão ser diferentes de outras soluções já vistas pelo leitor, é necessário ter em consideração que as soluções são apenas algumas das possíveis soluções a implementar.

Ao longo do tutorial iremos falar de streams, buffers, leitura e escrita, sem darmos muitas explicações sobre o que são efectivamente streams e o que significam todos estes termos, aconselha-se a leitura do capítulo Leitura e Escrita, Streams do tutorial de Java caso estes termos sejam desconhecidos.

Streams Standard

Virtualmente todos os sistemas operativos oferecem 3 streams padrão, uma de leitura, mapeada para o teclado, uma de escrita, mapeada para o ecrã, e uma de erros, que também se encontra mapeada para o ecrã. Naturalmente, estes mapeamentos podem ser alterados, e o sistema operativo onde a nossa aplicação esteja a ser executada pode ter algum, ou todos estas streams mapeadas para outros dispositivos. No entanto, vamos assumir que isso não acontece, e que a stream de entrada é o teclado, e a de saída e de erro é o nosso ecrã.

Assim, para acedermos a cada uma destas streams teremos de usar os objectos que o Java nos fornece em System.in, System.out e System.err para leitura, escrita e erros, respectivamente.

Reparem que isto são atributos estáticos da classe System, e embora seja usados sem grande cuidado ou atenção a esse facto, a verdade é que são objectos, tal como qualquer outro objecto que seja instanciado por nós, a diferença principal está no facto de serem instanciados pela plataforma Java, sem que o programador tenha de se preocupar com a sua gestão.

Existem várias classes de leitura de streams, essas classes podem dividir-se entre classes para streams de texto, streams binárias, com buffer ou sem buffer, para o nosso tutorial vamos apenas focar as streams de texto e, embora a leitura de dados do teclados não seja, tipicamente, um processo intensivo a nível de consumo de recursos, vamos usar buffers para optimizar a nossa leitura. Vamos assim, focar o uso de BufferedReader e InputStreamReader.

InputStreamReader é uma classe que nos permite transformar a stream System.in numa stream de texto:

InputStreamReader iReader = new InputStreamReader(System.in));

O que estamos a fazer é criar uma stream de texto com base numa stream binária definida pelo objecto System.in, a partir deste momento, a conversão entre texto e binário é completamente feita pela classe InputStreamReader, e não teremos de fazer conversões manuais.

Mas como falamos, vamos querer usar um buffer, para tornar a leitura algo mais optimizado2):

InputStreamReader iReader = new InputStreamReader(System.in));
BufferedReader bReader = new BufferedReader(iReader);

Podemos condensar o código acima, e formar uma linha que é comum ser vista quando se trabalha com streams3):

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

Como apenas precisamos de um objecto para aceder à stream, e o tipo de objecto define os métodos que temos disponíveis, não nos é útil manter uma referência para a instância de InputStreamReader, dessa forma podemos passar logo para o construtor a nova instância. Embora o código possa parecer mais complicado de ler, é algo simples de perceber se invertermos a ordem e lermos do fim para o início: "Coloca o System.in dentro de uma nova instância de InputStreamReader; pega nessa nova instância e coloca-a dentro de uma nova instância de BufferedReader".

O resultado é um buffer de caracteres, que usar uma stream de caracteres como base, que por sua vez, usa uma stream binária para se apoiar. Todas as conversões necessárias são feitas automaticamente e ganhamos métodos mais úteis que apenas leitura de bytes ou de caracteres, um a um.

Para fazermos algo útil com o código acima teremos de criar mais algum código, neste caso, vamos pedir o nome do utilizador e responder com um simpático "Olá".

public void hello() {
    System.out.println("Como se chama?");
    try {
        String name = reader.readLine();
        System.out.println("nOlá, " + name);
    } catch (IOException ex) {//Neste exemplo apanhamos a excepção aqui...
        System.err.println("Ocorreu um erro ao ler o texto, por favor troque de nome!");
        System.err.println("Motivo:" + ex.getMessage());
        //Não fazemos nada de especial se ocorrer um erro, mas apenas porque é um exemplo simples
        //iremos ver outras situações onde tratamos melhor os erros.
    }
}

Com este pequeno método podemos já ver como é simples ler dados de um teclado4).

Esta forma de ler, apesar de simples, tem como limitação o facto de apenas conseguirmos ler linhas completas, terminadas por n, o terminador de linha de sistema unix, r, o elemento que indica passagem do cursor para o início da linha, e rn o conjunto que permite mudar de linha em sistemas Windows. Assim, a única forma que possuímos de ler dados, é pedir ao utilizador que introduza os valores e pressione em Enter.

Obtemos de retorno uma String, que contém o texto introduzido, excluindo qualquer terminador que tenha sido usado, e que podemos transformar posteriormente. Não temos forma de limitar os dados introduzidos, nem de os validar, e todos os valores serão aceites, mesmo que estejamos à espera de valores numéricos, o utilizador podem sempre introduzir texto.

O uso de streams deste modo força-nos a criar mais código de validação de dados, podendo ser mais completo, no entanto, para leituras simples, ou que não necessitem de muito controlo sobre os dados enquanto estão a ser introduzidos, esta é uma excelente forma de ler dados.

A classe Scanner

A classe Scanner trata os dados através de tokens, dividindo o que o utilizador introduzir e permitindo escolher o que pretendemos ler

A classe Scanner tem como token predefinido o espaço em branco mas isso não nos impede de alterar usando o método useDelimiter() que tanto recebe um pattern como uma string que seria usada como pattern. Como o useDelimiter() devolve a própria distancia de Scanner pode-se fazer um código legível assim:

Scanner s = new Scanner(input).useDelimiter("n---n");

E assim manter um código que funciona e, ao mesmo tempo, mais fácil de ler porque sabemos à partida o delimitador daquele Scanner. O pattern usa a sintaxe do regex (regular expressions) 5) para a separação em tokens do que lê. Isto é só aplicável para o método next(). O Scanner contem vários métodos que usam o next() mas trabalham com código regex pré programados. Isto inclui: nextLine(), nextShort(), nextInt()… O que torna a classe mais útil das incluídas com o java para leitura do que é enviado para o stdin 6) ou para leitura de ficheiros (juntamente com as classes que já foram faladas que o fazem).

A classe Console

Uma alternativa à manipulação de streams será o uso da classe Console.

(…)

1) Devido a algumas razões históricas, as streams padrão de leitura, escrita e erro, são streams binárias e não streams de texto, como se poderia esperar.
2) Essa optimização não será notada nos sistemas actuais, mas é, mesmo assim, uma prática que deve ser sempre seguida.
3) Curiosamente, todas as relacionadas podem ser construídas de forma similar, é possível criar um buffer com uma outra stream que por sua vez usa como base uma stream binária
4) Ignoramos a criação de streams de escrita com buffer, vamos apenas concentrar a nossa atenção em streams de leitura, nos exemplos seguintes usamos sempre o método System.out.println()
5) Regex é quase uma linguagem de programação por si só e permite a pesquisa de informação de uma maneira muito detalhada. Para mais info:http://pt.wikipedia.org/wiki/Regex Não muito completo mas dá para dar noções
6) standard input: Um apontador para o espaço de memória que reflete, por definição, o que é escrito no teclado embora possa ser redirecionado para outra fonte
dev_geral/java/lercmdinput.txt · Esta página foi modificada pela última vez em: 2015/05/16 20:11 por Rui Carlos