Curso JavaIO

Mini Curso Java I/ O
● Sobre Esse Curso
● Introdução ao Java I/O
– Introdução
– O que é um Stream ?
– Dados Numericos
– Dados Caracter
– Resumo
● Escrevendo Streams
– Como Escrever um Stream ?
– Escrevendo Bytes para um Stream de Saída
– Escrevendo um Array de Bytes para um Stream de Saída
– Exercício
– Resumo
● Lendo Streams
– Como ler um Stream ?
– Lendo bytes de um Stream
– Lendo um Array de Bytes de um Stream
– Exercício
– Resumo
● File Streams
– O que é um File Stream ?
– Como escrever um File Stream ?
– Exemplo
– Como ler um File Stream ?
– Exemplo
– Exercício
– Resumo
● Escrevendo Arquivos Texto
– Como escrever um arquivo texto ?
– Exemplo
– Escrevendo arquivos de uma forma mais eficiente
– Exemplo
– Exercício
– Resumo
● Lendo Arquivos Texto
– Como ler um arquivo texto ?
– Exemplo
– Lendo arquivos texto de uma forma mais eficiente
– Exemplo
– Resumo
● Sobre Esse curso
– Esse Mini curso visa introduzir o leitor que não sabe
nada ou muito pouco sobre o pacote java.io, os exemplos
desse curso foram criados e executados tendo como
plataforma o Slackware linux, e o eclipse 3.3 como IDE,
você é livre para escolher um outro sistema operacional
e uma outra IDE, mais note que os exemplos são criados
sob o sistema de arquivos linux, por exemplo, algum
exemplo pode ler algum arquivo que está no diretório
/etc.
– Agora você precisa criar um projeto com o nome javaIO e
um pacote também com o nome javaIO, todos os exemplos
desse curso tem o pacote javaIO como pacote padrão.
– O que é um Stream ?
● Antes que agente veja o que é um stream, vamos nos
questionar o que é I/O, o I significa Input e O
Output, que em português significa entrada e saída,
mais quando se ouve falar em entrada e saída pensase
logo em baixo nível com manipulação de bits e bytes,
o que não deixa de ser verdade, só que não é só isso,
porque tudo é entrada e saída, por exemplo, você está
lendo esse material, isso é entrada, eu escrevi esse
material, isso é saída, você deve está se perguntado
mais o que isso tem haver com o curso de java I/O,
tudo! Se você entendeu o conceito de entrada e saída,
então você já sabe o que é um Stream.
● Se você ainda não entedeu então vou explicar, o que
você está lendo nesse curso é uma letra que forma uma
palavra que forma uma frase e tudo isso formando uma
sequência ordenada, e eu digo ordenada porque se
alguma coisa alterar não vai ser mais a memsa coisa
ela será uma outra coisa, confuso ? Vamos ver um
exemplo, veja a seguinte frase:
Estou estudando java I/O
Se por algum motivo a frase anterior mudase para:
estudando java I/O Estou
Isso quer dizer que alguma coisa está errada, a minha
sequência simplesmente se transformou em outra, na
informática agente diz que aconteceu uma corrupção
dos dados, mais note que dados corrompidos são
simplesmente dados que se transformaram é uma nova
sequência, voltando agora para o curso, na
informática Stream é uma sequência ordenada de bytes.
– Dados Numéricos
● Como descrito antes um Stream é uma sequência
ordenada de bytes, então para que você possa
manipulalos você precisa entender como o Java
manipular os tipos byte, short, int e long.
– byte => é um número de 8 bits que varia em uma
faixa de 128 à 127 em complemento de 2. Se você
não sabe o que é complemento de 2 vou explicar pra
você, é bem simples.
– Digamos que você tenha o número 10 e você quer
saber em binário quanto é 10, então agente faz o
seguinte cálculo:
10 => 00001010
complemento de 1 11110101
complemento de 2 +1
10 => 11110110
– Então nesse exemplo o que agente fez foi achar o
número binário de 10 que foi 00001010 e em seguida
foi feito o complemento de 1 que é simplesmente
inverte os números, onde tem 0 troca por 1 e onde
tem 1 troca por 0, e por último somamos o
complemento de 1 mais 1 e assim é gerado o
complemento de 2 e o nosso número 10, por java
ser baseada em complemento de 2 todos os tipos
numericos em java são sinalizados. Se você quiser
saber mais sobre complemento de 1 ou de 2 ou como
coverter um número decimal para binário procure um
livro de eletrônica digital, quando comecei eu
passava horas e horas brincando com conversão de
números e também com a tabela da verdade e cheguei
até a criar o meu próprio método de verificar a
tabela da verdade de circuitos lógicos.
– short => são números de 2 bytes e estão em uma faixa de
32.768 à 32.767 em complemento de 2.
– int => são números de 4 bytes e estão em uma faixa de
2.147,483,648 à 2.147,483,647 em complemento de 2.
– Long => são números de 8 bytes que vão de
9223372036854775808 até 9223372036854775807 em complemento
de 2
● Nota => perceba que o tamanho para os tipos descritos antes
são simplesmente o intervalo de cada tipo, por
exemplo:
– O tipo int tem 4 bytes de tamanho o que siginifa que 232 é
igual à 2.147,483,648 até 2.147,483,647, para que você ache
esse resultado é preciso fazer um cálculo bem simples,
primeiro você multiplica 4 por 8, porque cada byte contém 8
bits, então, em 4 bytes nós temos 32 bits, depois
multiplique 2 trinta e duas vezes, em seguida divida o
resultado por 2 e acrescente o sinal de menos no início,
formando 2.147,483,648, agora pegue o mesmo resultado da
multiplicação e divida por 2 e subtraia o resultado da
divisão por 1, e você acha 2.147,483,647. Essa mesma regra
vale para os outros tipos, menos para os tipos char, float e
double.
– O programa abaixo mostra como fazer esse cálculo,
copie, cole, compileo e o execute.
package javaIO;
public class Teste {
public static void main(String[] args) {
float x = 2;
long l = 0;
for(int i = 0; i < 31; i++){
x = x * 2;
}//end for
System.out.println("int de "+(l = (long)(x / 2))+" até "+(l =
(long)((x / 2)) – 1 ));
}//end main
}//end class
– Nesse exemplo ele calcula o tipo inteiro, para
calcular os outros tipos basta você acrescentar ou
diminuir a quantidade de voltas do for(), por
exemplo, um byte tem 8 bits, então você troca 31
por 7, 7 porque o loop começa em 0, e se você
contar de 0 até 7 você tem o resultado de 8
voltas.
● Conversão Numérica
– Por padrão todo número declarado em Java é
inteiro, por exemplo:
byte b = 5
short x = 5;
– Essa expressão está correta porque o compilador
Java faz a conversão para você, mais se você
tentar assinar uma variavel inteira para o
exemplo anterior ou se você tentar assinar um
valor menor ou maior que suportado pelo tipo,
você causará um erro de compilação, por exemplo:
int y = 15;
short x = y;
byte b = y;
byte c = 129;
byte c1 = 128;
– Nesse caso para que a expresão esteja correta é
preciso que seja feita uma coerção explícita ou
assinar o valor para um tipo maior.
int y = 15;
byte b = (byte)y;
short x = (short)y;
short c = 129;
short c1 = 128;
– Não sei se você sacou qual é a lógica, então vou
dizer qual é, entenda que um número menor cabe em
um número maior sem precisar de um cast(coerção)
explícito, e número maior não cabe em um número
menor, sendo assim ele precisa de um cast(coerção)
explícita, isso quer dizer que um byte b (byte b =
6;) pode ser assinado para um short s (short s =
b;) sem a necessidade de um cast, mais o inverso
não é verdadeiro. Você já sabe qual dos 4 tipos é
maior, qual é o menor e qual é o maior e menor
entre eles, e você já sabe isso desde que escrevi
sobre cada tipo, um int tem um tamanho de 4 bytes,
um short tem um tamanho de 2 bytes e um byte tem
um tamanho de 8 bits(1 byte).
– Dados Caracter
● Codificação
– Todo programa que manipula texto usa uma
codificação, cada letra, número e simbolos tem um
número mapeado pra ele, por exemplo, os espaço que
você dar no teclado quando está digitado um texto
é mapeado para o número 32 na codificação ASCII,
se você quiser testar abra um edito de texto e
pressione a tecla alt e em seguida mantendo a
tecla alt pressionada digite no teclado numérico
32 e solte a tecla alt, você verá que um espaço
foi inserido. A linguagem Java usa o padrão
UTF16.
● Unicode(UTF16)
– A linguagem Java usa o padrão unicode de 16 bits
conhecido como UTF16, na verdade quando você
escreve o seu fonte em algum editor de texto ainda
você não está usando o padrão UTF16, quem vai
usar esse padrão é o Java, quando você compila o
seu arquivo.java para um arquivo.class o
compilador Java converte o padrão que você usou
para escrever o seu arquivo.java para o padrão
UTF16, o padrão UTF16 é um padrão de 2 bytes, o
que significa que ele tem um tamanho de 2 elavado
a 16, e que vai de 0 até 65535, note que o padrão
UTF16 não é sinalizado.
● Tipo char
– O tipo char é baseado no padrão UTF16, o que
significa que ele tem um tamanho de 2 bytes e que
ele vai de 0 até 65535 não sinalizado, essa é a
quantidade de caracter que o tipo char suporta, na
verdade a codificação ASCII está contido no padrão
UTF16.
● Resumo
– Nesse capítulo você deu os primeiros passos para
conhecer o pacote java.io, nesse capítulo você viu o que
é um Stream, como Java manipula os tipos primitivos
byte, short e int, e viu também um pouco de codificação,
na próxima aula, Escrevendo Streams, é quando a diversão
começa.
– Como Escrever um Stream ?
● Para escrever um Stream você precisará criar um
objeto OutputStream, mais note que você não criará um
referência direta para essa classe, porque ela é uma
classe abstrata, sendo assim, você referenciará o
objeto OutputStream para alguma de suas sub classes.
– Escrevendo Bytes para um Stream de Saída
● A classe OutputStream declara 3 métodos para escrever
um Stream, são eles:
public abstract void write(int b);
public void write(byte b[]);
public void write(byte[] b, int offset,int length;
● O primeiro método é abstrato, sendo assim, a classe
que herdar de OutputStream é quem terá que dar alguma
funcionalida a esse método, vamos ver um exemplo de
como usar esse método.
● Para realizar o exemplo vamos usar a variável de
classe System.out assinada para um objeto
PrintStream, mais antes que possamos escrever o
código, preciso explicar para você o método public
void flush(), esse metodo é usado para forçar a
escrita do stream para a saída, na classe
OutputStream esse método é declarado sem nenhuma
funcionalidade, a declração dele é a seguinte:
public void flush() throws IOException {}
● Como descrito antes, nós vamos usar um objeto do tipo
PrintStream, essa classe herda de OutpuStream
indiretamente através da classe FilterOutputStream,
ao contrário de OutputStream, PrintStream dar uma
funcionalidade para o método flush(), nesse exemplo,
o método flush() vai escrever o stream para a saída
padrão do sistema, shell no GNU/Linux e prompt de
comando no Windows, agora que você já sabe o que o
método flush() faz, vamos fazer o nosso exemplo.
package javaIO;
import java.io.PrintStream;
public class Teste {
PrintStream out = System.out;
out.write(55);
out.flush();
}//end main
}//end class
● Nesse exemplo assinamos para a variável out uma
referência para a saída padrão oferecida pela
variável de classe System.out, em seguida o método
write é invocado, e é passado para ele o inteiro 55,
esse inteiro deve está na faixa de 0 até 255, se for
passado um inteiro menor que 0 ou maior que 255 ele
será resetado e ficará na faixa de 0 até 255, você
pode deixar qualquer número interio menor que 0 e
maior que 255 na faixa de 0 até 255, simplesmente
adicionando a seguinte instrução em seus programas:
int x = 300;
int result = x & 0x000000FF;
● O valor de x pode ser qualquer um, mais o operador &
e o valor 0x000000FF são requeridos, qualquer valor
menor que zero ou maior que 255 que você assine para
a variável x será binariamente resetado para um valor
entre 0 e 255.
● Para concluir essa discursão o que o operador and e o
valor hexadecimal 0x000000FF está fazendo com a
variável x é simplismente multiplicar o valor binário
de x com o valor binário de 0x000000FF.
– Nota => note que o valor hexadecimal 0x000000FF é
equivalente a 256 em decimal, na verdade 255,
porque se conta o zero, e o binário de 255 é
11111111, então a seguinte instrução de código do
exemplo anterior,
int x = 300;
int result = x & 0x000000FF;
poderia ser modificada para:
int x = 300;
int result = x & 255;
– Para ficar mais claro, abaixo mostro uma tabela
que deixa o exemplo anterior mais claro, só
lembrando, 255 é igual a 11111111 em binário e 300
é igual a 100101100.
● Então o esquema fica assim:
11111111
00101100
● Note que o último bit da esquerda do número binário
de 300 foi descartado.

255 300 Saída
1 0 0
1 0 0
1 1 1
1 0 0
1 1 1
1 1 1
1 0 0
1 0 0
– Então a saída da tabela foi 00101100, agora
descartamos os dois últimos bits da esquerda e
formamos 101100 que é igual a 44 em decimal, agora
você pode testar se esse resultado está certo,
basta você substituir o valor 55 no método write
do exemplo que fizemos anteriormente por 300 e
execute o programa, depois anote qual foi o
caraceter que foi impresso, e em seguida troque o
número 300 por 44 e execute o programa, você verá
que o caracter impresso por 300 é o mesmo caracter
que foi impresso por 44, então isso prova tudo que
foi descrito antes, o valor 300 foi binariamente
resetado para 44, um valor que está entre 0 e 255.
● O segundo método write escreve um array de bytes e
será abordado no próximo tópico, e o último método
write recebe 3 argumentos, o primeiro é um array de
bytes b que será escrito, o segundo argumento é a
posição em que devese começar a escrita do array de
bytes b e o último argumento é a quantidade de bytes
que deve ser escrito, você verá como usar esse método
no próximo tópico.
– Escrevendo um Array de bytes para um Stream de
Saída
● Para escrver uma array de bytes para um Stream você
usa um dos dois métodos write mostrado no tópico
anterior, o primeiro método recebe um array de bytes
para escrever o Stream, mais na verdade esse método
invoca o terceiro método com a seguinte assinatura:
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
● Então note que o terceiro método é invocado no
segundo método, e como descrito antes, o terceiro
método recebe um array de bytes b, uma posição em que
deve iniciar a escrita do array de bytes b e o
tamanho de bytes que deve ser escrito, vamos a partir
de agora fazer alguns exemplos de como usar esses
dois métodos.
package javaIO;
import java.io.IOException;
public class WriteByteArray {
String[] str = {"Java 2","Curso JavaME","Mini Curso
JavaIO","JDukes.com"};
byte bytes[] = null;
for(int i = 0; i < str.length; i++){
bytes = str[i].getBytes();
try {
out.write(bytes);
out.println();
out.flush();
} catch (IOException e) {
e.printStackTrace();
}//end catch
}//end for()
}//end main
}//end class
● Nesse exemplo agente viu como usar o método
write(byte b[]), primeiro um array de strings é
criado e povoado, em seguida a variável que conterá o
array de bytes é criada, no laço for() cada elemento
do array de string é convertido para uma array de
bytes e depois esse array é escrito para a saída
padrão, perceba que o método write(byte b[]) pode
causar uma exceção do tipo IOException, note que esse
exemplo foi bem simples, no decorrer do curso você
terá exemplos um pouco mais complexos. Vamos ver
agora como usar o metodo write(byte[] b, int
offset,int length).
package javaIO;
out.println();
out.write(bytes,0,bytes.length);
out.println();
out.flush();
}//end for()
}//end main
}//end class
● Esse exemplo faz a mesma coisa que o anterior, só que
no lugar do método write(byte[] b) estamos usando o
método write(byte[] b, int offset, int length),
nessse exemplo o detalhe em questão é o argumento int
offset e int length, e foi passado 0 e bytes.length,
representando a posição de gravação e a quantidade de
bytes a serem gravados, vamos fazer outro exemplo
alterando a posição de gravação e a quantidade de
bytes a serem gravados.
package javaIO;
out.println();
out.write(bytes,1,bytes.length 1);
out.println();
out.flush();
}//end for()
}//end main
}//end class
● Nesse exemplo a posição de escrita começa em 1,
quando você executar esse programa a primeira letra
de cada palavra será cortada, note que foi preciso
fazer um decremento no tamanho de bytes a serem
escritos, isso quer dizer que se você quiser começar
a escrita na posição 3, então você terá que
decrementar o tamanho em 3, por exemplo, bytes.length
– 3, note que para esse exemplo a implementação do
método write(byte b[], int offset, int length) da
forma que está implementado não é muito boa pra
gente, para terminar esse capítulo vamos fazer a
nossa própria implementação do método write(byte b[],
int offset, int length), para isso vamos herdar de
OutputStream, vamos lá!
package javaIO;
import java.io.OutputStream;
public class WriteByteArray extends OutputStream{
new WriteByteArray().write(bytes,1,bytes.length);
}//end for()
}//end main
public void write(byte[] buf, int off, int len) {
synchronized (this) {
if(off < 0 || off > buf.length || off > len ||
len < 0 || len > buf.length){
throw new IndexOutOfBoundsException();
}//end if
for(;off < len; off++){
try {
write(buf[off]);
}//end catch
}//end for
System.out.println();
}//end synchronized
}//end write()
public void write(int b) throws IOException {
OutputStream out = System.out;
out.write(b);
out.flush();
}//end write
}//end class
● Agora sim, com essa nova implementação do método
write(byte b[], int offset, int length) agente pode
dizer qual a posição de início da escrita do array de
bytes sem ter que fazer um decremento no tamanho de
bytes, o que eu fiz foi simplesmente anular o método
write(byte b[], int offset, int length) e o método
write(int b), bem fácil, não ?
● No método write(byte b[], int offset, int length)
faço uma checagem pra saber se a posição de início de
gravação dos dados ou do tamanho de dados a serem
escritos não vão causar um estouro no index do array,
e por último faço uma interação com o laço for(), no
método write(int b), foi criado um stream de saída
com a variável de classe System.out, e escrevo os
dados para esse stream de saída recém criado.
● Lendo Streams
– Exercício
● Qual método é usado para escrver um array de bytes ?
● Faça um programa que escreva para o console todos os
caracteres ASCII no intervealo de 32 até 255.
● Resumo
– Na aula de hoje você viu como escrever um stream de
bytes além de ter visto como escrever array de bytes
para um stream, você também viu na prática como herdei a
classe OutputStream e como anulei dois métodos dela,
write(int b) e write(byte b[], offset, int length), na
próxima aula você irá aprender como ler do stream, até
lá!
● Lendo Streams
– Como ler um Stream ?
● Para ler um Stream você usa um objeto da classe
abstrata java.io.InputStream ou alguma de suas sub
classes, perceba que a classe java.io.InputStream é a
uma classe abstrata e sendo assim você não pode criar
uma referência direta para ela.
– Lendo Bytes de um Stream
● Para ler um stream você usa algum dos seguintes
métodos:
public abstract int read() throws IOException
public int read(byte[] data) throws IOException
public int read(byte[] data, int offset, int
length) throws IOException
● Lendo Streams
● O primeiro método ler um inteiro na faixa de 0 até
255, o segundo método ler uma array de bytes, o que
esse método faz é ler dados de um stream de entrada e
então o armarzena no buffer passado para o mesmo,
você terá detalhes desse método no próximo tópico.
O terceiro método ler um stream de entrada e então o
armazena em um array de bytes b com uma posição
offset e com o tamanho de bytes a serem gravados.
Você terá mais detalhes sobre esse método no próximo
tópico.
● Vamos ver um exemplo de como usar o método read() que
retorna um inteiro na faixa de 0 até 255.
● Lendo Streams
● Nesse exemplo nós vamos usar o método read() da classe
PrintStream através da variável de classe System.in, da
mesma forma como a variável System.out a variável de
classe System.in é uma referência para a classe
PrintStream, esse exemplo consiste de uma interação com
um laço for(), e essa interação é feita a cada vez que o
usuário digita um caracter no shell(GNU/Linux) ou no
prompt de comando(Windows), e então aperta enter. No
shell ou no prompt de comando você executa a classe
ReadByte coma a seguinte instrução:
Java javaIO/ReadByte
● Se você usa Windows você deve trocar a barra / por barra
invertida \, depois que você digitar o comando e apertar
enter o shell ou o prompt de comando ficará esperando
que você digite um ou vários caracters, e quando você
apertar enter o código ASCII da tecla precionada será
impresso no shell ou no prompt de comando seguida de uma
quebra de linha.
● Lendo Streams
● Agora se você tiver usando o eclipse para compilar e
excutar o exemplo, você só precisa inserir os
caracters no console do eclipse e apertar enter, em
seguida o eclipse imprimirá o código ASCII da tecla
ou teclas pressionada(s) seguida de uma quebra de
linha. A figura 1.0 mostra a execução no shell e a
figura 1.1 mostra a execução no eclipse.
● Lendo Streams
package javaIO;
public class ReadByte {
for(int i = 0; i < 10; i++){
try {
System.out.println(System.in.read());
}//end catch
}//end for
}//end main
}//end class
● Lendo Streams
Fig 1.0
● Lendo Streams
Fig 1.1
● Lendo Streams
– Lendo um Array de Bytes de um Stream
● Como descrito antes, você ler um array de bytes de um
stream com os métodos read(byte b[]) e com o método
read(byte b[], int offset, int length), vamos ver
primeiro o método read(byte b[]) e em seguida o
método read(byte b[], int offset, int length).
● Da mesma forma que o método write(byte b[]) invoca em
seu corpo o método write(byte b[], int offset, int
length), o método read(byte b[]) também invoca um
método em seu corpo com a mesma lista de argumentos,
e esse método é:
● read(byte[] b, int offset, int length), abaixo mostro
a assinatura do método read(byte b[]).
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}

● Lendo Streams
● Como descrito no tópico anterior, o método read(byte
b[], int offset, int length) é usado para ler um
array de bytes começando em uma posição X e com um
tamanho de bytes Y a serem lidos, vamos ver o papel
dessas variáveis passada para o método read(byte b[],
int offset, int lemgth).
● O array de bytes b é onde os dados serão gravados.
● A variável offset é a posição em que devese inciar a
escrita dos dados lidos do stream de entrada no array
de bytes b.
● E a variável length é quantidade de bytes que devem
ser lidos e armazenados no array de bytes b.
– Agora vamos ver exemplos de como usar esses métodos.
● Lendo Streams
package javaIO;
import java.io.FileInputStream;
import java.io.InputStream;
public class ReadByteArray {
public ReadByteArray() {
}
try {
final PrintStream out = System.out;
final InputStream inputStream = new FileInputStream("/etc/named.conf");
● Lendo Streams
final byte[] buffer = new byte[64];
while(true){
int bytesRead = inputStream.read(buffer);
if(bytesRead == 1){
inputStream.close();
out.close();
break;
}//end if
out.write(buffer, 0, bytesRead);
}//end while
} catch (Exception e) {
}//end catch
}//end main
}//end class
● Lendo Streams
Fig 1.2
● Lendo Streams
● Nesse exemplo estou usando a classe FileInputStream
que será abordada no próximo capítulo, sendo assim,
ela será explicada depois, por hora fique avisado que
essa classe recebe como argumento o nome de um
arquivo, e nesse exemplo foi passado o arquivo
named.conf do diretório /etc, tirando essa classe não
tem nada de novo no código, então vou retirar do
fonte o trecho que nos interessa.
while(true){
int bytesRead = inputStream.read(buffer);
if(bytesRead == 1){
out.close();
break;
}//end if
}//end while
● Lendo Streams
● Primeiro foi criado um array de bytes buffer com o
tamanho de 64 slots ou posições, em seguida a variável
bytesRead é criada e é assinada para ela o inteiro
retornado pelo método read(byte[] b), e depois a
variável buffer é pasado para o mesmo, abaixo explico o
que está acontecendo nessa linha e nas outras.
● Lendo Streams
● O metodo read(byte b[]) ler 64 bytes do arquivo
named.conf em seguida esses bytes são gravados na
variável buffer que foi passada para o mesmo, entenda
que o método read não vai ler 64 bytes de vez, ele vai
adicionar byte por byte no array de bytes buffer, até
que o mesmo complete 64 bytes ou até que o final do
arquivo chegue, e depois a quatidade de bytes lidos
retornado pelo método read é gravado na variável
bytesRead, no if o valor do variável bytesRead é
checada, se bytesRead é igual a 1 então o final do
arquivo foi alcançado e os stream de entrada e de saída
são fechados, e a clásula break sai da instrução while,
se a variável bytesRead for diferente de 1 então o
array de bytes buffer é passado para o método write(byte
b[], int offset, int length) junto com a posição de
leitura e quantidades de bytes lidos.
● Lendo Streams
● Nota => perceba que a variável buffer tem um tamanho
de 64 posições, o que significa que ela terá 64 bytes
do arquivo named.conf, mais note tanbém que ela
poderá ter menos bytes, isso ocorre porque nem sempre
vai ter 64 bytes para ler, uma outra coisa que você
também deve perceber é que no método write foi
passado bytesRead que diz a quantidade de bytes que
devem ser gravados, fazer isso é uma boa prática de
programação, porque você garante que só será gravado
a quantidade exata de bytes que está contido na
variável buffer, como disse antes, nem sempre o
método read vai gravar 64 bytes na variável buffer,
para testar o que eu disse adicione a seguinte linha
depois do método write e antes da chave de fechamento
da instrução while, e em seguida execute o programa,
a figura 1.3 mostra o resultado, e em seguida vamos
ao nosso próximo exemplo.
System.out.println(“\n\nbytes lidos == ”+bytesRead);
● Lendo Streams
Fig 1.3
● Lendo Streams
package javaIO;
import java.io.InputStream;
public class ReadByteArray {
public ReadByteArray() {
}
try {
final PrintStream out = System.out;
final InputStream inputStream = new FileInputStream("/etc/named.conf");
● Lendo Streams
while(true){
int bytesRead = inputStream.read(buffer,0,buffer.length);
if(bytesRead == 1){
out.close();
break;
}
}//end while
}//end catch
}//end main
}//end class
● Lendo Streams
Fig 1.4
● Lendo Streams
● Esse exemplo é o mesmo que o anterior, a única
diferença está no método read, agora estamos usando o
método read(byte b[], int offset, int length) e não
mais read(byte b[]), a principal diferença entre
esses dois métodos é que o método read(byte b[], int
offset, int length) nos permite dizer em que posição
os dados lidos vão ser gravados no array de bytes e a
quatidade de bytes que devem ser lidos. Esse método é
muito útil, por exemplo, agente poderia especificar o
tamanho do array em 512 posições, então quando fosse
ler um arquivo de algum host na rede o método read
ficaria assim, read(buffer,0,255), isso porque quanto
menor o buffer mais rápido é a leitura, e se
trantando de uma leitura feita pela rede essa é uma
quantidade de bytes relativamente boa, agora quando
fosse ler um arquivo na máquina local
especificaríamos a quantidade máxima,
read(buffer,0,buffer.length), isso foi feito no nosso
exemplo.
● Lendo Streams
– Exercício
● Qual método é usado para ler um inteiro ?
● Qual método é usado para ler um array de bytes ?
● Faça um programa para ler um array de bytes e depois
escreva esse array para a saída padrão.
● Faça um programa que leia 2 numéros do usuário e em
seguida imprima todos os códigos ASCII nesse
intervalo.
● Resumo
– Na aula de hoje você viu como ler um inteiro e um array
de bytes, com a aula de hoje você já é capaz de escrever
e de ler stream, na próxima aula você verá File Stream,
e verá também exemplos um pouco mais elaborados.
● File Stream
– O que é um File Stream ?
● Você já sabe o que é um Stream e você provavelmente
também já sabe o que é um File(arquivo), então um
File Stream é um arquivo composto de uma sequência
ordenada de bytes. Nos próximos tópicos você verá
como ler e escrever um File Stream.
– Como escrever um File Stream ?
● Antes de começar a escrever e a ler File Streams
preciso escrever para você sobre a classe File, ela é
uma classe chave na hora de manipular arquivos.
● A classe java.io.File nos permite criar, deletá,
manipular arquivos, etc. A classe File declara vários
construtores, mais o contrutor que você mais vai usar
é esse:
public File(String pathname)
● O argumento passado para o construtor File é o nome
de um arquivo ou diretório, vamos ver um exemplo de
como criar e manipular esse objeto File.
● File Stream
package javaIO;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
public class HowToFile {
File file = new File("/etc/named.conf");
System.out.println("Esse arquivo existe ?\nResp => "+(file.exists() ?
"Sim":"Não"));
System.out.println("É um arquivo ou é um diretótio ?\n" +
"Resp => "+(file.isDirectory() ? "Diretório":file.isFile() ?
"Arquivo":"file not found"));
System.out.println(file.exists() ? "Ultima modificação foi no dia "+(new
SimpleDateFormat("dd/MM/yy").format(new Date(file.lastModified())))+"" +
" às "+(new SimpleDateFormat("HH:mm:ss").format(new
Date(file.lastModified()))):"");
}//end main
}//end class
● File Stream
Fig 1.5
● File Stream
● Veja que é muito simples criar e manipular um objeto
File, no exemplo a variável file foi criada e
inicializada com uma referência para o arquivo
/etc/named.conf, nas linhas seguintes a variável file
é usada para manipular essa referência, primeiro é
usado o método file.exists(), se o arquivo named.conf
existe, então um true é retornado se não um false é
retornado, depois os método file.isDirectory() e
file.isFile() são usados para saber se a string
passada para o construtor File é um arquivo ou um
diretório, se for um diretório então é impresso
diretório no terminal, se for um arquivo então é
impresso arquivo no terminal, agora se o aqruivo ou
diretório não existe então é impresso file not found
no terminal, e por último é usado o método
file.lastModifield() para saber a ultime vez que o
arquivo ou diretório foi modificado, note que esse
método retorna um long contendo a data e a hora em
milliseconds.
● File Stream
● Vamos ver o mesmo exemplo só que dessa vez vamos
passar para o construtor File um arquivo que não
existe, a figura 1.6 mostra o resultado, e em seguida
vamos ver a classe java.io.FileOutputStream.
● File Stream
package javaIO;
import java.text.SimpleDateFormat;
import java.util.Date;
public class HowToFile {
File file = new File("/etc/named.conf2");
System.out.println("Esse arquivo existe ?\nResp => "+(file.exists() ?
"Sim":"Não"));
System.out.println("É um arquivo ou é um diretótio ?\n" +
"Resp => "+(file.isDirectory() ? "Diretório":file.isFile() ?
"Arquivo":"file not found"));
System.out.println(file.exists() ? "Ultima modificação foi no dia "+(new
SimpleDateFormat("dd/MM/yy").format(new Date(file.lastModified())))+"" +
" às "+(new SimpleDateFormat("HH:mm:ss").format(new
Date(file.lastModified()))):"");
}
● File Stream
Fig 1.6
● File Stream
● FileOutputStream
– A classe java.io.FileOutputStream é uma subclasse
direta de OutputStream, essa classe nos permite
escrever streams para um arquivo. Para esrcrever
um stream para um arquivo você primeiro cria um
objeto FileOutputStream e em seguida usa algum dos
seguintes métodos:

public native void write(int b) throws IOException
public void write(byte b[]) throws IOException
public void write(byte b[], int off, int len) throws IOException
– Vamos ver como usar esses três método, vamos
seguir a ordem acima.
– Exemplo
● File Stream
package javaIO;
import java.io.FileOutputStream;
public class HowToFileOutputStream {
try {
FileOutputStream fileOutputStream = new FileOutputStream("./ascii.txt");
for(int i = 32; i < 127; i++){
fileOutputStream.write(i);
}//end for
}//end catch
}//end main
}//end class
● File Stream
● Veja que é muito fácil escrever um FileOutputStream,
primeiro foi criada a variável fileOutputStream, e em
seguida a mesma foi incializada com uma referência
para o construtor FileOutputStream, o construtor
FileOutputStream recebe como argumento uma String
representado o nome do arquivo que conterá o stream,
no exemplo foi passada a string “./ascii.txt”, o ./
diz que o arquivo será gravado no diretório atual, e
ascii.txt é o nome do arquivo, note que ./ é
utilizado no sistema de arquivo GNU/Linux ou em
sistemas operacionais que implementam o sistema de
arquivos do mesmo, se você usa o Windows então deve
se trocar o ./ por .\\, o arquivo será gravado no
diretório javaIO, a figura 1.8 mostra o arquivo
ascii.txt, e por último o laço for() escreve cada
caracter da codificação ascii na faixa de 32 até 127
para o arquivo ascii.txt, a figura 1.7, mostra o
resultado.
● File Stream
Fig 1.7
● File Stream
Fig 1.8
● File Stream
● Agora vamos ver um exemplo com o método write(byte
b[]), e em seguida vamos ver o método write(byte b[],
int offset, int length).
● File Stream
package javaIO;
String str = "Mini Curso Java I/O";
try {
fileOutputStream.write(str.getBytes());
}//end catch
}//end main
}//end class
● File Stream
package javaIO;
String str = "Mini Curso Java I/O";
try {
fileOutputStream.write(str.getBytes(),0,str.length());
}//end catch
}//end main
}//end class
● File Stream
● Nos dois exemplos anteriores foi escrito para o
arquivo a string “Mini Curso Java I/O”, como os
métodos write(byte b[]) e write(byte[] b, int offset,
e int length) já foram explicados no capítulo anterior
não tem porque fazelo de novo, a única coisa que vou
fazer é te avisar que os métodos write(byte[] b) e
write(byte b[],int offset, int length) invoca em seu
corpo o método nativo private native void
writeBytes(byte b[], int off, int len) throws
IOException , abaixo mostro a assinatura de write(byte
b[]) e write(byte b[], int offset, int length).

public void write(byte b[]) throws IOException {
writeBytes(b, 0, b.length);
}
public void write(byte b[], int off, int len) throws IOException{
writeBytes(b, off, len);
}
● File Stream
– Como ler um File Stream ?
● Para ler uma File Stream você cria uma referência
para o construtor FileInputStream passando para o
mesmo uma string que representa o arquivo a ser lido,
se você quiser, você pode passar um objeto File como
argumento para o construtor FileInputStream, e para
ler esse arquivo usa algum dos seguintes métodos
read.
public native int read() throws IOException;
public int read(byte b[]) throws IOException
public int read(byte b[], int off, int len) throws
IOException
– Exemplo
● Agora vamos fazer exemplos de como podemos usar esses
3 métodos.
● File Stream
package javaIO;
public class HowToFileInputStream {
try{
FileInputStream fileInputStream = new FileInputStream("ascii.txt");
int c;
while((c = fileInputStream.read()) != 1){
out.write(c);
}//end while
out.flush();
fileInputStream.close();
}catch (Exception e) {
}//end catch
}//end main
}//end class
● File Stream
● Esse é um exemplo bem simples, na criação do objeto
FileInputStream foi passado para o construtor
FileInputStream a string “ascii.txt” representando o
nosso arquivo, esse foi o aqruivo criado
anteriormente nesse capítulo, em seguida foi criada a
variável c que receberá o próximo byte do arquivo ou
1 se for o fim do mesmo, no loop while a variável c
é impressa na saída padrão. Vamos ao próximo exemplo.
● File Stream
package javaIO;
try{
FileInputStream fileInputStream = new FileInputStream("ascii.txt");
byte[] buffer = new byte[50];
while(true){
int bytesRead = fileInputStream.read(buffer);
if(bytesRead == 1){
out.close();
break;
}//end if
out.write(buffer);
}//end while
}//end catch
}//end main
}//end class
● File Stream
● Esse exemplo é mesmo que o anterior, a única coisa
que fizemos foi trocar o método read() por read(byte
b[]), no loop o while, é passado como argumento o
array de bytes buffer, que tem o tamanho de 50 bytes,
como esse método já foi discutido antes, não tem
motivo para discutilo novamente. Vamos ao nosso
último exemplo.
● File Stream
package javaIO;
try{
File file = new File("ascii.txt");
if(!(file.exists()) || !(file.isFile())){
System.err.println("File Not Found or File is not File");
return;
}//end if
FileInputStream fileInputStream = new FileInputStream(file);
byte[] buffer = new byte[50];
while(true){
int bytesRead = fileInputStream.read(buffer, 0, buffer.length);
if(bytesRead == 1){
out.close();
break;
}//end if
}//end while
● File Stream
}//end catch
}//end main
}//end class
● Veja que esse exemplo é parecido com os anteriores,
esse e os outros dois exemplos lêem o mesmo arquivo,
só que nesse exemplo é feita uma checagem que não foi
feita nos exemplos anteriores, essa checagem foi
feita na condicional if e com o objeto file, o obejto
file checa se o arquivo ascii.txt existe, se existe
então o objeto file checa se o arquivo ascii.txt é um
arquivo, se o arquivo não existe ou se ele existe
mais não é um arquivo então uma mensagem é impressa
no terminal e o programa é finalizado, se o objeto
file passar por essa checagem então isso significa
que está tudo certo e o objeto file é passado como
argumento para o construtor FileInputStream,
● File Stream
no loop while o método read(byte b[], int offset, int
length) é usado para ler o arquivo ascii.txt, também
não vou escrever sobre esse método porque já o fiz
antes.
● Nota => tanto o método read(byte b[]) como o método
read(byte b[], int offset, int length) invoca em seu
corpo o método private native int readBytes(byte b[],
int off, int len) throws IOException, abaixo mostro a
assinatura do método read(byte b[]) e read(byte b[],
int offset, int length).
public int read(byte b[]) throws IOException {
return readBytes(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
return readBytes(b, off, len);
}
● File Stream
– Exercício
● O que é um File Stream ?
● Leia um arquivo e o escreva para o terminal
● Faça um programa que copie um arquivo da origem A
para um destino B.
● Resumo
– Na aula de hoje você viu como ler e escrever File
Stream, agora você já está pronto para ler, escrever e
copiar arquivos, na próxima aula você vai aprender como
escrever arquivos textos, ou seja, escrever arquivos
como se você estivese escrevendo em algum editor de
texto.
– Como escrever um arquivo texto ?
● Para escrever um arquivo texto usase a classe
java.io.FileWriter, essa classe herda indiretamente
da classe abstrata java.io.Writer, a classe Write e
suas subclasses nos permite escrever stream de
caracter. Para escrever um stream de caracter criase
uma referência para a classe FileWriter e em seguida
escrevese um stream de caratcer com algum do
seguintes métodos:
public void write(int c) throws IOException
public void write(char cbuf[]) throws IOException
public void write(char cbuf[]) throws IOException
public void write(char cbuf[], int off, int len) throws
IOException
public void write(String str, int off, int len) throws
IOException
● A classe FileWriter herda todos esse métodos da
classe java.io.OutputStreamWriter, e essa classe
herda da classe Writer.
● Em outras palavras a classe FileWriter não declara
nenhum método, ela só declara construtores, a classe
OutputStreamWriter é quem anular os métodos herdados
da classe Writer, vamos agora ver exemplos como
escrever um arquivo texto.
● Exemplos
package javaIO;
import java.io.FileWriter;
public class WriteFileText {
try {
File file = new File("./FileWriter.txt");
FileWriter fileWriter = new FileWriter(file,true);
fileWriter.write("\tJava.io");
fileWriter.write("\nEsse é o meu primeiro exemplo" +
" usando a classe FileWriter.\n" +
"O argumento passado para o construtor FileWriter" +
" é o nome desse arquivo e o valor booleano\n" +
"indica se esse texto deve ser anexado ao final do
arquivo" +
"\n caso o arquivo exista e se existe algum texto
nele, um valor false " +
"indica que o texto\n" +
"não deve ser anexado no final do arquivo.");
fileWriter.close();
}//end catch
}//end main
}//end class
● Veja que é muito simples criar um arquivo texto,
primeiro um objeto file é criado e em seguida esse
objeto é passado para o construtor FileWriter junto
com o argumento booleano indicando se o texto deve
ser anexado no final do arquivo ou não, um true
indica que sim, se você criar um objeto FileWriter
que só passa um objeto File ou uma String indicando o
nome do arquivo, então o valor booleano false é
passado para o construtor FileOutputStream, todos os
construtores declarados na classe FileWriter invoca
algum construtor da classe FileOutputStream, na
verdade a classe FileWriter invoca o construtor da
sua super classe, que é OutputStreamWriter, passando
para a mesma uma referência FileOutputStream, no
nosso exemplo a classe FileWriter passa para o
construtor da sua super classe uma referência
FileOutputStream que recebe dois argumentos, um
objeto File e um valor booleano, não escrevi sobre
esse construtor FileOutputStream na aula 4 porque eu
iria fazelo nessa aula 5, abaixo mostro a declaração
do construtor FileWriter(File file) e do construtor
FileWriter(File file, boolean append).
public FileWriter(File file) throws IOException{
super(new FileOutputStream(file));
}
public FileWriter(File file, boolean append) throws IOException {
super(new FileOutputStream(file, append));
}
● Agora vamos ver a declaração dos construtores
FileOutputStream(File file) e FileOutputStream(File
file, boolean append) que são invocados no construtor
FileWriter(File file) e FileWriter(File file, boolean
append).
public FileOutputStream(File file) throws FileNotFoundException {
this(file, false);
}
public FileOutputStream(File file, boolean append)throws
FileNotFoundException{
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkWrite(name);
}
if (name == null) {
throw new NullPointerException();
}
fd = new FileDescriptor();
this.append = append;
if (append) {
openAppend(name);
} else {
open(name);
}
}
● No nosso primeiro exemplo foi passado o valor boolean
true para o contrutor FileWriter, mais nehnum texto
será anexado, na verdade será, só que não há nenhum
texto para ser anexado, e existe duas razões
prováveis, primeira, o arquivo não existe, segunda, o
arquivo existe só que o seu conteúdo está em branco.
No próximo exemplo vamos refazer o exemplo anterior
anexando um novo parágrafo no final do arquivo.
● Nota => note que toda vez que você for escrever um
arquivo texto você deve fechar o stream, se não, o
stream ficará aberto e não será gravado nada no
arquivo.
package javaIO;
public class WriteFileText {
try {
FileWriter fileWriter = new FileWriter(file,true);
//begin trecho1
fileWriter.write("Esse é o meu segundo exemplo,\n"
+"aos poucos estou aprendo sobre o pacote
java.io.\n");
//end trecho1
//begin trecho2
/*
fileWriter.write("Esse é o meu segundo
exemplo,\n" +
"aos poucos estou aprendo sobre o pacote
java.io.");
*/
//end trecho2
fileWriter.close();
}//end catch
}//end main
}//end class
● Note que o segundo método está comentado, isso foi feito
de próposito para que você perceba que o texto será
anexado no final do arquivo mesmo, execute esse exemplo
com esse trecho comentado, agora abra o arquivo
FileWriter.txt e veja que o primeiro método anexou o
texto depois do .(ponto), isso aconteceu porque na
primeira vez que o arquivo FileWriter.txt foi criado o
final do arquivo foi terminado com um .(ponto), perceba
que nesse exemplo o primeiro método writer esvreve uma
string terminandoa com uma quebra de linha(\n), agora
comente o trecho1 e retire o comentário do trecho2 e em
seguida execute o programa, você notará que o texto do
trecho2 foi anexado em uma nova linha, e não depois do
.(ponto).
● Agora vamos ver exemplos de como escrever um arquivo
texto usando os métodos public void write(char cbuf[]) e
public void write(char cbuf[], int off, int len).
package javaIO;
import java.io.Writer;
public class WriteFileText2 {
try{
String str = "Agora estou escrevendo um exemplo de
como\n"+"usar o método write(char[] c).";
File file = new File("FileWriter2.txt");
Writer writer = new FileWriter(file);
writer.write(str.toCharArray());
writer.close();
}//end cacth
}//end main
}//end class
● Veja como foi fácil escrever um arquivo texto usando
o método write(char[] c), simplesmente a string str
foi convertida para uma array de char com o método
toCharArray, na verdade quando você usa o método
write(String str) ou o método write(String str, int
ofset, int length), a string passada como arqumento é
convertida para um array de chars, na verdade esse
processo de conversão é feito no método write(String
str, int offset, int length), isso quer dizer que o
método write(String str) invoca em seu corpo o método
write(String str, int offset, int length), abaixo
mostro a declaração desses dois métodos.

public void write(String str) throws IOException {
write(str, 0, str.length());
}
public void write(String str, int off, int len) throws IOException{
synchronized (lock) {
char cbuf[];
if (len <= writeBufferSize) {
if (writeBuffer == null) {
writeBuffer = new char[writeBufferSize];
}
cbuf = writeBuffer;
}
else { // Don't permanently allocate very large buffers.
cbuf = new char[len];
}
str.getChars(off, (off + len), cbuf, 0);
write(cbuf, 0, len);
}
}
● Agora vamos fazer um exemplo usando o método
write(char[] c, int offset, int length).
package javaIO;
try{
String str2 = "\nAgora estou usando o método
write(char[] c, "+"int offset, int length)\npara
escrever esse texto, "+"note que estou anexando
esse texto ao texto anterior.";
File file = new File("FileWriter2.txt");
Writer writer = new FileWriter(file,true);
writer.write(str2.toCharArray(), 0,
str2.toCharArray().length);
writer.close();
}//end catch
}//end main
}//end class
– Escrvendo arquivos de uma forma mais eficiente
● Para escrever arquivos de uma forma mais eficiente
você usa a classe java.io.BufferedWriter, essa classe
herda da classe Writer diretamente, para que você
entenda a forma como agente escreveu os arquivos texto
até aqui (sem buffer) e forma como vamos escrever os
arquivos textos nos próximos exemplos (com buffer)
vou fazer uma animação. Note que a animação abaixo serve
para buffer de entrada e para buffer de saída.
– Sem Buffer
● Se você fez parte do curso JavaME ministrado por
mim, você percebeu que as aulas eram postadas
toda segundafeira, a cada segundafeira era
postada uma aula diferente, até que se chegase
ao final do curso, se agente fosse programar
nesse modelo ele seria ineficiente, porque você
só poderia ler a próxima aula depois de uma
semana.
– Com Buffer
● Agora se as aulas fossem postadas todas de uma
vez em um único arquivo ? Você poderia ler
todas as aulas de uma unica vez, sem precisar
esperar uma semana, se agente fosse progromar
nesse modelo ele seria eficiente, porque você
pode ler todas as aulas de uma vez ou não e na
hora que bem entendese, no modelo sem buffer,
não.
● Para escrever arquivos texto com a classe
BufferedWriter você passa como argumento para o
construtor BufferedWriter o objeto Writer ou
FileWriter, em outra palavras você faz isso:
File file = new File(“MyFile.txt”);
FileWriter writer = new FileWriter(file);
BufferedWriter buffer = new BufferedWriter(writer);
● Você escrver arquivos textos com buffer utilizando os
mesmos métodos mostrados anteriormente.
– Exemplos
package javaIO;
import java.io.BufferedWriter;
try{
File file = new File("./FileWriter3.txt");
Writer writer = new FileWriter(file);
BufferedWriter bufferedWriter = new
BufferedWriter(writer);
– Exemplos
bufferedWriter.write("Esse é o meu terceiro
arquivo, agora estou aprendendo " +
"a usar a classe BufferedWriter.");
bufferedWriter.newLine();
bufferedWriter.write("Eu tive que usar o método
newLine() da classe BufferedWriter " +
"para dar uma quebra de linha,");
bufferedWriter.newLine();
bufferedWriter.write("porque nem toda plaforma
utiliza o \\n como separador de linha.");
– Exemplos
bufferedWriter.close();
}//end catch
}//end main
}//end class
● Veja que esse exemplo é bem parecido com os exemplos
anteriores, a diferença é que agora estamos usando um
buffer, um outro detalhe importante que você deve
percerber é a presença do método newLine da classe
BufferedWriter, esse método dar uma quebra de linha,
e você deve usalo e não o \n, porque nem toda
plataforma utiliza o \n como separador de linha.
– Exercício
● Quem é a super classe de FileWriter ?
● Qual a classe que FileWriter herda inderetamente ?
*
● Faça um pequeno editor de textos.
*
Esse editor de texto não precisa ler arquivos só
escrever.
● Resumo
– Na aula de hoje você aprendeu como escrever um arquivo
texto usando as classes File, Writer e FileWriter, e
você também aprendeu a escrever arquivos textos
utilizando a classe BufferedWriter, no próximo capítulo
você vai aprender a ler esses arquivos textos.
– Como ler um arquivo texto ?
● Para ler um arquivo texto, você usa a classe
java.io.FileReader, essa classe herda indiretamente a
classe java.io.Reader através da classe
java.io.InputStreamReader que herda de Reader, da
mesma forma como a classe FileWriter a classe
FileReader não declara nenhum método, só
construtores, construtores esses que invocam em seu
corpo algum construtor da sua super classe, e esses
contrutores da super classe de FileReader recebe como
argumento uma referência para a classe
FileInputStream, na verdade a classe FileReader só
declara 3 construtores, abaixo mostro a declaração
dos construtores FileReader(String fileName) e
FileReader(File file).
public FileReader(String fileName) throws FileNotFoundException {
super(new FileInputStream(fileName));
}
public FileReader(File file) throws FileNotFoundException {
super(new FileInputStream(file));
}
– Exemplo
● Agora vamos fazer alguns exemplos de como usar um
objeto FileReader.
package javaIO;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
public class ReadFileText {
try {
if(!(file.exists())){
throw new FileNotFoundException();
}//end if
Reader reader = new FileReader(file);
int c;
while((c = reader.read()) != 1){
System.out.write(c);
}//end while
reader.close();

}//end cacth
}//end main
}//end class
● Nesse exemplo o arquivo FileWriter.txt foi lido com o
método read(), e o seu conteúdo foi impresso na saída
padrão, além desse método read() você também pode
usar algum dos seguintes métodos para ler um arquivo
texto.
public int read(java.nio.CharBuffer target) throws IOException
public int read(char cbuf[]) throws IOException
public int read(char cbuf[], int offset, int length) throws
IOException
– Lendo arquivos texto de uma forma mais eficiente
● Para ler um arquivo texto de uma forma mais eficiente
usase a classe java.io.BufferedReader, essa é uma
subclasse direta da classe Reader. Além dos métodos
read herdados da classe Reader, a classe
BufferedReader também declara em seu corpo um método
que ler uma linha, e esse método é readLine(), esse
método retorna uma String contendo o conteúdo de uma
linha ou null se o final do arquivo texto foi
alcançado, outro detalhe importante sobre esse método
é que ele não retorna nenhuma quebra de linha (\n).
– Exemplo
package javaIO;
import java.io.BufferedReader;
public class ReadFileText2 {
try {
if(!(file.exists())){
}//end if
Reader reader = new FileReader(file);
BufferedReader bufferedReader = new
BufferedReader(reader);
StringBuffer stringBuffer = new StringBuffer();
boolean EOF = false;
while(!EOF){
String readLine = bufferedReader.readLine();
if(readLine == null){
bufferedReader.close();
reader.close();
EOF = true;
}else{
stringBuffer.append(readLine);
stringBuffer.append('\n');
}//end else
}//end while
System.out.println(stringBuffer);
}//end catch
}//end main
}//end class
● Nesse exemplo o método readLine foi usado para ler o
arquivo FileWriter.txt, no loop while, a string
retornada pelo método readLine é armazenada na string
readLine, e em seguida a condicional if checa se o
final do arquivo foi alcançado, se o final do arquivo
ainda não foi alcançado, a string readLine é
armazenada no objeto stringBuffer com o método
append, seguida de uma quebra de linha, e por último,
o objeto stringBuffer contendo todo o texto do
arquivo FileWriter.txt é impresso na saída padrão.
– Exercício
● Qual classe FileReader herda inderetamente ?
● O método readLine é implementando em que classe ?
● Faça um programa que leia o seu programa.java.
● Faça um pequeno editor de texto que leia um arquivo
qualquer.
● Resumo
– Essa foi a nossa ultima aula, espero que você tenha
gostado desse curso, você pode enviar críticas e
sugestões para vagner@jdukes.com, na aula de hoje você
aprendeu a ler arquivos textos usando as classes Reader,
FileReader, InputStreamReader e BufferedReader.
– Saber compartilhar conhecimento é uma sabedoria para
poucos.
(Vagner de Araujo)
● Extra
– No exercício da ultima aula foi pedido um programa para
ler um arquivo qualquer, bom, nesse capítulo extra eu
estou mostrando o código fonte desse programa, é claro
que essa foi a minha maneira de fazer esse programa,
você pode ter a sua, o seu fonte não precisa ser igual
ao meu, basta que ele realize a tarefa de ler um arquivo
qualquer, sugiro que antes que você olhe esse fonte você
tente fazer o seu próprio código, a figura 1.9 mostra o
programa depois de pronto. Uma outra tarefa que vou
fazer é mostrar como escrever um programa para comparar
dois arquivos binariamente. O fonte desse programa é
mostrado depois da tarefa anterior, e a figura 2.0
mostra o resultado.
● Extra
package javaIO;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FileDialog;
import java.awt.Font;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
● Extra
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.JToolBar.Separator;
public class Bonus {
● Extra
JFrame.setDefaultLookAndFeelDecorated(true);
final JFrame frame = new JFrame("Bonus");
JMenuBar bar = new JMenuBar();
JMenu menu = new JMenu("File");
bar.add(menu);
JMenuItem item = new JMenuItem("Open File");
menu.add(item);
JPanel panel = new JPanel(new BorderLayout());
JPanel panel2 = new JPanel(new BorderLayout());
final TextArea textArea = new TextArea();
textArea.setEditable(false);
textArea.setBackground(Color.white);
textArea.setFont(new Font("arial", Font.ITALIC |
Font.BOLD,14));
panel2.add(textArea);
panel2.add(new JLabel("File Preview",new
ImageIcon("v.jpg"),
● Extra
SwingConstants.CENTER),BorderLayout.NORTH);
panel.add(bar,BorderLayout.NORTH);
panel.add(new Separator(),BorderLayout.LINE_END);
panel.add(new Separator(),BorderLayout.LINE_START);
panel.add(new Separator(),BorderLayout.AFTER_LAST_LINE);
panel.add(panel2,BorderLayout.CENTER);
frame.setContentPane(panel);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
item.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent evt){
FileDialog fileDialog = new FileDialog(frame,"Open
File",FileDialog.LOAD);
fileDialog.setVisible(true);
fileDialog.setLocationRelativeTo(frame);
● Extra
String filePath =
fileDialog.getDirectory()+fileDialog.getFile();
if(filePath == null){
return;
}//end if
StringBuffer stringBuffer = new StringBuffer();
try {
boolean EOF = false;
Reader reader = new FileReader(filePath);
BufferedReader bufferedReader = new
BufferedReader(reader);
while(!EOF){
String readLine = bufferedReader.readLine();
if(readLine == null){
bufferedReader.close();
reader.close();
EOF = true;
}else{
● Extra
stringBuffer.append(readLine);
stringBuffer.append('\n');
}//end else
}//end while
}//end catch
textArea.setText(stringBuffer.toString());
}//end actionPerformed
});//end actionListener
}//end main
}//end class
● Extra
Fig 1.9
● Extra
package javaIO;
public class File2CompBin {
try{
File file = new File("/etc/named.conf");
File file2 = new File("/etc/named.conf");
if(!(file.exists()) || !(file.isFile()) || !
(file2.exists()) || !(file2.isFile())){
}//end if
FileInputStream fileInputStream = new
FileInputStream(file);
FileInputStream fileInputStream2 = new
FileInputStream(file2);
int c;
● Extra
while((c = fileInputStream.read()) != 1){
if(!(Integer.toBinaryString(c).equals(Integer
.toBinaryString(fileInputStream2.read()))))
{
System.out.println("Os 2 arquivos não são
iguais");
fileInputStream2.close();
return;
}//end if
}//end while
● Extra
while((c = fileInputStream2.read()) != 1){
if(!(Integer.toBinaryString(c).equals(Integer
.toBinaryString(fileInputStream.read())))){
System.out.println("Os 2 arquivos não são
iguais ");
return;
}//end if
}//end while
● Extra
System.out.println("Os 2 arquivos são
iguais");
}//end catch
}//end main
}//end class
● Extra
Fig 2.0
● Extra
– Nesse exemplo foi usando dois objetos File e dois
objetos FileInputStream, esses objetos representam os
dois arquivos que vão ser lidos e comparados, como a
classe File e a classe FileInputStream já foram
explicadas não tem porque explicala novamente. A
comparação binária é feita com o método de classe
Integer.toBinaryString(int number), esse método recebe
um inteiro, e retorna uma string representando o binário
desse inteiro, de posse desse binário agente só precisa
usar o método equals() da classe String, se os binários
dos arquivo1 e arquivo2 forem iguais, então a mensagem
“Os 2 arquivos são iguais” é impressa no terminal, se
não forem, é impressa no terminal a mensagem "Os 2
arquivos não são iguais".
To be continued

Curso JavaIO

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Curso JavaIO

Enviado por

Direitos autorais:

Formatos disponíveis

Mini Curso Java I/ O

Você também pode gostar