Manipulando Arquivo Txt com Java
Neste artigo utilizaremos as classes do pacote java.io para criação de diretórios e arquivos do tipo txt. Também veremos como escrever e ler os arquivos criados com o java.io, e outras funções disponíveis neste pacote. Por fim, vamos criar um layout simples de arquivo txt para armazenar informações de objetos Java.
1. Criando diretórios e arquivos
Para a criação de diretórios e arquivos em Java, podemos utilizar a classe java.io.File, vamos agora ver como isso pode ser feito.
Para criar um diretório devemos primeiro criar uma instância da classe File para criar um objeto File. Em seu construtor passamos o local e o nome do diretório que será criado.
java.io.File diretorio = new java.io.File("C:\\TutorialArquivos");
Depois de criado o objeto e inserido o local e o nome do diretório, vamos então utilizar o método mkdir() do objeto File criado. É nesse momento que o diretório será criado. Este método retorna um valor true ou false para indicar se o diretório foi criado ou não.
boolean statusDir = file.mkdir(); System.out.print(statusDir);
Temos agora um novo diretório, vamos então criar nosso primeiro arquivo neste diretório. Para isso, criamos uma nova instância de File e no construtor parssaremos em qual diretório vamos criá-lo e qual será o nome do arquivo.
java.io.File arquivo = new java.io.File(diretorio, "arq_01.txt");
Feito o passo anterior, precisamos utilizar então o método createNewFile() para criar fisicamente o arquivo. Porém este método possui em sua assinatura a exigência de uma exceção do tipo java.io.IOException, que devemos utilizá-la. O método também possui um retorno do tipo boleano.
try {
boolean statusArq = arquivo.createNewFile();
System.out.print(statusArq);
} catch (IOException e) {
e.printStackTrace();
}
Agora está tudo criado, diretório e arquivo. Pode conferir no diretório C:\\ .
2. Usando outros métodos da classe File
Vamos conhecer outros métodos da classe java.io.File.
Primeiro vamos usar o método exists() , que retorna se um arquivo ou diretório existe em um determinado local. O uso é simples e nos retorna um valor boleano. Para utilizá-lo, devemos criar um objeto File e no construtor indicar o nome e/ou local do que procuramos.
Vamos testar se nosso diretório criado existe, e se existir, vamos então testar se nosso arquivo criado existe. Para não criar dois novos objetos, vamos utilizar os dois objetos criados na sessão 1.
if (dir.exists()) {
System.out.println("Diretório existe!");
if (arq.exists()) {
System.out.println("Arquivo existe!");
}
}
Outro método que podemos utilizar é o listFiles() , ele nos retorna uma lista com todos arquivos e diretórios de um determinado diretório. Devemos também criar um objeto File e indicar no construtor em qual local vamos fazer a pesquisa, neste exemplo vamos pesquisar no diretório C:\\ .
File files = new File("C:\\");
for (File file : files.listFiles()) {
System.out.println(file);
}
Vamos utilizar o método renameTo() para renomear um arquivo e um diretório. Precisamos criar um novo objeto para indicar o novo nome do arquivo. Vamos utilizar o diretório e o arquivo anteriormente criados para este exemplo.
File dir = new File("C:\\TutorialArquivos");
File arq = new File(dir, "arq_01.txt");
File arq2 = new File(dir, "arq_02.txt");
boolean statusRename = arq.renameTo(arq2);
System.out.println("Renomedo: " + statusRename + " -> New name: " + arq);
Veja que fizemos a chamada ao método renameTo() através do objeto antigo arq . Criamos um novo objeto chamado arq2, onde indicamos o novo nome do arquivo. Passamos então o objeto arq2 como parâmetro no método renameTo(arq2) .
Podemos também testar se um arquivo encontrado é do tipo diretório ou arquivo. Antes iremos criar mais alguns arquivos e diretórios dentro do nosso diretório C:\\TutorialArquivos . Vamos também utilizar o método getName() para ter como retorno o nome do arquivo encontrado. Veja no exemplo abaixo.
File dir = new File("C:\\TutorialArquivos");
File dir2 = new File(dir + "\\DiretorioDois");
dir2.mkdirs();
File dir3 = new File(dir + "\\DiretorioTres");
dir3.mkdir();
File arq3 = new File(dir, "arq_03.txt");
try {
arq3.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
for ( File f : dir.listFiles() ) {
if ( f.isDirectory() ) {
System.out.println(f + " é um diretório.");
} else if (f.isFile()) {
System.out.println(f.getName() + " é um arquivo.");
}
}
Por fim vamos utilizar o método delete() no próximo exemplo, e excluir o arquivo e o diretório que foram criados anteriormente.
System.out.println( dir3.delete() ); System.out.println( arq3.delete() );
Existem vários outros métodos na classe java.io.File além dos citados aqui, veja você mesmo e qualquer dúvida leia a documentação dos mesmos.
3. Escrevendo em arquivo TXT
Chegou a hora de aprendermos a escrever nos arquivos criados, para isso, vamos utilizar a classe java.io. PrintWriter . Existem varias classes no pacote java.io que possibilitam a escrita em arquivos, porém eu considero a PrintWriter a mais interessante delas pelos métodos que ela oferece.
Desta vez vamos criar uma classe chamada User e nela criar algumas variáveis de instância, conforme a listagem abaixo.
import java.util.Date;
public class User {
private Integer id;
private String nome;
private String observacao;
public User() {
}
public User(Integer id, String nome, String observacao) {
this.id = id;
this.nome = nome;
this.observacao = observacao;
}
//Gere os métodos getters e setters
//Subscreva o método toString()
}
Crie agora outra classe, chamada FileTestUser, nela iremos criar um método main() e um método para escrever no arquivo que ainda criaremos.
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
public class FileTestUser {
public static void main(String[] args) {
//criando um objeto User
User user = new User();
user.setId(1);
user.setNome("Bart Simpson");
user.setObservacao("Personagem de desenho animado.");
//Chamando o método escrever e passando user como parâmetro
escrever(user);
}
private static void escrever(User user) {
File dir = new File("C:\\TutorialArquivos");
File arq = new File(dir, "User.txt");
try {
//neste ponto criamos o arquivo fisicamente
arq.createNewFile();
//Devemos passar no construtor do FileWriter qual arquivo
// vamos manipular.
// Esse construtor aceita dois tipos de parâmetros,
// File ou String.
//O parâmetro true indica que reescrevemos no arquivo
// sem apagar o que já existe.
// O false apagaria o conteúdo do arquivo e escreveria
// o novo conteúdo.
// Se não usar o 2° parâmetro, ele por padrão será false.
//O mais importante, essa linha abre o fluxo do arquivo
FileWriter fileWriter = new FileWriter(arq, false);
//Agora vamos usar a classe PrintWriter para escrever
//fisicamente no arquivo.
//Precisamos passar o objeto FileReader em seu construtor
PrintWriter printWriter = new PrintWriter(fileWriter);
//Agora vamos escrever no arquivo com o método println(),
// que nos permite escrever linha a linha no arquivo
printWriter.println(user.getId());
printWriter.println(user.getNome());
printWriter.println(user.getObservacao());
//o método flush libera a escrita no arquivo
printWriter.flush();
//No final precisamos fechar o arquivo
printWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
A classe PrintWriter ainda nos fornece outros dois métodos para escrita, o write() e o append(). A diferença deles para o método println() é que o último escreve linha a linha conforme é chamado, já os anteriores irão adicionando as palavras sempre na mesma linha.
Há também uma diferença entre o método write() e append(), o primeiro não aceita null, já o segundo aceita null. Existem ainda os métodos printf(), print() e format() e eles funcionam de maneira semelhante como quando os utilizamos em um System.out.print() , System.out.printf() ou System.out.format() respectivamente.
4. Lendo um arquivo TXT
Para ler o arquivo User.txt, vamos primeiro importar as classes java.io.FileReader e java.io.BufferedReader. Em seguida vamos criar o método ler().
private static void ler() {
File dir = new File("C:\\TutorialArquivos");
File arq = new File(dir, "User.txt");
try {
//Indicamos o arquivo que será lido
FileReader fileReader = new FileReader(arq);
//Criamos o objeto bufferReader que nos
// oferece o método de leitura readLine()
BufferedReader bufferedReader = new BufferedReader(fileReader);
//String que irá receber cada linha do arquivo
String linha = "";
//Fazemos um loop linha a linha no arquivo,
// enquanto ele seja diferente de null.
//O método readLine() devolve a linha na
// posicao do loop para a variavel linha.
while ( ( linha = bufferedReader.readLine() ) != null) {
//Aqui imprimimos a linha
System.out.println(linha);
}
//liberamos o fluxo dos objetos ou fechamos o arquivo
fileReader.close();
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
Caso você deseje recuperar os dados do arquivo para o objeto User, deverá criar um layout para o arquivo. Salvar as informações na mesma linha seria o mais aconselhável caso o mesmo arquivo guarde mais de um User.
Esse layout pode ser por posições, tipo o id vai da posição 0 à 5, o nome da posição 6 à 26, e assim por diante. Outro modo seria ao invés de guardar posições, criar um carácter que determine que o campo id terminasse quando encontrasse esse carácter e está começando o campo nome, poderia ser, por exemplo, um ponto e vírgula, ou qualquer outro carácter que você tem certeza que não seria usado naquele objeto.
5. Usando um layout simples
Vamos agora criar uma nova classe chamada TestLayout. Vamos criar vários users e depois inserir em um arquivo, onde usaremos o ";" para separar os atributos de cada user . E cada nova linha do arquivo conterá um novo user .
import java.util.*;
import java.io.*;
import java.util.ArrayList;
public class FileTestUser {
public static void main(String[] args) {
//Criamos 6 users
User user1 = new User(1, "Ronaldinho Gaúcho", "Jogador de Futebol");
User user2 = new User(2, "Nelson Piquet", "Piloto de Fómula 1");
User user3 = new User(3, "Monteiro Lobato", "Escritor");
User user4 = new User(4, "Luana Piovani", "Atriz");
User user5 = new User(5, "Ana Maria Braga", "Apresentadora de Televisão");
User user6 = new User(6, "João Carlos", "Programador JEE");
//adicionamos os users em um lista
List userList = new ArrayList();
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
userList.add(user5);
userList.add(user6);
//passamos a lista por parâmetro
layout(userList);
}
private static void layout(List users) {
File dir = new File("C:\\TutorialArquivos");
//Cria um novo arquivo
File arq = new File(dir, "User2.txt");
try {
arq.createNewFile();
FileWriter fileWriter = new FileWriter(arq, false);
PrintWriter printWriter = new PrintWriter(fileWriter);
//Utilizamos o método print() para escrever na
// mesma linha e um ponto e vírgula no final.
//O println forçará a troca de linha
// para o próximo user.
for (User user : users) {
printWriter.print(user.getId() + ";");
printWriter.print(user.getNome() + ";");
printWriter.println(user.getObservacao());
}
printWriter.flush();
printWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
FileReader fileReader = new FileReader(arq);
BufferedReader bufferedReader = new BufferedReader(fileReader);
String linha = "";
//Lista que irá guardar o resultado, ou seja,
// cada linha do arquivo que corresponde a um User
List result = new ArrayList();
while ((linha = bufferedReader.readLine()) != null) {
System.out.println(linha);
if (linha != null && !linha.isEmpty()) {
result.add(linha);
}
}
fileReader.close();
bufferedReader.close();
for (String s : result) {
//Usamos o método split da classe String
// para separar as partes entre os ponto e vírgulas.
//Guardamos o resultado em um array
String[] user = s.split(";");
//Criamos um objeto User e setamos em seus atributos
//as posições correspondentes do array
User u = new User();
u.setId(Integer.valueOf(user[0]));
u.setNome(user[1]);
u.setObservacao(user[2]);
//exibe o conteúdo do objeto u
System.out.println(u.toString());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Conclusão
Neste artigo vimos como utilizar alguns métodos importantes do pacote java.io . Aprendemos a criar, excluir e renomear arquivos e diretórios, entre outros métodos da classe File . Também aprendemos a escrever em arquivos e como ler os mesmos, e por fim, um pequeno exemplo para trabalhar com arquivo no estilo layout . Fica como dica a criação do seu próprio layout de arquivo.
Saiba mais
- Documentação do classe java.io.File http://download.oracle.com/javase/6/docs/api/java/io/File.html
- Documentação da classe java.io.PrintWriter http://download.oracle.com/javase/6/docs/api/java/io/PrintWriter.html
- Documentação da classe java.io.BufferedReader http://download.oracle.com/javase/6/docs/api/java/io/BufferedReader.html
- Documentação da classe java.io.FileReader http://download.oracle.com/javase/6/docs/api/java/io/FileReader.html
- Documentação da classe java.io.FileWriter http://download.oracle.com/javase/6/docs/api/java/io/FileWriter.html
- Documentação da classe java.lang.String http://download.oracle.com/javase/6/docs/api/java/lang/String.html
