STREAMS (FLUXOS) EM JAVA uma Introdução

Transcrição

1 STREAMS (FLUXOS) EM JAVA uma Introdução Miguel Jonathan DCC-IM/UFRJ (rev. maio 2010) A palavra stream em inglês significa um "fluxo de água", como um riacho. A idéia que transmite é de algo fluindo continuamente, de uma fonte de origem para um local de destino. Em Java, streams são objetos que permitem obter dados de algum fluxo de entrada ou enviar dados para algum fluxo de saída, usando um protocolo básico comum. Essas fontes e destinos podem ser arquivos de disco, áreas da memória (buffers) conexões de rede, assim como os tradicionais arquivos padrão de entrada (teclado) e saída (monitor de vídeo e impressora). A linguagem Java trabalha com um conjunto de mais de 50 classes de stream diferentes. Mas todas derivam (estendem) as classes abstratas básicas abaixo descritas. Essa estrutura de classes torna a linguagem muito flexível, mas ao mesmo tempo requer um estudo aprofundado, para tirar proveito dessa variedade. Neste texto introdutório, veremos apenas as classes básicas mais usadas. Todas pertencem ao pacote java.io. As classes abstratas básicas para leitura e escrita de bytes são: InputStream e OutputStream. Elas são úteis para ler fluxos de dados binários, imagens, etc. Os seus métodos não permitem trabalhar com conceito de linhas, nem reconhecem caracteres especiais. As classes abstratas básicas para leitura e escrita de caracteres Unicode são Reader e Writer. Elas são úteis para trabalhar com texto, e convertem automaticamente caracteres de fim de linha entre sistemas operacionais diferentes. Essas classes não são instanciáveis, mas fornecem o protocolo comum para todas as demais subclasses concretas, que são usadas para diversos meios de entrada e saída, e diversas formas de leitura e escrita de dados. ATENÇÃO: praticamente todos os métodos das classes de stream lançam exceções verificáveis, do tipo IOException ou sub-classe desta. Para usar esses métodos é obrigatório usar blocos try-catch ou o método declarar explicitamente que pode lançar exceção, usando a cláusula throws no cabeçalho. InputStream (métodos de instância) Possui um método abstrato read() que é implementado nas subclasses, para ler 1 byte da entrada. Os demais métodos são concretos, e os mais usados são apresentados abaixo. Procure verificar na API. public int available() throws IOException Retorna o número de bytes que podem ser lidos (ou pulados) desse InputStream sem bloqueio pela próxima chamada de um método para esse input stream. public void close() throws IOException Fecha o receptor da mensagem (ele não poderá mais ser usado para leitura) e libera os recursos do sistema operacional associados a ele. public void mark(int readlimit) Marca a posição corrente deste InputStream. public boolean marksupported() Testa se o receptor suporta os métodos mark e reset. public int read() throws IOException Retorna o próximo byte da entrada, ou 1 se o fim do fluxo de entrada foi alcançado. Note que para obter o retorno como byte é preciso usar um cast pois o tipo de retorno é int. Esse método é abstrato, e precisa ser implementado nas classes concretas. public int read(byte[] b) throws IOException Lê do fluxo de entrada no máximo um número de bytes igual ao tamanho do buffer b (b.length). Retorna o número de bytes lidos ou 1 se não houver bytes disponíveis. Os bytes são lidos para b[0], b[1], etc. public int read(byte[] b, int inicio,int max) throws IOException Lê do fluxo receptor no máximo max bytes para o vetor de bytes b, iniciando na posição inicio. Ou seja, se

2 houverem 0 < k <= max bytes disponíveis para leitura, eles serão lidos para as posições b[inicio], b[inicio+1],..., b[inicio+k-1]. O método retorna o número de bytes lidos, ou 1 caso não haja nenhum byte disponível para leitura (fim-de-arquivo). Esse método pode lançar uma exceção da classe IndexOutOfBoundsException se as expressões de índices ultrapassarem os limites do vetor. public void reset()throws IOException Reposiciona a stream para a posição no momento em que o método mark foi chamado pela última vez nesta input stream. public long skip(long n) throws IOException Ignora os n primeiros bytes de dados desta stream de entrada. Para maior eficiência, usa-se o método available() para saber quantos bytes estão disponíveis para leitura, e então lê-se todos para um buffer de tamanho suficiente com read (byte[]). Por exemplo, se input for uma (sub-classe) de InputStream: int bytesdisponiveis = input.available(); if (bytesdisponiveis > 0) { byte[] buf = new byte[bytesdisponiveis]; input.read(buf); Recomenda-se fechar o fluxo depois de usá-lo, para liberar os recursos alocados pelo sistema operacional. Para isso, enviar ao fluxo a mensagem close(): Ex: input.close(); OutputStream Essa é a classe abstrata raiz de todas as classes que fornecem o serviço de escrita de bytes em um fluxo de saída. public void close() throws IOException Fecha o fluxo de saída receptor da mensagem (ele não poderá mais ser usado nem reaberto) e libera os recursos do sistema operacional associados a ele. Se houver bytes ainda no buffer, eles serão descarregados na saída antes de fechar o fluxo. O método da classe OutputStream não faz nada. Ele é redefinido em cada uma das subclasses concretas. public void flush() throws IOException Descarrega os bytes que estejam no buffer do fluxo na saída associada. public void write(byte[] b) throws IOException Escreve todos os bytes do vetor b bytes no fluxo receptor da mensagem. Equivale a chamar o método write (b, 0, b.length). public void write(byte[] b, int inicio,int n) throws IOException Escreve n bytes do vetor de bytes b, iniciando na posição inicio, no fluxo receptor da mensagem. Ou seja, serão escritos os bytes b[inicio], b[inicio+1],..., b[inicio+n-1] Esse método pode lançar uma exceção IndexOutOfBoundsException se as expressões de índices ultrapassarem os limites do vetor. public void write(int b) throws IOException Escreve o byte menos significativo (posições 0 a 7) do argumento (que é um int) no fluxo receptor da mensagem. Os demais 24 bits do argumento são ignorados. Esse método é abstrato, e precisa ser implementado nas subclasses concretas. Recomenda-se fechar o fluxo de saída depois de usá-lo, para liberar os recursos alocados pelo sistema operacional e forçar a descarga de quaisquer bytes que tenham ficado retidos no buffer. Para isso, enviar ao fluxo a mensagem close(): Ex: output.close(); Os métodos acima podem lançar uma IOException se ocorrer algum erro na escrita dos dados, em particular se o fluxo de saída tiver sido fechado. Também podem lançar uma NullPointerException se a referência ao vetor b for nula.

3 Reader e Writer São as classes abstratas das quais descendem as diversas classes especializadas para ler e escrever fluxos de caracteres Unicode. Protocolo básico: Method Summary - Reader void close() Closes the stream and releases any system resources associated with it. void mark(int readaheadlimit) Marks the present position in the stream. boolean marksupported() Tells whether this stream supports the mark() operation. int int read() Reads a single character. int read(char[] cbuf) Reads characters into an array. read(char[] cbuf, int off, int len) Reads characters into a portion of an array. int read(charbuffer target) Attempts to read characters into the specified character buffer. boolean ready() Tells whether this stream is ready to be read. void reset() Resets the stream. long skip(long n) Skips characters. Method Summary - Writer Writer append(char c) Appends the specified character to this writer. Writer append(charsequence csq) Appends the specified character sequence to this writer. Writer append(charsequence csq, int start, int end) Appends a subsequence of the specified character sequence to this writer. void close() Closes the stream, flushing it first. void flush() Flushes the stream. void write(char[] cbuf) Writes an array of characters. void write(char[] cbuf, int off, int len) Writes a portion of an array of characters. void write(int c) Writes a single character. void write(string str) Writes a string. void write(string str, int off, int len) Writes a portion of a string. Subclasses para ler/gravar arquivos:

4 Para ler e gravar arquivos texto, usamos as classes FileReader e FileWriter. Essas classes lêem um caractere a cada vez, o que é ineficiente. Normalmente vamos querer ler/escrever linhas inteiras. Linhas são seqüências de caracteres terminadas por uma marca de fim de linha, que é em geral o caractere newline ('\n'). Para ler uma linha de cada vez, usa-se o método readline() da classe BufferedReader. Para criar um objeto dessa classe, passa-se para o seu construtor uma instância de alguma classe básica, como FileReader. O exemplo abaixo mostra como ler dados de um arquivo texto de nome "arquivo.txt" que está no mesmo diretório que o programa: FileReader reader = new FileReader("arquivo.txt"); BufferedReader br = new BufferedReader(reader); String linha; while ((linha=br.readline())!= null) { etc. A cada execução de br.readline() uma nova linha será retornada na forma de uma String. Quando não houver mais linhas, o método retorna null (e não uma String vazia, cuidado!). Gravando linhas em um arquivo texto Para gravar linhas em um arquivo texto, usamos um BufferedWriter, para evitar gravar caractere a caractere. Nesta classe, não há um correspondente método writeline(). Em vez disso, há o método write(string linha, int deslocamento, int numchars); Esse método grava no arquivo uma linha contendo os numchars caracteres da String linha, a partir da posição deslocamento. Portanto, para gravar uma linha com a String toda, devemos escrever: write (linha, 0, linha.length()); A gravação não inclui a marca de fim de linha. Para colocá-la pode-se usar o método newline(), ou colocar direto o caratere newline com write('\n'); IMPORTANTE: o método write() de BufferedWriter escreve para um buffer da memória, e só quando ele fica cheio é que os caracteres são transmitidos para o arquivo. É preciso forçar a gravação com flush(), caso contrário nada será realmente gravado. O método close() fecha o fluxo. Deveria forçar um flush, mas não o faz. No exemplo a seguir, todas as strings de um vetor de Strings serão gravadas, linha a linha, em um arquivo. String[] v = {"aaa", "bbbb", "ccccc"; BufferedWriter bw = new BufferedWriter (new FileWriter("arquivo.txt")); for (int i=0; i< v.length(); i++){ bw.write(v[i], 0, v[i].length()); bw.newline();// grava uma marca de fim de linha bw.flush(); //descarrega o conteudo do buffer da memoria no arquivo bw.close(); Um programa exemplo completo O programa abaixo, na primeira parte, lê um arquivo texto qualquer do disco, e imprime na console um máximo de 10 linhas (ou menos se não houver tantas linhas).

5 Na segunda parte, um vetor de ints com valores aleatórios entre 0 e 999 é construído. O conteúdo desse vetor é gravado em um arquivo (binário, não texto) no disco. Depois o arquivo é lido de novo para um outro vetor de ints na memória: import java.io.*; import java.util.random; public class TestaStreams{ public static void main (String[] args) throws IOException{ //Lendo e imprimindo no maximo 10 linhas de um arquivo-texto para a console: FileReader reader = new FileReader("c:\\testeStream.txt"); BufferedReader br = new BufferedReader(reader); String linha; int linhaslidas=0; while ((linha=br.readline())!= null && linhaslidas<=10){ System.out.println(linha); linhaslidas++; //Gravando um vetor de ints e lendo mais tarde: int[] v = new int[100]; int i; // Cada posicao do vetor recebe um int aleatorio entre 0 e 999 Random gen = new Random(); for(i=0; i<100; i++) v[i] = gen.nextint(1000); FileOutputStream fos = new FileOutputStream("vetInteiros.dat"); DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(fos)); for (int n:v) dos.writeint(n); //obs: usando foreach com vetor dos.flush(); //necessario se usar BufferedOutputStream // Criando uma stream de leitura para dados, nao bufferizada nesse caso: DataInputStream dis =new DataInputStream(new FileInputStream("vetInteiros.dat")); // Criando uma area na memoria para receber os ints do arquivo. // O tamanho do vetor vai acomodar exatamente o no. de ints disponiveis no arquivo: int bytesdisponiveis = dis.available(); System.out.println("No. de bytes disponiveis para leitura = "+ bytesdisponiveis); int[] v2 = new int[bytesdisponiveis/4]; // lendo os inteiros um a um, do arquivo para a memoria (vetor v2): for(i=0; i<v2.length; i++) v2[i] = dis.readint(); //obs: usando aqui for classico //imprimindo na tela o conteudo de v2, 20 numeros por linha: for(i=0; i<v2.length; i++){ System.out.print ("" + v2[i] + " "); if((i+1)%20==0) System.out.println();