Eclipse ler arquivo verificar palavras reptidas e criar outro

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?

do {
   s = br.readLine(); 
 } while (s != null);

quando colei a listagem que a identação saiu.

vou testar a sua dica.

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!

diecavallax:

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!

então, mas vc usa a String antes de testar, se ela for nula nula vai da NullPointException mesmo, sei lá eu faria assim:

String s1 = br1.readLine(); 

while (s1 != null){

       bw.append(s1);
       bw.newLine(); 

        s1 = br1.readLine(); 
}

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!!!

Para ler um arquivo e filtrar as palavras repetidas, use um LinkedHashSet. Um exemplo:

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

class TesteLinkedHashSet {
    public static void main(String[] args) {
        BufferedReader br = null;
        Set<String> linhas = new LinkedHashSet<String>() ;
        try {
            br = new BufferedReader (new FileReader ("1.txt"));
            for (String linha = br.readLine(); linha != null; linha = br.readLine()) {
                linhas.add (linha);
            }
            br.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (br != null) try { br.close(); } catch (IOException e) {}
        }

        PrintWriter pw = null;
        try {
            pw = new PrintWriter (new FileWriter ("101.txt"));
            for (String linha : linhas) {
                pw.println (linha);
            }
            pw.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (pw != null) pw.close();
        }
    }
}

thingol:

Para ler um arquivo e filtrar as palavras repetidas, use um LinkedHashSet. Um exemplo:

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

class TesteLinkedHashSet {
    public static void main(String[] args) {
        BufferedReader br = null;
        Set<String> linhas = new LinkedHashSet<String>() ;
        try {
            br = new BufferedReader (new FileReader ("1.txt"));
            for (String linha = br.readLine(); linha != null; linha = br.readLine()) {
                linhas.add (linha);
            }
            br.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (br != null) try { br.close(); } catch (IOException e) {}
        }

        PrintWriter pw = null;
        try {
            pw = new PrintWriter (new FileWriter ("101.txt"));
            for (String linha : linhas) {
                pw.println (linha);
            }
            pw.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (pw != null) pw.close();
        }
    }
}

Mas thingol, uma dúvida, se o arquivo for MUITO GRANDE, num pode ser que ele coma a memória toda?

É 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();
        }
        
    }
}

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.

legal, não sabia que o sort do unix usava mergesort, no caso do linux um sort -u resolve, né?