如何基於限制列出文件系統中的文件：java

Question

如何用開始編號和結束編號列出文件系統中可用的文件？

例如，如果C:\\Test\\有500文件，那么如何列出從1到20的文件

根據此列表提供start number and end number可用於特定文件路徑的文件。

我正在java中嘗試

我嘗試了類似的事情，它為我提供了給定路徑的所有可用文件

public static List<String> loadAllFiles(String filesLocation) {

        //find OS
        //String osName = System.getProperty("os.name");

        //replace file path based on OS
        filesLocation = filesLocation.replaceAll("\\\\|/", "\\"+System.getProperty("file.separator"));

        List<String> pdfFiles = new ArrayList<String>();
        if (log.isDebugEnabled()) {
            log.debug("In loadAllFiles execute start");
        }

        File directoryList = new File(filesLocation);
        File[] filesList = directoryList.listFiles();

        try {
            for (int count = 0; count < filesList.length; count++) {
                if (!filesList[count].isDirectory() && filesList[count].getName().endsWith(SPLIT_AND_SAVE_WORKING_FILE_EXTENSION.trim())) { 
                    // load only PDF  files
                    pdfFiles.add(filesList[count].getName().replace(SPLIT_AND_SAVE_WORKING_FILE_EXTENSION.trim(), ""));
                }
            }


        } catch (Exception filesException) {
            filesException.printStackTrace();
            //TODO : Log the exception
        } finally {

            if (filesList != null)
                filesList = null;

            if (directoryList != null)
                directoryList = null;
        }

        log.debug("In loadAllFiles execute end");

        return pdfFiles;
    }

I think the question is misunderstood, Say if i have 1000 files[file names can be anything] and i want to restrict getting the files name like i will give starting Number and ending number. like 1 to 20 and i want to load those 20 files alone. 

Answer 1

沒有使用純Java 7的外部庫的示例

import java.io.IOException;
import java.nio.file.DirectoryStream;
import static java.nio.file.DirectoryStream.Filter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

// list files starting with 1 till 20 "-.*"
public class FileNameFilter {

    private static final Filter<Path> fileNameFilter = new Filter<Path>() {
        @Override
        public boolean accept(Path entry) throws IOException {
            if (!Files.isRegularFile(entry)) {
                return false;
            }
            return entry.getFileName().toString().matches("^([1][0-9]{0,1}|2[0]{0,1})-.*");
        }
    };

    public static void main(String[] args) {
        final String filesLocation = "resources/";

        Path path = Paths.get(filesLocation);
        try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(path, fileNameFilter)) {
            for (Path entry : dirStream) {
                System.out.printf("%-5s: %s%n", "entry", entry.getFileName());
            }
        } catch (IOException e) {
            // add your exception handling here
            e.printStackTrace(System.err);
        }
    }
}

編輯 Java 8版本

// list files starting with 1 till 20 "-.*"
public class FileNameFilter {
    public static void main(String[] args) {
        final String filesLocation = "resources/";

        try {
            Files.walk(Paths.get(filesLocation))
                    .filter(p -> p.getFileName().toString().matches("^([1][0-9]{0,1}|2[0]{0,1})-.*"))
                    .forEach(entry -> {System.out.printf("%-5s: %s%n", "entry", entry.getFileName());});
        } catch (IOException e) {
            // add your exception handling here
            e.printStackTrace(System.err);
        }
    }
}

編輯2個示例以列出目錄中的前20個文件。
note注意文件的順序與在dir中運行ls或dir的順序相同。

Java 7示例

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileListLimiter {

private static final int MAX_FILES_TO_LIST = 20;

    public static void main(String[] args) {
        final String filesLocation = "resources/";

        Path path = Paths.get(filesLocation);
        try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(path)) {
            int fileCounter = 1;
            for (Path entry : dirStream) {
                System.out.printf("%-5s %2d: %s%n", "entry", fileCounter++, entry.getFileName());
                if (fileCounter > MAX_FILES_TO_LIST) {
                    break;
                }
            }
        } catch (IOException e) {
            // add your exception handling here
            e.printStackTrace(System.err);
        }
    }
}

Java 8示例

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class FileListLimiter {

private static final int MAX_FILES_TO_LIST = 20;

    public static void main(String[] args) {
        final String filesLocation = "resources/";

        try {
            Files.walk(Paths.get(filesLocation))
                    .filter(p -> p.toFile().isFile())
                    .limit(MAX_FILES_TO_LIST)
                    .forEach(entry -> {System.out.printf("%-5s: %s%n", "entry", entry.getFileName());});
        } catch (IOException e) {
            // add your exception handling here
            e.printStackTrace(System.err);
        }
    }
}

Answer 2

嘗試類似

final String pattern = "^[1-20].*";
final FileFilter filter = new RegexFileFilter(pattern);
final File[] files = directory.listFiles(filter);

Answer 3

為什么不使用這種邏輯。 它非常簡單，您將不需要任何替換或替換。我假設您將能夠非常輕松地將其轉換為代碼並轉換為Java。 我還沒有測試過正則表達式，但是您已經掌握了基本思想。

1.使用掃描儀（或任何其他方式）獲取開始和結束限制的輸入范圍。

2.創建目錄列表，掃描目錄中的每個文件。 在這里使用for循環。

3.定義一個正則表達式，僅獲取文件的起始數據。

      start pattern = (^[0-9]{0,2})[a-zA-Z].+[0-9]{0,2}$ use grouping in regular expression to fetch this group1

4.從group1中獲取值時，請檢查文件名是否以group1數據開頭。

5如果此數據位於您要搜索的范圍之間，則創建一個arraylist並將匹配的文件存儲在該arraylist中。

6.進行直到目錄結束的過程。 最終的arraylist將包含給定范圍內的文件。

希望這可以幫助

Answer 4

從Java 7開始，您可以利用Files＃walkFileTree 。 在visitFile期間，您可以使用正則表達式來查找您的特定文件。

像這樣

Path start = Paths.get(filesLocation);

Final Pattern pattern = Pattern.compile("^([1]?[0-9]|[2][0])\\.pdf");

Files.walkFileTree(start, new SimpleFileVisitor<>()  
{  
   @Override  
   public FileVisitResult visitFile(Path filePath, BasicFileAttributes attrs)  
      throws IOException  
   { 

    File f = filePath.toFile();
    if (pattern.matcher().matches(f.getName())) {
            System.out.println("Valid match found " + f.getName())
    }  
      return FileVisitResult.CONTINUE;  
   }  
});  

Answer 5

不確定我是否完全理解您的問題，但這是一個Java 8示例，該示例遍歷按名稱排序的目錄文件，從給定的偏移量開始，並將結果限制為給定的大小。 它還允許您從結果中包括/排除目錄。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collection;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class DirectoryWalkerTest {

    public static void main(final String... args) throws IOException {
        final String filesLocation = "/path/to/files";

        System.out.println(getFiles(filesLocation, true, 0, 10));
        System.out.println(getFiles(filesLocation, true, 10, 10));

        System.out.println(getFiles(filesLocation, false, 0, 10));
        System.out.println(getFiles(filesLocation, false, 10, 10));
    }

    /**
     * Returns a limited list of filenames starting at the given offset.
     *
     * @param filesLocation     the directory to scan
     * @param filterDirectories should we include directories in results
     * @param offset            the starting offset
     * @param limit             the maximum number of results
     * @return a collection of file names
     */
    private static Collection<String> getFiles(final String filesLocation, final boolean filterDirectories,
            final int offset, final int limit) throws IOException {
        Stream<Path> stream = Files.list(Paths.get(filesLocation));

        if (filterDirectories) {
            stream = stream.filter(path -> !Files.isDirectory(path));
        }

        return stream
                .map(Path::toString)
                .sorted()
                .skip(offset)
                .limit(limit)
                .collect(Collectors.toList());
    }

}

Answer 6

根據您的代碼，您可以嘗試以下操作：

int begin = 0;
int limit = 10;
for (int count = 0; count < filesList.length; count++)
{
    if (!filesList[count].isDirectory() && filesList[count].getName().endsWith(SPLIT_AND_SAVE_WORKING_FILE_EXTENSION.trim()))
    {
        // moving to begin index, only if the file is not a directory and is matching your criteria, whatever it is
        if (count < begin) continue;

        // load only PDF  files
        pdfFiles.add(filesList[count].getName().replace(SPLIT_AND_SAVE_WORKING_FILE_EXTENSION.trim(), ""));
    }

    // Stopping when limit is reached
    if (pdfFiles.size() == limit) break;
}

它將根據您的標准begin編制索引並獲得limit項目。

Answer 7

我玩了一下，想出了一些對我有用的東西。 也許您可以找到所需的零件。 如果您不希望使用完整路徑，只需刪除getCanonicalPath（）。

    import java.io.File;
    import java.io.FilenameFilter;
    import java.io.IOException;
    import java.util.ArrayList;

    public class GetFirst_20_pdf_files {

        // Creating an empty array list with 10 entries (the default)
        ArrayList<String> pdfFiles = new ArrayList<String>();

        public ArrayList<String> myList() {
            // here you can get start and end from user
            int start = 2;
            int end   = 4;
            // and set the directory
            String filesLocation = ".";

            File directoryList = new File(filesLocation); 
            File[] files = directoryList.listFiles();
            int count = 0;
            for (File file : files) {
                // don't want directories
                if (file.isDirectory()) { continue; }
                // want ".pdf" files only
                if (!file.getName().toLowerCase().endsWith(".pdf")) { continue; }
                // only want between start and end
                count++;
                if (count >= start && count <= end) {
                try {
                     pdfFiles.add(file.getCanonicalPath());
                 } catch (IOException e) {
                     System.out.println(e);
                 }

                 if (count >= end) { return pdfFiles; }
                }
            }
            return pdfFiles;
        }

        public static void main(String[] args) throws IOException {

            GetFirst_20_pdf_files L = new GetFirst_20_pdf_files();
            ArrayList<String> aList = L.myList();

            for (String p : aList) {
                System.out.println(p);
            }
        }
    }