Ir ao conteúdo
  • Cadastre-se
Belmires

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

Posts recomendados

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
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();
        }
    }
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

        }
    }
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Isso mesmo

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

}          

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

GRÁTIS: minicurso “Como ganhar dinheiro montando computadores”

Gabriel TorresGabriel Torres, fundador e editor executivo do Clube do Hardware, acaba de lançar um minicurso totalmente gratuito: "Como ganhar dinheiro montando computadores".

Você aprenderá sobre o quanto pode ganhar, como cobrar, como lidar com a concorrência, como se tornar um profissional altamente qualificado e muito mais!

Inscreva-se agora!