Manipulação de arquivos em linguagem Java

Depois de vários testes cheguei à conclusão que a melhor forma de manipulação de arquivos no Java é utilizar arquivos randômicos ou serialização.

Arquivos randômicos:

Como a manipulação de arquivos randômicos no Java é difícil e trabalhosa, eu criei a classe Random para fazer o trabalho pesado. É só copiar o código e colar em uma classe com o mesmo nome. Os principais métodos da classe Random são:

Construtor – Configura a classe com o nome do arquivo que deve ser aberto ou criado, com o tamanho em caracteres dos campos e com a quantidade de campos por registro. Obviamente um arquivo só pode ser manipulado com a mesma configuração com a qual foi criado.

GravarStr – Grava uma string no final do arquivo ou em algum campo que foi excluído. Os campos excluídos são marcados logicamente com um “#”. Esse método só pode ser utilizado para a criação de novos registros, ou seja, não pode ser utilizado para atualizar registros, porque ele não oferece parâmetro para a gente dizer onde um campo novo deve ser gravado. Ele grava as informações no primeiro campo vazio que encontra. A string a ser gravada não pode começar por #. Se começar por # o programa apaga esse caractere antes de gravar a string no arquivo.

GravarStringIndex – Grava uma string no campo especificado do arquivo. A numeração começa por zero. Deve ser utilizado para atualização de registros.

ApagarString – Apaga um campo em um local especificado do arquivo e coloca um “#” como primeiro caractere do campo. Esse “#” indica que o campo foi excluído e é utilizado pelos métodos GravarStr e ContarRegistros.

ContarRegistros – retorna o número de registros do arquivo. Leva em consideração sempre o primeiro campo de cada registro.

ContarCampos – retorna o número de campos do arquivo, inclusive os vazios. Pode ser utilizado para listagens com ou sem filtro. A gente coloca um While que vai até a posição atual no arquivo ficar igual ao número de campos.

AbrirArquivo – Abre o arquivo.

FecharArquivo – Fecha o arquivo.

Os métodos para gravar e ler dados numéricos utilizam o método GravarStr e fazem as conversões automaticamente, uma vez que esse método só grava strings.

Uma string nunca é gravada antes de passar pelo método tratarString. Esse método retira um # inicial se houver um e altera o tamanho da string para o tamanho configurado dos campos do arquivo. Se a string for maior corta os caracteres em excesso, se for menor completa com espaços em branco. O método lerString ignora os espaços em branco no fim das strings gerados por esse método.

Serialização:

Através da serialização podemos gravar e ler milhares de dados de um arquivo com apenas uma instrução. A serialização consiste em gravar um objeto inteiro (classe) em um arquivo. Todos os tipos primitivos, inclusive vetores de tipos primitivos, são armazenados. Porém a serialização sempre grava por cima dos dados anteriores quando o arquivo é aberto, ou seja, pra não sobrescrever, todos os objetos têm que ser gravados em uma única sessão de abertura do arquivo. Uma boa estratégia para trabalhar com serialização é criar as seguintes classes:

• Uma classe que representa os registros, por exemplo: Produtos.
• Uma classe que cria um vetor de objetos Produtos e manipula seus campos (variáveis) através de métodos, por exemplo: Registros.
• Uma classe com o método main que serializa a classe Dados que contem o vetor de objetos Produtos com todos os dados.

Não há limite de quantidade de vetores de objetos diferentes em uma classe.

As duas primeiras classes que estão envolvidas na serialização precisam implementar a interface Serializable, do pacote java.io. Essa interface não declara nenhum método, apenas marca a classe como serializável. A classe que contem o método main não precisa implementar Serializable.

Instruções:

Import java.io.*;

ObjectOutputStream arquivo=new ObjectOutputStream(new FileOutputStream(“Dados.dat”));

[1]arquivo.writeObject(registros);

arquivo.close();

ObjectInputStream arquivo=new ObjectInputStream(new FileInputStream(“Dados.dat”));

Registros registros=(Registros) arquivo.readObject;

arquivo.close();

[1] registros é um objeto da classe Registros.

Esta é a classe Random:

package random;
import java.io.*;
//Copyright (C) 2008 Robson Faria Machado
//http://robsonfm.blogspot.com/
public class Random {
 private String arquivo;
 private int campos;
 private RandomAccessFile arq;
 private int camposPorRegistro;
public Random(String arquivo, int campos, int cpr) {
 super();
 this.arquivo = arquivo;
 this.campos = campos;
 camposPorRegistro=cpr;
}
 public void abrirArquivo(){
  try{
  arq=new RandomAccessFile(this.arquivo, "rw");
  }catch(Exception e){
   System.out.println("Erro ao abrir arquivo. " + e.toString());
  }
 }
public void fecharArquivo(){
if (arq!=null){
 try{
 arq.close();
 }catch(Exception e){
  System.out.println("Erro ao fechar arquivo. " + e.toString());
 }
}
}

public void gravarStr(String str){
String teste="";
int cont=0;
str=tratarString(str);
try{
do{
 arq.seek(cont * ((campos*2)+1));
 teste=String.valueOf(arq.readChar());
 //System.out.println(teste);
 if (teste.equalsIgnoreCase("#")){
  arq.seek(cont * ((campos*2)+1));
  arq.writeChars(str);
  return;
 }
 cont++;
}while(true);
}catch(EOFException eof){
try{
 arq.writeChars(str);
 return;
}catch(IOException io){
 System.out.println("Erro ao gravar dados no arquivo. " + io.toString());
}
}catch(Exception e){
 System.out.println("Erro ao gravar dados no arquivo. " + e.toString());
}
}
public void gravarStringIndex(String texto, int pos){
 try{
  arq.seek(pos * ((campos*2)+1));
  arq.writeChars(texto);
 }catch(Exception e){
  System.out.println("Erro ao gravar dados no arquivo. " + e.toString());
 }
}
 public String tratarString(String texto){
  if (texto.substring(0, 1).equalsIgnoreCase("#")){
   texto=texto.substring(1, texto.length());
  }
  if (texto.length()>campos){
   texto=texto.substring(0, campos);
   return texto;
   }
  if (texto.length()<campos){
   int p=campos-texto.length();
   for (int i=0; i<p; i++){
    texto=texto + " ";
   }
    return texto;
  }
 
  return texto;
 }
public int procurarString(String str, int campoDoRegistro){
 if (str.length()>campos){
  System.out.println("Erro: A string a ser pesquisada é maior que os campos dos registros do arquivo.");
  System.out.println("Tamanho da string: " + str.length());
  System.out.println("Tamanho dos campos: " + (campos));
  return -1;
 }
 String teste="";
 String teste2="";
 int cont=campoDoRegistro-1;
 str=tratarString(str);
 try{
 do{
  arq.seek(cont * ((campos*2)+1));
  teste=String.valueOf(arq.readChar());
  //System.out.println(teste);
  if (teste!="#"){
   teste2="";
  for (int i=0; i<campos*2; i+=2){
   arq.seek((cont * ((campos*2)+1))+i);
   teste2=teste2+arq.readChar();

  }
  if (teste2.equalsIgnoreCase(str)){
   return cont;
  }
  }
  cont+=camposPorRegistro;
 }while(true);
 }catch(EOFException eof){
 return -1;
 }catch(Exception e){
  System.out.println("Erro ao gravar dados no arquivo. " + e.toString());
 }
 return -1;
 }
public long contarRegistros(){
 long contador=0;
 int cont=0;
 String teste;
 try{
 do{
  arq.seek(cont * ((campos*2)+1));
  teste=String.valueOf(arq.readChar());
  contador++;
  if (teste.equalsIgnoreCase("#")){
   contador--;
  }
  cont+=camposPorRegistro;
 }while(true);
 }catch(EOFException eof){
 return contador;
 }catch(Exception e){
  System.out.println("Erro ao contar registros. " + e.toString());
 }
 return contador;
}
//Método contar campos, incluive os vazios.
public long contarCampos(){
 long contador=0;
 int cont=0;
 String teste;
 try{
 do{
  arq.seek(cont * ((campos*2)+1));
  teste=String.valueOf(arq.readChar());
  contador++;
  cont++;
 }while(true);
 }catch(EOFException eof){
  return contador;
 }catch(Exception e){
  System.out.println("Erro ao contar registros. " + e.toString());
 }
 return contador;
}
public String lerString(int pos){
 String stringLida="";
 try{
  arq.seek(pos * ((campos*2)+1));
  for (int i=0; i<campos*2; i+=2){
   stringLida=stringLida + arq.readChar();
   }
  return stringLida.trim();
 }catch(Exception e){
  System.out.println("Erro ao lerString. " + e.toString());
 }
 return stringLida.trim();
 }
public void apagarString(int pos){
 String vazio="#";
 vazio=tratarString(vazio);
 try{
  arq.seek(pos * ((campos*2)+1));
  arq.writeChars(vazio);

 }catch(Exception e){
  System.out.println("Erro ao lerString. " + e.toString());
 }
 }
//int, double, float, long
public void gravarInt(int valor){
 gravarStr(String.valueOf(valor));
}
public void gravarDouble(double valor){
 gravarStr(String.valueOf(valor));
}
public void gravarFloat(float valor){
 gravarStr(String.valueOf(valor));
}
public void gravarLong(long valor){
 gravarStr(String.valueOf(valor));
}
public int lerInt(int pos){
 String val="";
 val=lerString(pos);
 return Integer.parseInt(val);
}
public double lerDouble(int pos){
 String val="";
 val=lerString(pos);
 return Double.parseDouble(val);
}
public float lerFloat(int pos){
 String val="";
 val=lerString(pos);
 return Float.parseFloat(val);
}
public long lerLong(int pos){
 String val="";
 val=lerString(pos);
 return Long.parseLong(val);
}
}

---