Java Codigo pra ler varios arquivos txt e gravar as informações em apenas um txt

Belmires · 4 de outubro de 2019

package Ler;

import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.FileReader;  
import java.io.IOException;  
  
public class Teste7 {  
    public static void main(String[] args) {       
//    	System.out.println(File);
        File diretorio = new File("C:\\Arq");

        File arquivo = null;       
        File[] arquivos = null;       
        FileReader fr = null;       
        BufferedReader br = null;       
               
        String linha = "";       
        File arquivoDestino = new File("C:\\Arq\\new 1.txt");       
        FileOutputStream fos = null;       
        try {       
           if (diretorio.isDirectory()) {       
                arquivos = diretorio.listFiles(); 
                fos = new FileOutputStream(arquivoDestino);
                for (int i = 0; i < arquivos.length; i++) {       
                    arquivo = arquivos[i];    
                      
                     fr = new FileReader(arquivo);       
                     br = new BufferedReader(fr);     
                     fos = new FileOutputStream(arquivoDestino);       
                     while ((linha = br.readLine()) != null) {       
                        fos.write(linha.getBytes());       
                    }  
                     fos.write("\n".getBytes()); 
               }       
            }       
               
            fos.flush();       
            fos.close();       
        } catch (FileNotFoundException fnex) {       
            fnex.printStackTrace();       
        } catch (IOException ioex) {       
            ioex.printStackTrace();       
        }     
    }  
  
}

AdrianoSiqueira · 4 de outubro de 2019

package ler;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;

public class Programa {

    public static void main(String[] args) {
        // Altere essas variáveis segundo as suas necessidades
        final String urlDiretorioOrigem = "/tmp/Programa";
        final String urlArquivoDestino = "/tmp/Programa/destino.txt";

        File diretorioOrigem = new File(urlDiretorioOrigem);
        File arquivoDestino = new File(urlArquivoDestino);

        if (!diretorioOrigem.isDirectory()) {
            System.out.println("A URL de origem não é um diretório ou o diretório não existe!!!");
            return;
        }

        File[] arquivos = diretorioOrigem.listFiles();

        if (arquivos != null) {
            Arrays.sort(arquivos);  // Deixar os arquivos em ordem alfabética

            for (File arquivo : arquivos) {
                if (arquivo.getAbsolutePath().equals(urlArquivoDestino)) {
                    // Pula a leitura do próprio arquivo de destino
                    continue;
                }

                String conteudo = lerArquivo(arquivo);
                escreverArquivo(conteudo, arquivoDestino);
            }

            System.out.println("Tudo pronto.");
            System.exit(0);
        } else {
            System.out.println("Erro de I/O!!!");
            System.exit(1);
        }
    }

    private static String lerArquivo(File arquivo) {
        StringBuilder builder = new StringBuilder();
        String linha;

        try (BufferedReader reader = new BufferedReader(new FileReader(arquivo))) {
            while ((linha = reader.readLine()) != null) {
                builder.append(linha);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return builder.toString();
    }

    private static void escreverArquivo(String conteudo, File arquivo) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(arquivo, true))) {
            writer.write(conteudo);
            writer.newLine();
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Belmires · 6 de outubro de 2019

Ele esta colocando as informações do próximo arquivo na frente do outro. Eu fiz esse codigo, mas agarrei fazendo uma função para ler o arquivo primeiro e comparar as linhas já contidas no arquivo antes de inserir, mas agarrei aqui e estou com duvida. Poderia me ajudar a proceder


package Unificar;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

public class Unificar {

    public static void main(String[] args) {
        try {
            Unificar programa = new Unificar();
            programa.executar();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private List<String> linhasCopiadas;

    private void executar() throws IOException {
        File diretorio = new File("C:\\Arq"); // Pasta de origem 
        File arquivoDestino = new File("C:\\Users\\Belmires\\Desktop\\Teste.txt"); // Pasta do novo arquivo criado
        PrintWriter destino = new PrintWriter(arquivoDestino);
        linhasCopiadas = new ArrayList<>();
        BufferedReader ler = new BufferedReader(new FileReader(arquivoDestino));
        ler(){
            
        
        }
        
        for (File arquivo : diretorio.listFiles()) {
            BufferedReader origem = new BufferedReader(new FileReader(arquivo));
            copiar(origem, destino);
            origem.close();
        }
        destino.flush();
        destino.close();
    }
//            Função que compara as linhas
    private void copiar(BufferedReader origem, PrintWriter destino) throws IOException {
        String linha = null;
        while ((linha = origem.readLine()) != null) {
            if (!linhasCopiadas.contains(linha)) { // Se a linha ainda não foi copiada pro arquivo de destino
                destino.println(linha); // Copia a linha no arquivo de destino
                linhasCopiadas.add(linha); // Joga a linha na lista de linhas copiadas
            }
        }
    }
    
    private void ler (BufferedReader destino){
        try {
            while (destino.ready()){
                linhasCopiadas.add(destino.readLine());
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

AdrianoSiqueira · 7 de outubro de 2019

O código que eu postei não serve para você?

Belmires · 7 de outubro de 2019

Meu problema e um pouco mais complicado. olha se da para você entender.

Estou querendo fazer a comparação antes “=” usando o split, para inserir a linha toda caso o valor da chave não seja igual, e fazer uma varredura no arquivo destino para comparar as linhas já contidas no arquivo e inserir apenas linhas novas. Estou pedindo demais, mas que sou nova na programação, agradeço desde já.

package Ler;

package Ler;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

public class Unificar {

    public static void main(String[] args) {
        try {
            Unificar programa = new Unificar();
            programa.executar();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private List < String > linhasCopiadas;

    private void executar() throws IOException {

        // Pasta de origem 
        File diretorio = new File("C:\\Arq");

        // Pasta do novo arquivo a ser criado
        File arquivoDestino = new File("C:\\Users\\p808176\\Desktop\\Teste.txt");
        PrintWriter destino = new PrintWriter(arquivoDestino);
        linhasCopiadas = new ArrayList < > ();

        BufferedReader ler = new BufferedReader(new FileReader(arquivoDestino));
        ler(BufferedReader origem) {
            String linha = null;

            while ((linha = origem.readLine()) != null) {
                chaveValor = linha.split("=");
            }
        }


        for (File arquivo: diretorio.listFiles()) {
            BufferedReader origem = new BufferedReader(new FileReader(arquivo));
            copiar(origem, destino);
            origem.close();
        }
        destino.flush();
        destino.close();
    }
    //          Função que compara as linhas para não se repetir
    private void copiar(BufferedReader origem, PrintWriter destino) throws IOException {
        String linha = null;
        String[] chaveValor;
        while ((linha = origem.readLine()) != null) {
            chaveValor = linha.split("=");
            //          System.out.println(chaveValor[0]);
            //          System.out.println(chaveValor[1]);

            if (!linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
                destino.println(linha); // Copia a linha no arquivo de destino
                linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
            }
        }
    }

    private void ler(BufferedReader destino) {
        try {
            while (destino.ready()) {
                linhasCopiadas.add(destino.readLine());
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }
    }
}

AdrianoSiqueira · 7 de outubro de 2019

Atá, então o arquivo de destino não pode ter linhas repetidas?

Belmires · 7 de outubro de 2019

Isso mesmo

Belmires · 8 de outubro de 2019

O programa esta encontrando os aquivos mas não esta lendo o arquivo destino e inserindo o as linhas não contidas nele, peço ajuda. agradeço desde ja

package Ler;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Unificar  {

    public static void main(String[] args) {
      	ProcurarArquivos e = new ProcurarArquivos();
        // Exemplo :
        List<String> extensions = Arrays.asList(new String[] {
            "ApplicationResources.properties"
        });
        List<File> files = e.listFiles(new File("c:\\"), extensions);
        for (File f : files) {
            System.out.println(f.getAbsolutePath());
            
        }
    	
        try {
        	Unificar programa = new Unificar();
            programa.executar();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    public List<File> listFiles(File directory) {
        List<File> files = new ArrayList<File>();
        listFiles(files, directory);
        return files;
    }

    private void listFiles(List<File> files, File directory) {
        File[] filesAndSubdirectories = directory.listFiles();
        if (filesAndSubdirectories != null) {
            for (File file : filesAndSubdirectories) {
                if (file.isDirectory()) {
                    listFiles(files, file);
                } else {
                    files.add(file);
                }
            }
        }
    }
    
    private List<String> linhasCopiadas;
	private File f;

    private void executar() throws IOException {
    	
		f = null;
		// Pasta de origem 
        File diretorio = new File(f.getAbsolutePath()); 
        
        // Pasta do novo arquivo a ser criado
        File arquivoDestino = new File("C:\\Users\\p808176\\Desktop\\Teste.txt"); 
        PrintWriter destino = new PrintWriter(arquivoDestino);
//        PrintWriter arquivo = new PrintWriter(diretorio);
        linhasCopiadas = new ArrayList<>();
        BufferedReader ler = new BufferedReader(new FileReader(arquivoDestino));
        BufferedReader origem = new BufferedReader(new FileReader(diretorio));
      
        
        
        
        // Lendo o arquivo de 
         ler(ler); 
    	  String linha = null;
          String[] chaveValor; 
          while ((linha = ler.readLine()) != null) {
          	chaveValor = linha.split("=");
          	 if (!linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
                 destino.println(linha); // Copia a linha no arquivo de destino
                 linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
             }
          }
      
        
        for (File arquivo : diretorio.listFiles()) {
            copiar(origem, destino);
            origem.close();
        }
        destino.flush();
        destino.close();
    }
    

//    		Função que compara as linhas para não se repetir
    private void copiar(BufferedReader origem, PrintWriter destino) throws IOException {
        String linha = null;
        String[] chaveValor; 
        while ((linha = origem.readLine()) != null) {
        	chaveValor = linha.split("=");
//        	System.out.println(chaveValor[0]);
//        	System.out.println(chaveValor[1]);
        
            if (!linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
                destino.println(linha); // Copia a linha no arquivo de destino
                linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
            }
        }
    }
 
  private void ler (BufferedReader arquivoDestino){
	try {
		while (arquivoDestino.ready()){
			linhasCopiadas.add(arquivoDestino.readLine());
		}
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();

	}
  }
  private boolean endsWith(File filename, List<String> extensions) {
      String name = filename.getName();
      for (String ext : extensions) {
          if (name.toLowerCase().endsWith(ext.toLowerCase()))
              return true;
      }
      return false;
  }

  public List<File> listFiles(File directory, List<String> extensions) {
      List<File> files = new ArrayList<File>();
      listFiles(files, directory, extensions);
      return files;
  }

  private void listFiles(List<File> files, File directory, List<String> extensions) {
      File[] filesAndSubdirectories = directory.listFiles();
      if (filesAndSubdirectories != null) {
          for (File file : filesAndSubdirectories) {
              if (file.isDirectory()) {
                  listFiles(files, file, extensions);
              } else {
                  if (endsWith(file, extensions)) {
                      files.add(file);
                  }
              }
          }
      }
  }
  
  
  
}

AdrianoSiqueira · 9 de outubro de 2019

Pelos testes que fiz aqui, acho que esse código dará certo:

package codigo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

public class Programa {
    public static void main(String[] args) {
        final String urlPastaOrigem = "/tmp/Programa";
        final String urlArquivoDestino = "/tmp/Programa/destino.txt";

        File pastaOrigem = new File(urlPastaOrigem);
        File arquivoDestino = new File(urlArquivoDestino);

        /*
        Se o arquivo de destino existir, a lista de linhas será iniciada já com
        as linhas do próprio arquivo, caso contrário a lista será criada em branco.

        Saiba mais: Operador ternário.
         */
        Set<String> linhasDestino = arquivoDestino.exists()
                ? new LinkedHashSet<>(ler(arquivoDestino))
                : new LinkedHashSet<>();

        // Lista os arquivos da pasta e realiza alguns testes.
        File[] arquivos = pastaOrigem.listFiles();

        if (arquivos == null) {
            System.out.println("Pasta de origem não é uma pasta.");
            return;
        } else if (arquivos.length == 0) {
            System.out.println("Pasta de origem está vazia.");
            return;
        }

        // Deixa os arquivos em ordem alfabética.
        Arrays.sort(arquivos);

        Set<String> linhasNovas = new LinkedHashSet<>();

        for (File arquivo : arquivos) {
            if (arquivo.getAbsolutePath().equals(arquivoDestino.getAbsolutePath())) {
                // Pula a leitura do próprio arquivo de destino.
                continue;
            }

            linhasNovas.addAll(ler(arquivo));
        }

        /*
        Prepara o conteúdo final para ser escrito no arquivo,
        esse conteúdo é formado pela união das linhas atuais e novas.
         */
        StringBuilder conteudoFinal = new StringBuilder();

        for (String linha : linhasDestino) {
            conteudoFinal.append(linha)
                    .append(System.lineSeparator());
        }

        for (String linha : linhasNovas) {
            if (linhasDestino.contains(linha)) {
                // Se a linha já existir, ela será pulada.
                continue;
            }

            conteudoFinal.append(linha);
            conteudoFinal.append(System.lineSeparator());
        }

        // Substitui todo o conteúdo do arquivo de destino
        escrever(conteudoFinal.toString(), arquivoDestino);

        // Execução bem sucedida.
        System.out.println("Tudo pronto");
        System.exit(0);
    }

    /**
     * Lê as linhas do arquivo e gera um {@link Set} contendo elas.
     * Automaticamente não serão aceitas linhas repetidas.
     *
     * @param arquivo Arquivo para ler as linhas.
     *
     * @return Set contendo as linhas do arquivo.
     */
    private static Set<String> ler(File arquivo) {
        String linha;
        Set<String> linhas = new LinkedHashSet<>();

        try (BufferedReader reader = new BufferedReader(new FileReader(arquivo))) {
            while ((linha = reader.readLine()) != null) {
                linhas.add(linha);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return linhas;
    }

    /**
     * Escreve o novo conteúdo dentro do arquivo de destino substituindo o conteúdo antigo.
     *
     * @param conteudo       O que deve ser escrito no arquivo.
     * @param arquivoDestino Arquivo que receberá o conteúdo.
     */
    private static void escrever(String conteudo, File arquivoDestino) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(arquivoDestino))) {
            writer.write(conteudo);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Belmires · 9 de outubro de 2019

Bom dia, como ficaria esse código com uma busca por aquivos com o mesmo nome, e a comparação dentro desses arquivos sendo feita apenas com a chave das linhas contidas nesses arquivos, como nesse exemplo que eu respondi por ultimo.

Exemplo de informações que estão no arquivo

chave = valor

desenvolvi esse código, mas não esta lendo as informações que já estão no aquivo de destino e esta apagando e parece que esta esta copiando para o arquivo de destino apenas as linha que são diferentes entre todos arquivos

package Ler;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Unificar {

    public static void main(String[] args) throws IOException {
        ProcurarArquivos e = new ProcurarArquivos();
        // Aruivos a serem procurados
        List<String> extensions = Arrays.asList(new String[] { "ApplicationResources.properties" });
        Unificar prog = new Unificar();
        // Caminho onde vai ser procurar
        List<File> files = e.listFiles(new File("c:\\"), extensions);
        for (File f : files) {
            BufferedReader arquivoFile = new BufferedReader(new FileReader(f));
            prog.modifica(arquivoFile);
//            System.out.println(f.getAbsolutePath());

        }

        try {
            Unificar programa = new Unificar();
            programa.executar();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    public List<File> listFiles(File directory) {
        List<File> files = new ArrayList<File>();
        listFiles(files, directory);
        return files;
    }

    private void listFiles(List<File> files, File directory) {
        File[] filesAndSubdirectories = directory.listFiles();
        if (filesAndSubdirectories != null) {
            for (File file : filesAndSubdirectories) {
                if (file.isDirectory()) {
                    listFiles(files, file);
                } else {
                    files.add(file);
                }
            }
        }
    }

    private List<String> linhasCopiadas;

    private void executar() throws IOException {

    }

    // Função que compara as linhas para não se repetir
    private void copiar(BufferedReader origem, PrintWriter destino)
            throws IOException {
        String linha = null;
        String[] chaveValor;
        while ((linha = origem.readLine()) != null) {
            chaveValor = linha.split("=");
            // System.out.println(chaveValor[0]);
            // System.out.println(chaveValor[1]);

            if (!linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
                destino.println(linha); // Copia a linha no arquivo de destino
                linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
            }
        }
    }

    private void ler(BufferedReader arquivoDestino) {
        try {
            while (arquivoDestino.ready()) {
                linhasCopiadas.add(arquivoDestino.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();

        }
    }

    private boolean endsWith(File filename, List<String> extensions) {
        String name = filename.getName();
        for (String ext : extensions) {
            if (name.toLowerCase().endsWith(ext.toLowerCase()))
                return true;
        }
        return false;
    }

    public List<File> listFiles(File directory, List<String> extensions) {
        List<File> files = new ArrayList<File>();
        listFiles(files, directory, extensions);
        return files;
    }

    private void listFiles(List<File> files, File directory,
            List<String> extensions) {
        File[] filesAndSubdirectories = directory.listFiles();
        if (filesAndSubdirectories != null) {
            for (File file : filesAndSubdirectories) {
                if (file.isDirectory()) {
                    listFiles(files, file, extensions);
                } else {
                    if (endsWith(file, extensions)) {
                        files.add(file);
                    }
                }
            }
        }
    }

    public void modifica(BufferedReader origem) throws IOException {

        File arquivoDestino = new File("C:\\Users\\p808176\\Desktop\\Teste.txt");
        PrintWriter destino = new PrintWriter(arquivoDestino);
        // PrintWriter arquivo = new PrintWriter(diretorio);
        linhasCopiadas = new ArrayList<>();
        BufferedReader ler = new BufferedReader(new FileReader(arquivoDestino));
        // BufferedReader origem = new BufferedReader(new
        // FileReader(diretorio));

        // Lendo o arquivo de
        ler(ler);
        String linha = null;
        String[] chaveValor;
        while ((linha = ler.readLine()) != null) {
            chaveValor = linha.split("=");
            if (!linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
                destino.println(linha); // Copia a linha no arquivo de destino
                linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
            }
        }

        copiar(origem, destino);
        origem.close();

        destino.flush();
        destino.close();
    }

}

AdrianoSiqueira · 9 de outubro de 2019

Você pode postar o código das classes ProcurarArquivos e Unificar? Porque do jeito que está eu não consigo reproduzir.

Belmires · 11 de outubro de 2019

Desenvolvi um pouco mais o código mas agora ele esta copiando linhas iguais. e tenho que compara primeiro o valor antes do "=" e se for diferente acrescenta ao arquivo se for igual faz a comparação com o valor depois do "=" se for igual não acrescenta se for diferente acrescenta no arquivo adicionado mais um comentário na linha para identificação depois do arquivo p

pronto.

package Unificar;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author p808176
 *
 */
public class Unificar {

	public static void main(String[] args) throws IOException {
		ProcurarArquivos e = new ProcurarArquivos();
		// Nome dos arquivos a serem procurados
		List<String> extensions = Arrays.asList(new String[] { "ApplicationResources.properties" });
		Unificar prog = new Unificar();
		// Caminho onde vai ser procurar
		List<File> files = e.listFiles(new File("C:\\powerlogic\\workspaces\\workspace_producao"), extensions);
		for (File f : files) {
			if(!f.getAbsoluteFile().toString().contains("classes")){
				BufferedReader arquivoFile = new BufferedReader(new FileReader(f));
				prog.modifica(arquivoFile);
				
			// Ira printar os caminhos dos arquivos encontrados
				System.out.println(f.getAbsolutePath());
		}
		}
		System.out.println("Arquivo de unificação feito com sucesso");
		try {
			Unificar programa = new Unificar();
			programa.executar();
		} catch (Throwable t) {
			t.printStackTrace();
		}
	}

	private List<String> linhasCopiadas;

	void executar() throws IOException {

	}

	private void ler(BufferedReader arquivoDestino) {
		try {
			String linha = "";
			while ((linha = arquivoDestino.readLine()) != null) {
				linhasCopiadas.add(linha);
			}
		} catch (IOException e) {
			e.printStackTrace();

		}
	}


	public void modifica(BufferedReader files) throws IOException {

		File arquivoDestino = new File("C:\\Users\\p808176\\Desktop\\Teste.txt");
		Writer destino = new BufferedWriter(new FileWriter(arquivoDestino, true));
		linhasCopiadas = new ArrayList<>();
		BufferedReader ler = new BufferedReader(new FileReader(arquivoDestino));


		// Lendo o arquivo de Destino e acrescentar apenas valores diferentes
		ler(ler);
		String linha = null;
		String[] chaveValor;
		String newLine = System.getProperty("line.separator");
		
		while ((linha = files.readLine()) != null) {
			chaveValor = linha.split("=");
			
			if (linhasCopiadas.contains(chaveValor[0])) { // Se a linha ainda não foi copiada pro arquivo de destino
				destino.write(newLine+linha); // Copia a linha no arquivo de destino
				linhasCopiadas.add(chaveValor[0]); // Joga a linha na lista de linhas copiadas
			}

		}
		files.close();
		destino.flush();
		destino.close();
	}

}
          
package Unificar;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class ProcurarArquivos {

    public List<File> listFiles(File directory) {
        List<File> files = new ArrayList<File>();
        listFiles(files, directory);
        return files;
    }

    private void listFiles(List<File> files, File directory) {
        File[] filesAndSubdirectories = directory.listFiles();
        if (filesAndSubdirectories != null) {
            for (File file : filesAndSubdirectories) {
                if (file.isDirectory()) {
                    listFiles(files, file);
                } else {
                    files.add(file);
                }
            }
        }
    }

    private boolean endsWith(File filename, List<String> extensions) {
        String name = filename.getName();
        for (String ext : extensions) {
            if (name.toLowerCase().endsWith(ext.toLowerCase()))
                return true;
        }
        return false;
    }

    public List<File> listFiles(File directory, List<String> extensions) {
        List<File> files = new ArrayList<File>();
        listFiles(files, directory, extensions);
        return files;
    }

    private void listFiles(List<File> files, File directory, List<String> extensions) {
        File[] filesAndSubdirectories = directory.listFiles();
        if (filesAndSubdirectories != null) {
            for (File file : filesAndSubdirectories) {
                if (file.isDirectory()) {
                    listFiles(files, file, extensions);
                } else {
                    if (endsWith(file, extensions)) {
                        files.add(file);
                    }
                }
            }
        }
    }

}

AdrianoSiqueira · 11 de outubro de 2019

Eu dividi em três classes para ficar mais fácil

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class GerenciadorArquivo {

    /**
     * Procura os arquivos dentro do diretório.
     *
     * @param diretorioOrigem Pasta onde deve ser realizada a busca.
     *
     * @return Uma lista com os arquivos encontrados.
     */
    public List<File> listarArquivos(File diretorioOrigem) {
        Objects.requireNonNull(diretorioOrigem, "Diretório de origem não pode ser null.");

        List<File> arquivos = new ArrayList<>();
        listar(diretorioOrigem, arquivos);

        return arquivos;
    }

    /**
     * Função auxiliar para percorrer recursivamente os subdiretórios da pasta de origem.
     *
     * @param diretorioOrigem Pasta de origem onde deve ser realizada a busca.
     * @param arquivos        Lista onde colocar os arquivos.
     */
    private void listar(File diretorioOrigem, List<File> arquivos) {
        File[] items = diretorioOrigem.listFiles();
        Objects.requireNonNull(items, "Diretório de origem não existe ou não é um diretório.");

        for (File item : items) {
            if (item.isDirectory()) {
                listar(diretorioOrigem, arquivos);
            } else {
                arquivos.add(item);
            }
        }
    }

    /**
     * Lê o conteúdo do arquivo e armazena as linhas dentro de uma lista.
     *
     * @param arquivo Arquivo que deve ser lido.
     *
     * @return Lista contendo as linhas do arquivo.
     */
    public List<String> ler(File arquivo) {
        Objects.requireNonNull(arquivo, "O arquivo não pode ser null.");

        List<String> linhas = new ArrayList<>();
        String linha;

        try (BufferedReader reader = new BufferedReader(new FileReader(arquivo))) {
            while ((linha = reader.readLine()) != null) {
                if (linha.contains("=")) {
                    // Só adiciona linhas válidas no formato [ chave=valor ]
                    linhas.add(linha);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return linhas;
    }

    /**
     * Escreve o novo conteúdo dentro do arquivo. Todo o conteúdo antigo será sobrescrito.
     *
     * @param conteudo O que deve ser escrito.
     * @param arquivo  Arquivo que será sobrescrito.
     */
    public void escrever(String conteudo, File arquivo) {
        Objects.requireNonNull(arquivo, "O arquivo não pode ser null.");

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(arquivo))) {
            writer.write(conteudo);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class GerenciadorLinhas {

    private Map<String, String> linhas;

    public GerenciadorLinhas() {
        linhas = new LinkedHashMap<>();
    }

    /**
     * Adiciona a linha no map de linhas.
     *
     * @param linha Linha a ser adicionada.
     */
    public void adicionarLinha(String linha) {
        String chave = linha.split("=")[0];
        String valor = linha.split("=")[1];

        if (!linhas.containsKey(chave)) {
            linhas.put(chave, valor);
        }
    }

    /**
     * Adiciona as linhas no map de linhas.
     *
     * @param linhas Linhas a serem adicionadas.
     */
    public void adicionarLinha(List<String> linhas) {
        linhas.forEach(this::adicionarLinha);
    }

    public Map<String, String> getLinhas() {
        return linhas;
    }
}

import java.io.File;
import java.util.Collections;
import java.util.List;
import java.util.Map;

public class Principal {

    public static void main(String[] args) {
        File diretorioOrigem = new File("/tmp/Programa");
        File arquivoDestino = new File("/tmp/Programa/destino.txt");

        GerenciadorArquivo gerenciadorArquivo = new GerenciadorArquivo();
        GerenciadorLinhas gerenciadorLinhas = new GerenciadorLinhas();

        List<File> arquivos = gerenciadorArquivo.listarArquivos(diretorioOrigem);
        arquivos.remove(arquivoDestino);
        Collections.sort(arquivos);

        if (arquivoDestino.exists()) {
            gerenciadorLinhas.adicionarLinha(gerenciadorArquivo.ler(arquivoDestino));
        }

        // Ler todos os arquivos
        for (File arquivo : arquivos) {
            gerenciadorLinhas.adicionarLinha(gerenciadorArquivo.ler(arquivo));
        }

        // Preparar para escrever
        StringBuilder builder = new StringBuilder();
        Map<String, String> map = gerenciadorLinhas.getLinhas();

        for (Map.Entry<String, String> entry : map.entrySet()) {
            builder.append(entry.getKey())
                    .append("=")
                    .append(entry.getValue())
                    .append(System.lineSeparator());
        }

        gerenciadorArquivo.escrever(builder.toString(), arquivoDestino);
    }
}