Speichern von Dateien mit der angegebenen Erweiterung unter dem in Java angegebenen Verzeichnis in der Liste

Hintergrund

Wenn eine große Anzahl von Dateien in Java ausgeführt werden muss, ist es durchweg einfacher, den Auflistungsteil in Java zu implementieren, als ihn mit dem Befehl find des Terminals aufzulisten und dann an Java zu übergeben. Also habe ich diesen Code geschrieben.

Codeübersicht

Dieses Programm verwendet den Verzeichnisnamen und die Erweiterung als Argumente, durchsucht das angegebene Verzeichnis und die darunter liegenden Verzeichnisse und speichert die Datei mit der angegebenen Erweiterung in "ArrayList". Hier finden Sie die m4a-Datei im iTunes-Ordner und speichern sie in der Liste.

Der obige Code verwendet die neuen Java 8-Lambda-Ausdrücke (Lambda-Ausdrücke) und Streams ( Stream). Im Folgenden finden Sie Code, der keine Lambda-Ausdrücke und Streams verwendet. (Möglicherweise funktioniert es mit Java, das älter als Java 8 ist.)

Java 8 oder höher

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.stream.Stream;

public class Utils {
    public static void main(String[] args) throws IOException {
        // To list up m4a files in iTunes directory
        Path rootDir = Paths.get(System.getProperty("user.home"), "Music", "iTunes");
        String extension  = "m4a";

        // for standard inputs
        if (args.length == 2) {
            rootDir = Paths.get(args[0]);
            extension   = args[1];
        } else if (args.length != 0){
            System.err.println("Error: set correct args.");
        }

        if (!Pattern.matches("^[0-9a-zA-Z]+$", extension)) {
            System.err.println("Error: set correct extension. (only alphabet and numeric)");
        } else {
            ArrayList<File> fileList = listUpFiles(rootDir, extension);
            for (File file : fileList) {
                System.out.println(file.getAbsolutePath());
            }
            System.out.println(fileList.size());    
        }
    }

    /**
     * list up files with specified file extension (extension)
     * under the specified directory (rootDir) recursively.
     * @param rootDir   : root directory
     * @param extension : string needs to be contained as file extension
     * @return          : list of files
     */
     public static ArrayList<File> listUpFiles(Path rootDir, String extension){
        String extensionPattern = "." + extension.toLowerCase();
        final ArrayList<File> fileList = new ArrayList();

        try (final Stream<Path> pathStream = Files.walk(rootDir)) {
            pathStream
                    .map(path -> Path::toFile)
                    .filter(file -> !file.isDirectory())
                    .filter(file -> file.getName().toLowerCase().endsWith(extensionPattern))
                    .forEach(fileList::add);
        } catch (final IOException e) {
            e.printStackTrace();
        }
        return (fileList);
    }
}

Code, der keine Lambda-Ausdrücke und Streams verwendet

import java.io.File;
import java.util.regex.Pattern;
import java.util.ArrayList;

public class UtilsOld {

    public static void main(String[] args) {
        // To list up m4a files in iTunes directory
        String rootDirName = System.getProperty("user.home") + java.io.File.separator +
                             "Music" + java.io.File.separator + "iTunes";
        String extension  = "m4a";

        // for standard input
        if (args.length == 2) {
            rootDirName = args[0];
            extension   = args[1];
        } else if (args.length != 0){
            System.err.println("Error: set correct args.");
        }

        if (!Pattern.matches("^[0-9a-zA-Z]+$", extension)) {
            System.err.println("Error: set correct extension. (only alphabet and numeric)");
        } else {
            String extensionPattern = "." + extension.toLowerCase();

            ArrayList<File> fileList = new ArrayList();
            fileList = listUpFiles(rootDirName, extensionPattern, fileList);

            for (File file : fileList) {
                System.out.println(file.getAbsolutePath());
            }
            System.out.println(fileList.size());
        }
    }

    /**
     * list up files with specified file extension (ext)
     * under the specified directory (rootDirName) recursively.
     *
     * @param rootDirName      : root directory name
     * @param extensionPattern : regular expression pattern of file extension
     * @param fileArrayList    : ArrayList to store files
     * @return : return fileArrayList
     */
    public static ArrayList listUpFiles(String rootDirName, String extensionPattern, ArrayList<File> fileArrayList){
        File rootDir = new File(rootDirName);
        File[] listOfFiles = rootDir.listFiles();
        assert listOfFiles != null;

        for (File item : listOfFiles) {
            if (item.isDirectory()) {
                fileArrayList = listUpFiles(item.getAbsolutePath(), extensionPattern, fileArrayList);
            } else if (item.isFile()) {
                String fileName = item.getName().toLowerCase();
                if (fileName.endsWith(extensionPattern)) {
                    fileArrayList.add(item);
                }
            }
        }
        return(fileArrayList);
    }
}

Referenz

Kommentar von saka1029 https://www.javacodegeeks.com/2014/05/playing-with-java-8-lambdas-paths-and-files.html