Filtragem de multiplos arquivos usando o Regex

Programação Java
, ,
#1

Bom dia, eu sou novo na linguagem de programação e decidi criar uma conta aqui para ver se encontro alguma ajuda.

Meu conhecimento é deveras limitado pelo fato de eu ser um estagiário de uma escola técnica, a empresa a qual estou estagiando pediu para eu fazer um programa em Java de busca de informações em arquivos e estou com dificuldade para juntar dois códigos um que faz a varredura no disco C e encontra somente os arquivos pdf e txt(só estou trabalhando com esse por enquanto), e outro utilizando o regex que identifica se o arquivo tem a informação que quero ou não.

Isto é, eu gostaria que algum ser abençoado me desce um norte de como proceder pois estou fazendo isso sozinho, sem um supervisor só aprendendo sozinho e pesquisando e aprendendo, a ideia é pegar esses arquivos lidos tanto pdf quanto txt e filtrar aqueles que contem as informações que eu quero .

Leitor de arquivos somente em pdf e txt:

import java.io.File;


public class mhe {
    private static String extension = "none";
    private static String fileName;

    public static void main(String[] args ){
        String dir = "C:\\";
        File aFile = new File(dir);
        ReadDirectory(aFile);
    }
    private static void ReadDirectory(File aFile) {
        File[] listOfFiles = aFile.listFiles();
        if (aFile.isDirectory()) {
             listOfFiles = aFile.listFiles();
            if(listOfFiles!=null) {
                 for (File listOfFile : listOfFiles) {
                     if (listOfFile.isFile()) {
                         fileName = listOfFile.toString();
                         int dotPos = fileName.lastIndexOf(".");
                         if (dotPos > 0) {
                             extension = fileName.substring(dotPos);
                         }if (extension.equals(".txt") || extension.equals(".pdf")) {
                             System.out.println("FILE:" + listOfFile);
                         }
                     }
                     if (listOfFile.isDirectory()) {
                         ReadDirectory(listOfFile);
                     }
                 }
            }
        }
    }
}

Regex que encontra informações(CPF) no arquivo:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BuscaCPF {

    public static void main(String[] args) throws FileNotFoundException {
        {
            File doc = new File("C:\\temp\\in.txt");

            Scanner obj = new Scanner(doc);
            while (obj.hasNext()) {
                String objt = obj.next();
                Pattern p = Pattern.compile("[0-9]{3}[.][0-9]{3}[.][0-9]{3}[-][0-9]{2}");
                Matcher m = p.matcher(objt);
                boolean matchFound = m.find();
                if (matchFound) {
                    System.out.println(objt);
                } else {
                    System.out.println("Não encontrado");
                }
            }
        }
    }
}
#2

Desde o Java 7 você pode usar as classes do pacote java.nio, que facilitam um pouco as coisas (como java.nio.file.Files, java.nio.file.Path e java.nio.file.Paths).

Primeiro, se quer reusar o código de uma classe em outra, uma solução seria ter um método que faz a busca em um arquivo:

public class BuscaCPF {
    private Pattern pattern;
    public BuscaCPF(Pattern pattern) {
        this.pattern = pattern;
    }
    public void buscar(Path arq) {
        try {
            Files.lines(arq).filter(line -> this.pattern.matcher(line).find()).forEach(System.out::println);
        } catch (IOException ex) {
            // erro, mostra alguma mensagem, etc
        }
    }
}

Ou seja, ela recebe um Pattern e faz a busca deste em um arquivo, imprimindo as linhas encontradas (não vejo sentido em imprimir “não encontrado” para cada linha que não satisfaz o critério de busca, então tirei isso).

Aí basta criar uma instância com o pattern desejado e usá-la na sua busca:

public static void main(String args[]) throws Exception {
    String diretorio = "diretorio"; // diretório de onde a busca começa
    BuscaCPF busca = new BuscaCPF(Pattern.compile("[0-9]{3}[.][0-9]{3}[.][0-9]{3}[-][0-9]{2}"));
    Files.find(Paths.get(diretorio), Integer.MAX_VALUE,
        // somente arquivos com extensão pdf e txt
        (path, attr) -> attr.isRegularFile() && (path.toString().endsWith(".pdf") || path.toString().endsWith(".txt")))
        .forEach(busca::buscar);
}

Obs: eu ainda faria a busca retornar uma lista com as linhas encontradas, em vez de só imprimir. Aí quem chama o método de busca faz o que quiser com a lista (podendo inclusive imprimir, mas não fica limitado a isso).

1 curtida