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... args) 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 file, BasicFileAttributes attrs
    ) throws IOException {
      System.out.println("Processing file:" + file);
      return FileVisitResult.CONTINUE;
    }
    
    @Override  public FileVisitResult preVisitDirectory(
      Path dir, BasicFileAttributes attrs
    ) throws IOException {
      System.out.println("Processing directory:" + dir);
      return FileVisitResult.CONTINUE;
    }
  }
} 

The File class has methods for listing the contents of a single directory, such as list and listFiles, but there is no method for listing all files in a directory tree.

Here's a simple utility which returns a sorted List of File objects which reside under a given root directory. It uses recursion.

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 args - <tt>args[0]</tt> is the full name of an existing 
  * directory that can be read.
  */
  public static void main(String... args) throws FileNotFoundException {
    File startingDirectory= new File(args[0]);
    FileListing listing = new FileListing();
    List<File> files = listing.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 startingDir is a valid directory, which can be read.
  */
  public List<File> getFileListing(
    File startingDir
  ) throws FileNotFoundException {
    validateDirectory(startingDir);
    List<File> result = getFileListingNoSort(startingDir);
    Collections.sort(result);
    return result;
  }

  // PRIVATE

  private List<File> getFileListingNoSort(
    File startingDir
  ) throws FileNotFoundException {
    List<File> result = new ArrayList<>();
    File[] filesAndDirs = startingDir.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.
  */
  private void validateDirectory (
    File directory
  ) throws FileNotFoundException {
    if (directory == null) {
      throw new IllegalArgumentException("Directory should not be null.");
    }
    if (!directory.exists()) {
      throw new FileNotFoundException("Directory does not exist: " + directory);
    }
    if (!directory.isDirectory()) {
      throw new IllegalArgumentException("Is not a directory: " + directory);
    }
    if (!directory.canRead()) {
      throw new IllegalArgumentException("Directory cannot be read: " + directory);
    }
  }
} 

>java -cp . FileListing "C:\\TEMP\\"
C:\\TEMP\\Hokkaido.txt
C:\\TEMP\\Honshu.txt
C:\\TEMP\\mb
C:\\TEMP\\mb\\Kyushu.txt
C:\\TEMP\\mb\\Shikoku.txt