estou aprendendo java, e tb eclpise, assim elaboreio o codigo abaixo.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class TestaEntrada {
public static void main(String[] args) throws IOException {
String entrada = null, saida = null;
for (int i = 1; i <= 23; i++) {
entrada = i + ".txt";
saida = 100 + i + ".txt";
InputStream is = new FileInputStream(entrada);
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
BufferedReader br1 = new BufferedReader(isr);
OutputStream os = new FileOutputStream(saida);
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
String s, s1;
do {
s = br.readLine();
int j = 0;
do {
s1 = br1.readLine();
if ((s1.compareTo(s) == 0)) {
bw.append(s);
bw.newLine();
}
if ((s1.compareTo(s) != 0)) {
if (j == 0) {
bw.append(s);
bw.newLine();
bw.append(s1);
bw.newLine();
} else {
bw.append(s1);
bw.newLine();
}
}
System.out.println(j);
j++;
} while (s1 != null);
} while (s != null);
System.out.println(saida);
bw.close();
}
}
}
Pretendo fazer o com este codigo o seguinte, ler duas linhas arquivo 1.txt ( com mais de 3 mil palavras iniciadas com a letra a), testar se são iguais, e escrever o outro arquivo 101.txt, sem as palavras reptidas.
Estou com dois problemas
1- no console observo que a contagem não passa de 25382, como segue abaixo a mensagem.
…
25379
25380
25381
25382
Exception in thread “main” java.lang.NullPointerException
at TestaEntrada.main(TestaEntrada.java:39)
não consegui encontrar onde possa estar causando este erro pois pelo visto ele efetua a litura de 25382 linhas e depois da o erro.
2 - mesmo assim ele cria o arquivo 101.txt, mas nao cria o restante 102.txt, 103.txt e etc.
este erro acho que é por causa do primeiro.
Seu código me deu dor de cabeça, sem identação, tá difícil de entender, da proxima vez use a tag code para escrever o código:
1-Eu acho que vc devia fechar os BufferedReader. Tive um professor na facul. chamado Alfredo Goldman que me disse que por uma questão de educação, se abriu feche!! eheheheheh
br.close();
br1.close();
2-Seu do while, confesso que não testei, mas é estranho primeiro vc pega a String depois verifica se ela é nula, num deveria ser ao contrário?
e quanto ao verificar a string acho que esse é a forma correta no meu caso, pois ele testa depois para ver se se e nulo(fim do arquivo) ai vai para a a execução. Me corrija se estiver errado.
e quanto ao verificar a string acho que esse é a forma correta no meu caso, pois ele testa depois para ver se se e nulo(fim do arquivo) ai vai para a a execução. Me corrija se estiver errado.
obrigado![/quote]
então, mas vc usa a String antes de testar, se ela for nula nula vai da NullPointException mesmo, sei lá eu faria assim:
Não me considero um bom programdor, só tô tentando te ajudar, como eu disse eu faria assim!!! Vc pode concordar ou não, mas continuamos amigos.
Eu tomo muito cuidado pra dar pitaco no código dos outros, pq todo programador se acha um deus e quando um outro progrmador se mete eles custumam ficar p. da vida!!!
É claro que sim.
Nesse caso, se você aceitar que o arquivo de saída seja ordenado, use alguma ferramenta como o “sort” e o “uniq” do Unix.
O “sort” usa um método chamado “mergesort”, que permite ordenar arquivos maiores que a memória disponível, usando arquivos temporários.
E o “uniq” simplesmente remove linhas consecutivas repetidas.
O diecavallax não disse que o arquivo estava previamente ordenado.
Se estiver, então ele pode fazer algo semelhante ao que ele estava fazendo (ou seja, ele tentou reescrever o comando “uniq” do Unix), só que tomando mais cuidado.
Exemplo de implementação do uniq:
import java.io.*;
class ExemploUniq {
public static void main(String[] args) {
BufferedReader br = null;
PrintWriter pw = null;
try {
br = new BufferedReader (new FileReader (args[0]));
pw = new PrintWriter (new BufferedWriter (new FileWriter (args[1])));
String corrente = null, anterior = "";
while (true) {
anterior = corrente;
corrente = br.readLine();
if (corrente == null)
break;
if (!corrente.equals (anterior)) {
pw.println (corrente);
}
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (br != null) try { br.close(); } catch (IOException ex) {}
if (pw != null) pw.close();
}
}
}
[quote=thingol]É claro que sim.
Nesse caso, se você aceitar que o arquivo de saída seja ordenado, use alguma ferramenta como o “sort” e o “uniq” do Unix.
O “sort” usa um método chamado “mergesort”, que permite ordenar arquivos maiores que a memória disponível, usando arquivos temporários.
E o “uniq” simplesmente remove linhas consecutivas repetidas.
[/quote]
legal, não sabia que o sort do unix usava mergesort, no caso do linux um sort -u resolve, né?
