Как просмотреть файлы в файловой системе на основе лимита: java

Question

Как указать файлы, доступные в файловой системе, с начальным номером и конечным номером?

как если есть 500 файлы в C:\Test\ тогда как список файлов, начиная с 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

Попробуйте что-то вроде

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

Answer 2

почему не используйте эту логику. его довольно прямолинейно, и вам не понадобится замена или замена. Предположим, вы сможете легко преобразовать это в код в Java. Я не тестировал регулярное выражение, но вы получили основную идею.

1.use scanner (или любым другим способом), чтобы получить диапазоны ввода для начала и конечного предела.

2.создайте список каталогов, просматривающих каждый файл в каталоге. используйте цикл for здесь.

3.define регулярное выражение для извлечения только начальных данных для файла.

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

4. Когда вы получите значения из группы1, проверьте имя файла, если оно начинается с данных группы1.

5 Если эти данные попадают между диапазонами, которые вы хотите найти, создайте arraylist и сохраните сопоставленный файл в arraylist.

6.Показать процесс до конца справочника. Конечный arraylist будет содержать ваши файлы в заданных диапазонах.

надеюсь, что это помогает

Answer 3

Начиная с 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 4

Пример без внешних библиотек, используя обычный 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); 
     } 
    } 
} 

редактировать Ява 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 файлов в каталоге.
примечание Порядок файлов такой же, как вы бы запускали 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 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); 
      } 
     } 
    }