TL;DR: if you you need to filter out files/dirs by attributes - use Files.find(), if you don't need to filter by file attributes - use Files.walk().

Details

There is a slight difference which is actually explained in the documentation, but in a way that it feels completely wrong. Reading the source code makes it clear:

• Files.find:

  return StreamSupport.stream(...)
                          .onClose(iterator::close)
                          .filter(entry -> matcher.test(entry.file(), entry.attributes()))
                          .map(entry -> entry.file());
  

• Files.walk:

  return StreamSupport.stream(...)
                          .onClose(iterator::close)
                          .map(entry -> entry.file());
  

This means that if, in your eventual filter, you need to get and validate file attributes - chances are that File.find will be faster. That's because with File.walk, your filter callback will need an extra call to e.g. Files.readAttributes(file, BasicFileAttributes.class), while with File.find - the attributes are already retrieved and given to you in the filter callback.

I just tested it with my sample 10K-files-in-many-folders structure on Windows, by searching files only (i.e. excluding folders):

// pre-Java7/8 way via recursive listFiles (8037 files returned): 1521.657 msec.
for (File f : new File(dir).listFiles()) {
    if (f.isDirectory()) {
        _getFiles(files, path, pattern);
    } else {
        ...
    }
}

// Files.walk(8037 files returned): 1575.766823 msec.
try (Stream<Path> stream = Files.walk(path, Integer.MAX_VALUE) {
    files = stream.filter(p -> {
        if (Files.isDirectory(p)) { return false; } // this extra check makes it much slower than Files.find
        ... 
    }).map(p -> p.toString()).collect(Collectors.toList());
}

// Files.find(8037 files returned): 27.606675 msec.
try (Stream<Path> stream = Files.find(path, Integer.MAX_VALUE, (p, a) -> !a.isDirectory())) {
    files = stream.filter(p -> { ... }).map(p -> p.toString()).collect(Collectors.toList());
}

// Files.walkFileTree(8037 returned): 27.443974 msec.
Files.walkFileTree(new File(path).toPath(), new SimpleFileVisitor<Path>() { 
    @Override
    public FileVisitResult visitFile(Path p, BasicFileAttributes attrs) throws IOException {
        ...
        return FileVisitResult.CONTINUE;
    }
});

Really old question, but I still find it when I search for some directories reading ways.

Anyway, assylias commented the first post to add :

filter(p -> p.getFileName().startsWith("O_"))

Which is not working because there is missing the .toString() function. With this you can solve the problem by a more efficient way like it :

Files.walk(Paths.get(SOURCEDIR))
    .filter(p -> p.getFileName().toString().startsWith("O_"))
    .forEach(System.out::println);

Which one uses the Java 8 Syntax and provides you a standalone line which does the work.

This solution uses fnmatch.translate to convert glob patterns to regular expressions (it assumes the includes only is used for files):

import fnmatch
import os
import os.path
import re

includes = ['*.doc', '*.odt'] # for files only
excludes = ['/home/paulo-freitas/Documents'] # for dirs and files

# transform glob patterns to regular expressions
includes = r'|'.join([fnmatch.translate(x) for x in includes])
excludes = r'|'.join([fnmatch.translate(x) for x in excludes]) or r'$.'

for root, dirs, files in os.walk('/home/paulo-freitas'):

    # exclude dirs
    dirs[:] = [os.path.join(root, d) for d in dirs]
    dirs[:] = [d for d in dirs if not re.match(excludes, d)]

    # exclude/include files
    files = [os.path.join(root, f) for f in files]
    files = [f for f in files if not re.match(excludes, f)]
    files = [f for f in files if re.match(includes, f)]

    for fname in files:
        print fname

Files.walk(Paths.get("/path/to/stuff/"))
     .filter(p -> p.toString().endsWith(".ext"))
     .map(p -> p.getParent().getParent())
     .distinct()
     .forEach(System.out::println);

This filters all files that have the extension and gets the parent path of their directory. distinct ensures that every path is used only once.

This works. It works best to map from Path to File and then see if the list contains the file name.

List<String> fileList = List.of("file1.txt", "file3.dat");
try (Stream<Path> paths = Files.walk(Paths.get(fileSourcePath))) {
    paths
    .filter(Files::isReadable)
    .map(Path::toFile)
    .filter(file -> fileList.contains(file.getName()))
    .forEach(file->System.out.println(file));       
}catch (IOException ex){
    ex.printStackTrace();
}

files = [ fi for fi in files if not fi.endswith(".dat") ]