Reading all the files in a folder recursively Java

Question

I need to write a program to read folder path from stdin and all it's subfolders and then print out the number of files according to their extension.

it will be compiled as follows:

java Summary -r <path>

the output needs to look like:

txt:
  number of files: 5
  combined size: 1202131
  largest file: 729224
  smallest file: 12323
pdf:
  number of files: 2
  etc...

can someone please help me with this? I'm not sure how to approach it.

what java version are you using? – kritzikratzi Sep 20 '12 at 09:09 — kritzikratzi, Sep 20 '12 at 09:09

score 6 · Accepted Answer · edited May 23 '17 at 12:06

you can start with something like this for reading files recursively

public void listFilesForFolder(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry);
        } else {
            System.out.println(fileEntry.getName());
        }
    }
}

This code is by @rich.

The rest of the details is something that you have to work out.

You can see Read all files in a folder for more details

score 0 · Answer 2 · edited May 23 '17 at 11:58

0

Take a look at this: List files from directories and sub directories in java including only partial file paths

You'll get a list of all files under your directory, and then you can use file.length() to get the size.

edited May 23 '17 at 11:58

Community

1
1

answered Sep 20 '12 at 09:09

Osiris

4,195
2
22
52

score 0 · Answer 3 · answered Sep 20 '12 at 09:10

something simillar to this code (from http://www.javapractices.com/topic/TopicAction.do?Id=68):

in JDK 7:

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;

/** Recursive listing with SimpleFileVisitor in JDK 7. */
public final class FileListingVisitor {

  public static void main(String... aArgs) throws IOException{
    String ROOT = "C:\\test";
    FileVisitor<Path> fileProcessor = new ProcessFile();
    Files.walkFileTree(Paths.get(ROOT), fileProcessor);
  }

  private static final class ProcessFile extends SimpleFileVisitor<Path> {
    @Override public FileVisitResult visitFile(
      Path aFile, BasicFileAttributes aAttrs
    ) throws IOException {
      System.out.println("Processing file:" + aFile);
      return FileVisitResult.CONTINUE;
    }

    @Override  public FileVisitResult preVisitDirectory(
      Path aDir, BasicFileAttributes aAttrs
    ) throws IOException {
      System.out.println("Processing directory:" + aDir);
      return FileVisitResult.CONTINUE;
    }
  }
}

in older:

import java.util.*;
import java.io.*;

/**
* Recursive file listing under a specified directory.
*  
* @author javapractices.com
* @author Alex Wong
* @author anonymous user
*/
public final class FileListing {

  /**
  * Demonstrate use.
  * 
  * @param aArgs - <tt>aArgs[0]</tt> is the full name of an existing 
  * directory that can be read.
  */
  public static void main(String... aArgs) throws FileNotFoundException {
    File startingDirectory= new File(aArgs[0]);
    List<File> files = FileListing.getFileListing(startingDirectory);

    //print out all file names, in the the order of File.compareTo()
    for(File file : files ){
      System.out.println(file);
    }
  }

  /**
  * Recursively walk a directory tree and return a List of all
  * Files found; the List is sorted using File.compareTo().
  *
  * @param aStartingDir is a valid directory, which can be read.
  */
  static public List<File> getFileListing(
    File aStartingDir
  ) throws FileNotFoundException {
    validateDirectory(aStartingDir);
    List<File> result = getFileListingNoSort(aStartingDir);
    Collections.sort(result);
    return result;
  }

  // PRIVATE //
  static private List<File> getFileListingNoSort(
    File aStartingDir
  ) throws FileNotFoundException {
    List<File> result = new ArrayList<File>();
    File[] filesAndDirs = aStartingDir.listFiles();
    List<File> filesDirs = Arrays.asList(filesAndDirs);
    for(File file : filesDirs) {
      result.add(file); //always add, even if directory
      if ( ! file.isFile() ) {
        //must be a directory
        //recursive call!
        List<File> deeperList = getFileListingNoSort(file);
        result.addAll(deeperList);
      }
    }
    return result;
  }

  /**
  * Directory is valid if it exists, does not represent a file, and can be read.
  */
  static private void validateDirectory (
    File aDirectory
  ) throws FileNotFoundException {
    if (aDirectory == null) {
      throw new IllegalArgumentException("Directory should not be null.");
    }
    if (!aDirectory.exists()) {
      throw new FileNotFoundException("Directory does not exist: " + aDirectory);
    }
    if (!aDirectory.isDirectory()) {
      throw new IllegalArgumentException("Is not a directory: " + aDirectory);
    }
    if (!aDirectory.canRead()) {
      throw new IllegalArgumentException("Directory cannot be read: " + aDirectory);
    }
  }
}

score 0 · Answer 4 · edited May 06 '14 at 05:46

Please use the following piece of code.

public static void listFiles(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isFile() && fileEntry.getName().endsWith(".txt")) {
            System.out.println(fileEntry.getName());
        }
    if (fileEntry.isFile() && fileEntry.getName().endsWith(".pdf")) {
            System.out.println(fileEntry.getName());
        }
     else {
            listFiles(fileEntry);
        }
    }
}

public static void main(String startingPath){
    File folder = new File(startingPath);
    listFiles(folder);
}

Reading all the files in a folder recursively Java

4 Answers4