Escrita/Leitura arquivos

Programação Java
#1

Iae pessoal, esse é meu primeiro post mas já leio e aprendo com o fórum a algum tempo.

Bom, minha dúvida é: como consigo ler todas as linhas de um arquivo.

Vejam o código:

[code]import javax.swing.;
import java.io.;

class main_teste{
public static void main (String args[]) throws IOException {
teste vet[] = new teste[2];
String Arq = “arquivo.txt”;

	leDados(vet, Arq);
	for (int i=0; i<vet.length; i++){
		vet[i].imprimir();
	}
}

static void leDados (teste vet[], String Arq) throws IOException {
	for (int i=0; [b]i<vet.length[/b]; i++){
		vet[i] = new teste();
		vet[i].nome = JOptionPane.showInputDialog (null, "Digite o nome: ");
	}
		gravaDados(vet, Arq);
}	

static void gravaDados (teste vet[], String Arq) throws IOException {
	FileWriter arquivo;
	BufferedWriter Barquivo;
	arquivo = new FileWriter(Arq,true);
	Barquivo = new BufferedWriter(arquivo);
	for (int i=0; i<vet.length; i++){
		Barquivo.write(vet[i].nome);
		Barquivo.newLine();
		Barquivo.flush();
	}
}

}[/code]

Toda vez que eu rodo o programa ele adiciona nomes no fim do arquivo, preciso agora mandar imprimir todas as linhas, mais pelo fato de ter colocado o vetor do tamanho do array, ele lê somente 2 linhas. Mas já tentei mudar p/ valores numéricos e sempre retorna erros.

Alguém ae pode dar uma força?

Valeu

#2

Hum, você já ouviu falar em java.util.List e java.util.ArrayList? São semelhantes a arrays, mas você não precisa se preocupar com o tamanho. Vou em resumo pôr os paralelos.

Declaração:
/A/ teste[] x = new teste[10];
/L/
import java.util.ArrayList;
import java.util.List;
…
List<teste> x = new ArrayList<teste>();
Inserir um novo elemento:
/A/ x[i] = new teste();
/L/ x.add (teste());
Saber quantos elementos tem:
/A/ int tamanho = x.length;
/L/ int tamanho = x.size();
Atribuir à posição 10 (supondo que essa posição exista):
/A/ x[10] = new tamanho();
/L/ x.set (10, new tamanho());
Obter um valor da posição 10 (supondo que essa posição exista):
/A/ teste t = x[10];
/L/ teste t = x.get(10);

onde /A/ é o que você faz com arrays, e /L/ o que você faz com Lists.

#3

olha se é isso que vc quer… veja a parte com //

import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.BufferedReader;
class Buffer{
	public static void main(String args[]){
	File f = new File("soso.txt");
	try{
		FileWriter fw = new FileWriter(f);
		BufferedWriter bw = new BufferedWriter(fw);
			bw.write("camilo");
			bw.newLine();//nova linha
			bw.write("rumo ");
			bw.flush();
			bw.close();
	}
catch(IOException e){e.printStackTrace();}
	//lendo
	try{
		FileReader fr = new FileReader(f);
		BufferedReader br = new BufferedReader(fr);		
		 String s;
		 //equanto tiver dados na linha imprima
		 while((s=br.readLine())!=null){		
			System.out.println(s);
		 }
	}catch(IOException e){}
	}}

flw!!

#4

thingol, nunca ouvi falar. Mas vou estudar sobre o assunto.

LPJava, é isso que eu preciso sim.

Mas me ajuda em umas dúvidas:

  1. Qual a diferença de declarar String Arq e File f?
  2. Os comandos try e catch são p/ tratamento de erros certo? Então qual a diferença entre setar throws IOException depois do método main e escrever o código “dentro” de try?
  3. {e.printStackTrace();}, serve p/ imprimir os possíveis erros, certo?

Valeu

#5

1 - String arq - uma variavel(objeto) da class String e File f é uma variavel(objeto) da class File. String retorna uma string e File retorna um file.
2 - se vc diz que o metodo main pode lançar uma exceção do tipo IOException e quem chamar o metodo main deve tratar essa exceção ou passar a bola. mais quando vc poe try e catch dentro do main vc ta dizendo aonde tem o try{} é algo perigoso… que pode lançar uma exceção se ocorrer isso… o catch… deve tratar essa exceção.
Se o metodo trata a exceção vc nao precisa declarar q ele lança ja q ele vai tratar…
3- sim ele mostra a pilha de da exceção de onde tudo começou.

class At{
static void x() throws Exception{}
public static void main(String []ar){
//olhe que meu metodo main vai chamar
// um metodo perigoso entao aqui vc escolhe ou trata
//ou passa a bola.. claro se o main passar a bola quem recebe?
// o usuario.
try{
x();
}
catch(Exception e){e.printStackTrace();}
...

ou pode fazer isso

class At{
static void x() throws Exception e{}
public static void main(String ar[]) throws Exception{
x();
// aqui vc chamou x um metodo perigoso
// se ele lançar uma exceção o metodo main
//nao é capaz de tratar ele passa a bola..

espero ter ajudado… se eu tiver errado… a galera me corrige ai hehe :smiley:
flw!!

#6

Se entendi bem, então o mais correto é utilizar sempre o try{}.

Porque se não de que adianta o tratamento de erros, se o método main não consegue tratar a excessão da outra forma.

#7

Na verdade, o try…catch do LPJava, da forma que está aí, é um exemplo do que não se deve fazer. Porque dessa forma, ele até imprime o erro, mas não toma nenhuma atitude e mantém o código executando. Se o usuário rodou o aplicativo via javaw, o erro nem sequer será impresso e será sumariamente ignorado!

Recomendo fortemente a leitura do artigo:
Lidando com Exceptions e do post http://www.guj.com.br/posts/list/15/59056.java#313005

#8

era a duvida dele… isso realmente nao deve acontecer…

#9

Definitivamente complicado de entender isso.

Nesse meu código por exemplo, se eu não utilizar throws IOException ele me retorna o seguinte erro: unreported exception java.io.IOException; must be caught or declared to be thrown.

Porque a obrigatoriedade de eu ter que tratar os erros?

#10

A obrigatoriedade de tratar os erros (ou deixar para alguém tratar) é amplamente discutida em Java, mas é isso que a difere das linguagens do ambiente .NET.

Veja a discussão:

Há uma história que diz que o sr. Guy Steele (que queria essa obrigatoriedade implantada no compilador, e é um dos “pais da linguagem”, tendo escrito a especificação da linguagem Java) aproveitou que o sr. James Gosling (que inventou a linguagem) estava fora em viagem e pagou um jantar para dois caras que estavam escrevendo o compilador, para implementarem essa obrigatoriedade. Não sei se isso é folclore ou verdade.

#11

[quote=castanhagi]
Porque a obrigatoriedade de eu ter que tratar os erros?[/quote]

No java existem 2 tipos de exceção:
Runtime: Filhas de Exception e RuntimeException: Você não tem qualquer tipo de obrigação de tratar, não precisa colocar na clausula throws.
Normais: Filhas de Exception somente. Você é obrigado a tratar.

As exceções normais são interessantes quando você tem um problema recuperável. Por exemplo, na hora de abrir um arquivo, a exceção FileNotFoundException é uma ótima candidata a uma exceção normal.

Quando usadas corretamente, facilita muito a programação, pois exceções recuperáveis devem ser tratadas, seja para mandar uma mensagem de erro para o usuário, seja para tomar uma ação de emergência. O legal é que compilador garante que o programador pelo menos analisou a exceção e tomou algum tipo de ação à seu respeito. Além disso, a exceção fica mais documentada no código, pois as cláusulas throws são bastante visíveis.

Use esse mecanismo em suas classes para sinalizar quais situações de erro são comuns e que o usuário deveria estar atento.

Agora, o IOException, nesse caso, deveria ser uma RuntimeException. Se o problema der um erro no meio da leitura, há muito pouco o que se possa fazer. O mesmo vale para as SQLExceptions (tanto que o SpringFramework uma versão do ResultSet que deixa de lançar SQLException para lançar uma exceção de runtime).

#12