Ficheiros em JAVA

O que é um Canal
 Em JAVA, todas os aspectos que se relacionam com as diferentes formas de se
realizar a leitura e a escrita de dados a partir de uma fonte e para um destino,
são reunidas, e abstraídas, no conceito de canal.
 Um Canal é uma abstracção que pode representar quer uma fonte genérica de
entrada de dados ou um destino genérico para escrita de dados de acesso
sequencial e independente de dispositivos físicos concretos, formatos ou até de
mecanismos de optimização de leitura e escrita.

 Em JAVA, existem duas grandes classes de canais, designadamente:
 Canais de caracteres (canais de texto)
 Canais de bytes (canais binárias)

2

Classes Base
 Todos as classes , que implementam formas particulares de Leitura e Escrita
em canais, são derivadas de quatro classes abstractas, são elas:

 Para os canais de bytes: InputStream e OutputStream
 Para os canais de caracteres: Reader e Writer (associados aos ficheiros)

 Estas classes sendo abstractas definem o conjunto de métodos que uma
qualquer implementação de tais canais deverá concretizar.

 JAVA oferece serviços básicos de Entrada e Saída através de dois canais
associados respectivamente às operações de bytes associada a leitura do
teclado ou a e escrita no monitor:
 System.in: Leitura no teclado
 System.out: Escrita no monitor

3

Canal de leitura: System.in
 System.in: É o canal de leitura standard
 Por omissão lê o teclado

 Podemos usar System.in de várias maneiras
 Directamente (acesso básico)
 Em conjunto com outros canais (acesso combinado)

4

Wrappers & Buffers
O package java.io está inteligentemente desenhado.
InputStreamReader Algumas das classes funcionam como classes embrulho
(wrapper classes) e destinam-se a acrescentar
System.in funcionalidade aos canais existentes.

Por Exemplo:

•InputStreamReader: Permite ler um caracter do teclado
sem ser necessário converte-lo manualmente.
InputStreamReader
(read())
System.in •BufferedReader: Permite ler uma cadeia de caracteres
do teclado sem ser necessário converte-lo manualmente
BufferedReader (readLine()).

5

Ler do teclado (Java 1.4)

try {
BufferedReader r = new BufferedReader(
new InputStreamReader(System.in));

String s = r.readLine() ;
int i = (new Integer(s)).intValue() ;

System.out.println(i) ;
}
catch (IOException e) { }

6

Canais de Bytes
ByteArrayInputStream
DataInputStream DataInput
FileInputStream
BufferedInputStream
FilterInputStream
LineNumberInputStream
InputStream SequenceInputStream
PushBackInputStream
PipedInputStream

ObjectInputStream ObjectInput

Object StringBufferInputStream

ByteArrayOutputStream

FileOutputStream BufferedOutputStream

OutputStream FilterOutputStream DataOutputStream DataOutput

PipedOutputStream PrintStream

ObjectOutputStream ObjectOutput

RandomAccessFile

7

Canais de Caracteres
CharArrayReader

InputStreamReader FileReader

FilterReader PushBackReader

Reader StringReader

PipedReader

BufferedReader LineNumberReader

Object BufferedWriter

CharArrayWriter

OutputStreamWriter FileWriter

Writer FilterWriter

PipedWriter

PrintWriter

StringWriter

StreamTokenizer

8

Classe Scanner (JAVA 5.0)

 A classe Scanner, introduzida com a versão J2SE 5.0, é uma
classe nova que permite converter o texto para tipos primitivos.
 java.util.Scanner

 O texto pode ser obtido das mais diversas fontes tais como
objectos do tipo:
 Strings

 InputStream

 Ficheiros

 A classe Scanner permite separar o texto em tokens, que são
sequências de caracteres separados por delimitadores.

 Por defeito, os delimitadores são os espaços em branco, tabs e
mudanças de linha.

9

Leitura do Teclado
 Para ler de forma confortável texto do canal de entrada padrão, é preciso
criar primeiro um Scanner sobre canal System.in que esta associado ao
teclado
Scanner sc = new Scanner(System.in);

 Para cada um dos tipos primitivos há um método correspondente com a
assinatura nextXxx() que retorne um valor desse tipo.

 Se a string não puder ser interpretada como sendo deste tipo, é lançado
uma excepção do tipo InputMismatchException.

 Exemplos de algumas leituras de tokens:
 String aToken = sc.next() ; //Lê um token

 int num1 = sc.nextInt() ; //Lê um token inteiro
 double num2 = sc.nextDouble() ; //Lê um token real
 String linha = sc.nextLine() ; //Lê uma linha

10

Exemplo: Ler do teclado (Java 5.0)
import java.io.*;
import java.util.*;

class ExScanner{
public static void main(String[] args) {
{
Scanner scanTeclado = new Scanner(System.in);

System.out.println ("Introduza um inteiro");

try
{
int num = scanTeclado.nextInt();
System.out.println ("Numero introduzido:" + num);
}

catch (InputMismatchException e)
{
System.out.println ("Erro na leitura do valor:" + e );
}
}
}

11

import java.io.*;
import java.util.*;

class ExScanner{
public static void main(String[] args) {
{
String str = "Vamos experimentar o scanner";

Scanner scanStr = new Scanner(str);

while (scanStr.hasNext())
{
System.out.println ("Token:" + scanStr.next());
}
}
}
}

12

Ler int (e.g. 3501): Introduziu 123
import java.io.*;
import java.util.*;
Ler float (e.g. 2,43): Introduziu 2.34
public class ScanConsoleApp{
public static void main (String arg[]) {
// Cria um scanner para ler do teclado
Scanner scanner = new Scanner (System.in);
try {
System.out.printf (“Ler int (e.g. %4d): ",3501);
int int_val = scanner.nextInt ();
System.out.println (" Introduziu " + int_val +"n");

System.out.printf (“Ler float (e.g. %5.2f): ", 2.43);
float float_val = scanner.nextFloat ();
System.out.println (" Introduziu " + float_val +"n");
}
catch (InputMismatchException e) {
System.out.println (“Erro na leitura do valor:" + e );
}
}
}

13

Ficheiros
 Um ficheiro é uma entidade de armazenamento de informação permanente.

 A manipulação de ficheiros é feita pela utilização de canais que derivam das
classes: InputStream; Reader; OutputStream; Writer.

 Os ficheiros, de acordo com o tipo de informação que podem armazenar,
podem ser classificada em:

Ficheiros de Texto (Orientado ao caracter)
 Derivam das classes : Reader e Writer.
 Fácil de ser lido por humanos com ferramentas simples (type, more, edit, ...).
 Linhas com comprimento variável.
 Cada linha termina com uma marca.
 Exemplo: ficheiro com código-fonte em Java.

Ficheiro de Dados (Orientado ao byte)
 Derivam das classes : InputStream e OutputStream.
 Apropriado para o processamento por ferramentas automáticas.
 Armazenamento de tipos primitivos, serialização de objectos, etc.
 Armazenamento independente da plataforma.

14

A Classe File

 A classe File representa os ficheiros e directorias de um sistemas de
ficheiros.
 Esta classe define métodos para a realização das operações sobre ficheiros
e directorias:
 listagem de directorias

 apagar um ficheiro

 determinar atributos de um ficheiro, alterar o seu nome, etc.

 Definição:

 File entFich = new File(cadeia de caracteres);

15

Os métodos da Classe File
CONSTRUTORES
 File(String caminho) construtor de directórios/ficheiros
 File(String caminho,String nome) construtor com nome separado do caminho
 File(String directorio, String nome) construtor com directório e nome do ficheiro

MÉTODOS
 boolean canRead() ficheiro/directório pode ser lido
 boolean canWrite() pode-se gravar no ficheiro/directório
 boolean delete() apaga ficheiro/directório
 boolean exists() verifica se ficheiro/directório existem
 boolean isAbsolute() verifica se caminho é absoluto
 boolean isDirectory() verifica se objecto é directório
 boolean isFile() verifica se objecto é ficheiro
 boolean mKdir() cria directório do objecto
 boolean mKdirs() cria directórios do caminho
 boolean renameTo(String novo) muda nome do ficheiro/directório para novo

16

Exemplo: Classe File
import java.io.*;
class Exemplo
{
public static void main(String[] args) throws IOException
{
File meuFicheiro = new File(”dados.dat”);

if (meuFicheiro.exists())

System.out.println(“dados.dat existe");

else

System.out.println(" dados.dat não existe");

}
}
Testa a existência do ficheiro “dados.dat”

17

Escrita
Ficheiro de Texto
 Passos necessários para criar um ficheiro de Texto

 Criar um objecto do tipo File. Permite manipular diversos atributos de
um ficheiro.

 Criar um canal FileWriter ligado ao objecto File. Permite associar um
ficheiro de texto a um canal de escrita.

 Criar um canal tampão BufferedWriter ligado ao objecto FileWriter.
Maior eficiência na escrita de um ficheiro.

 Criar um canal PrintWriter ligado ao objecto BufferedWriter.
Permite a utilização dos métodos print e println.

18

Escrita com PrintWriter
import java.io.*;
public class PrintWriterFileApp{

File file = null;
file = new File ("textOutput.txt");
try {
FileWriter file_writer = new FileWriter (file);
BufferedWriter buf_writer = new BufferedWriter (file_writer);
PrintWriter print_writer = new PrintWriter (buf_writer);

print_writer.println ("Saida com PrintWriter.");
print_writer.println ("tipos primitivos convertidos em strings:");

boolean a_boolean = false;
int an_int = 1234567;

print_writer.println (a_boolean);
print_writer.println (an_int);
}
catch (IOException ioe){ System.out.println("IO Exception"); }
}
}

19

Escrita num ficheiro de Texto (formatado)
import java.io.*;
public class PrintWriterFileApp{

File file = null;
file = new File ("textOutput.txt");
Formatter formatter;
try {
formatter = new Formatter (file);

formatter.format ("Saida com PrintWriter. %n");
formatter.format ("tipos primitivos convertidos em strings: %n");

boolean a_boolean = false;
int an_int = 1234567;
double a_double = -4.297e-15;

formatter.format ("boolean = %9b %n", a_boolean);
formatter.format ("int = %9d %n", an_int);
formatter.format ("double = %9.2e %n", a_double);
formatter.flush ();
formatter.close ();
}
catch (IOException ioe){ System.out.println("IO Exception"); }
}}
20

Escrita num ficheiro de Texto (formatado)
formatter.format ("Saida com PrintWriter. %n");
%n –> mudança de linha

Ficheiro textOutput.txt :

Saida com PrintWriter.
Tipos primitivos convertidos em strings:
boolean = false
int = 1234567
double = -4.30e-15

21

Leitura
Ficheiro de Texto
 Leitura com Scanner

 Leitura com File Reader

 Criar um objecto do tipo File
Permite manipular diversos atributos de um ficheiro.

 Criar um canal FileReader ligado ao objecto do tipo File
Permite a leitura de um ficheiro escrito em formato ASCII.

 Criar um canal tampão BufferedReader ligado objecto do tipo FileReader
Maior eficiência na leitura de um ficheiro .

22

Leitura com Scanner
import java.io.*; Ficheiro textInput.txt:
import java.util.*; 123 Primeiro
public class LeituraFicheiro { 234 Segundo
Saida:
File file = new File ("textInput.txt");
Numero inteiro lido: 123
Scanner scanner = null;
Primeiro
try {
Numero inteiro lido: 234
scanner = new Scanner (file);
Segundo
while( scanner.hasNext())
Finished executing
{
int num = scanner.nextInt();
System.out.println ("Numero inteiro lido: " +num);
System.out.println (scanner.next());
}
}
catch (InputMismatchException e) {
System.out.println ("Mismatch exception:" + e );
}
catch (FileNotFoundException e) {
System.out.println ("Ficheiro não encontrado!");
System.exit (0);
} }}

23

Leitura com FileReader (Ex.1)
Le um ficheiro de texto.
import java.io.*; Envia para o ecrã cada linha lida.
import java.util.*;

class LeFicheiro
{
public static void main(String[] args) throws IOException
{
String linha;
File f;
FileReader fich;
BufferedReader entrada = null;

24

Leitura com FileReader (Ex.1)

try
{
f = new File("meuFich.dat");
fich = new FileReader(f);
entrada = new BufferedReader(fich);
do
{
linha = entrada.readLine();
if (linha != null )
System.out.println(linha);
}
while (linha != null);
}

25

Leitura com FileReader (Ex1)

catch ( IOException e)
{
System.out.println("Erro de I/O.");
System.out.print(e);
}
finally
{
System.out.println("fim do programa.");
if (entrada != null)
entrada.close();
}

}
}

26

Exemplo 2
import java.io.*;
class ContaDigitoCaracter{
public static void main(String[] args) throws IOException {
int proxValor, numMaius=0, numMinu=0, numDigitos=0, numOutros=0;
char proxCar; Lê um ficheiro e retorna os números de:
String nomeFicheiro; digitos; letras maisculas; letras
minusculas e outros caracteres
// Obtem ficheiro do utilizar
System.out.print(“Nome do ficheiro: ");
nomeFicheiro = Le.umaString();
File fich= new File(nomeFicheiro);

// testa leitura
if (fich.exists() && fich.canRead())
{
// Cria os canais
BufferedReader fichEnt
= new BufferedReader(new FileReader(fich));

27

Exemplo2
// Le do ficheiro
proxValor = fichEnt.read();
while (proxValor != -1){
proxCar = (char) proxValor;
if (Character.isDigit(proxCar)){
numDigitos++;
}
else if (Character.isUpperCase(proxCar)){
numMaius++;
}
else if (Character.isLowerCase(proxCar)){
numMinu++;
}
else {
numOutros++;
}
proxValor = fichEnt.read();
}

28

Exemplo2
Nome do Ficheiro: ContaCar.java

Numero de digitos: 7
//fecha canal Numero de letras maisculas: 96
fichEnt.close(); Numero de letras minusculas: 1001
//Mostra resultados Numero de outros caracteres: 832
System.out.print(“Numero de digitos: “);
System.out.println( numDigitos);
System.out.print(“Numero de letras maisculas: “);
System.out.println( numMaius);
System.out.print(“Numero de letras minusculas: “);
System.out.println( numMinu);
System.out.print(“Numero de outros caracteres: “);
System.out.println( numOutros);
}
else {
System.out.print(“não é possível ler ficheiro: “);
System.out.println(nomeEntrada);
}
}
}

29

Exemplo3 - Ficheiro Texto
Leitura de um Ficheiro e separação de
Ficheiro: accoes.dat dados
ACME 6/1/96 50 46.5 49.75
SP500 6/2/96 124 122 123.5
DWMI 6/1/96 24.5 22.25 24.5

Pretende-se manipular um ficheiro (accoes.dat), no
qual cada linha contem o registo de uma sessão da
bolsa sobre um grupo de acções:
Nome da acção, data do registo, valor mais alto
obtido, valor mais baixo obtido, valor de fecho.

30

dados
import java.io.*;
import java.util.*;

public class stock_data {

public static void main(String args[])
{
String nome_accao;
Date data_registo;
float valor_alto, valor_baixo, valor_fecho;

try {
String linha_str;
int linha_numero;

File fich= new File("accoes.dat");

// Cria os canais
BufferedReader fichEnt
= new BufferedReader(new FileReader(fich));

31

dados(cont.)

while ((linha_str = fichEnt.readLine()) != null)
{
StringTokenizer st = new StringTokenizer(linha_str);
// extrai tokens e os converte para os tipos apropriados

nome_accao = st.nextToken();
data_registo = new Date(st.nextToken());
valor_alto = Float.valueOf(st.nextToken()).floatValue();
valor_baixo = Float.valueOf(st.nextToken()).floatValue();
valor_fecho = Float.valueOf(st.nextToken()).floatValue();

32

dados (cont.)
// mostra resultado
System.out.println("nome da Accao :" + nome_accao);
System.out.println("Data Registo :" + data_registo);
System.out.println("valores: Alto:" + valor_alto +
" Baixo:" + valor_baixo + " Fecho:" + valor_fecho);
System.out.println();
}
fichEnt.close();
}
catch (IOException e)
{
System.out.println("Erro I/O: " + e);
}
}
}

33

Ficheiros em JAVA

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Ficheiros em JAVA (20)

Mais de Pedro De Almeida (20)

Último (20)

Ficheiros em JAVA