You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2020/10/13 14:22:52 UTC

[commons-io] 03/03: Let org.apache.commons.io.filefilter classes work with java.nio.file.Files.walk* APIs.

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-io.git

commit 8b6d4969ffb55bf7301a44a8156f02b0213e6d68
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue Oct 13 10:22:44 2020 -0400

    Let org.apache.commons.io.filefilter classes work with
    java.nio.file.Files.walk* APIs.
    
    Also: AccumulatorPathVisitor does not track directories properly.
---
 pom.xml                                            |  34 +
 src/changes/changes.xml                            |   6 +
 .../commons/io/file/AccumulatorPathVisitor.java    |  83 +-
 .../commons/io/file/CopyDirectoryVisitor.java      |  23 +-
 .../java/org/apache/commons/io/file/Counters.java  | 109 ++-
 .../commons/io/file/CountingPathVisitor.java       |  17 +-
 ...SimplePathVisitor.java => NoopPathVisitor.java} |  16 +-
 .../java/org/apache/commons/io/file/PathUtils.java |  89 ++
 .../{SimplePathVisitor.java => PathVisitor.java}   |  17 +-
 .../apache/commons/io/file/SimplePathVisitor.java  |   2 +-
 .../commons/io/filefilter/AbstractFileFilter.java  |  93 ++-
 .../commons/io/filefilter/AgeFileFilter.java       | 124 ++-
 .../commons/io/filefilter/AndFileFilter.java       |  86 +-
 .../io/filefilter/CanExecuteFileFilter.java        |  35 +-
 .../commons/io/filefilter/CanReadFileFilter.java   |  56 +-
 .../commons/io/filefilter/CanWriteFileFilter.java  |  47 +-
 .../commons/io/filefilter/DelegateFileFilter.java  |   2 -
 .../commons/io/filefilter/DirectoryFileFilter.java |  43 +-
 .../commons/io/filefilter/EmptyFileFilter.java     |  79 +-
 .../commons/io/filefilter/FalseFileFilter.java     |  44 +-
 .../commons/io/filefilter/FileFileFilter.java      |  44 +-
 .../commons/io/filefilter/FileFilterUtils.java     | 108 +--
 .../commons/io/filefilter/HiddenFileFilter.java    |  59 +-
 .../apache/commons/io/filefilter/IOFileFilter.java |  75 +-
 .../io/filefilter/MagicNumberFileFilter.java       |  62 +-
 .../commons/io/filefilter/NameFileFilter.java      |  74 +-
 .../commons/io/filefilter/NotFileFilter.java       |  37 +-
 .../apache/commons/io/filefilter/OrFileFilter.java |  53 +-
 .../PathFilter.java}                               |  30 +-
 .../io/filefilter/PathVisitorFileFilter.java       |  90 ++
 .../commons/io/filefilter/PrefixFileFilter.java    |  72 +-
 .../commons/io/filefilter/RegexFileFilter.java     |  39 +-
 .../commons/io/filefilter/SizeFileFilter.java      |  71 +-
 .../commons/io/filefilter/SuffixFileFilter.java    |  55 +-
 .../commons/io/filefilter/TrueFileFilter.java      |  28 +-
 .../commons/io/filefilter/WildcardFileFilter.java  |  63 +-
 .../commons/io/filefilter/WildcardFilter.java      |  76 +-
 .../org/apache/commons/io/filefilter/package.html  |  46 +-
 .../apache/commons/io/DirectoryWalkerTestCase.java |   4 +-
 .../io/file/AccumulatorPathVisitorTest.java        | 122 +++
 .../apache/commons/io/file/CounterAssertions.java  |  11 +-
 .../org/apache/commons/io/file/CountersTest.java   |  23 +
 .../commons/io/file/PathUtilsVisitorTest.java      | 103 +++
 .../commons/io/filefilter/AgeFileFilterTest.java   | 109 +++
 .../io/filefilter/DirectoryFileFilterTest.java     |  93 +++
 .../commons/io/filefilter/FileFilterTestCase.java  | 909 ++++++++++++++-------
 .../filefilter/IOFileFilterAbstractTestCase.java   |   4 +-
 .../io/filefilter/RegexFileFilterTestCase.java     |  39 +
 48 files changed, 2868 insertions(+), 636 deletions(-)

diff --git a/pom.xml b/pom.xml
index c314057..775a629 100644
--- a/pom.xml
+++ b/pom.xml
@@ -308,6 +308,8 @@ file comparators, endian transformation classes, and much more.
     <spotbugs.plugin.version>4.1.3</spotbugs.plugin.version>
     <spotbugs.impl.version>4.1.3</spotbugs.impl.version>    
     <japicmp.skip>false</japicmp.skip>
+    <!-- generate report even if there are binary incompatible changes -->
+    <commons.japicmp.breakBuildOnBinaryIncompatibleModifications>false</commons.japicmp.breakBuildOnBinaryIncompatibleModifications>
     <jacoco.skip>${env.JACOCO_SKIP}</jacoco.skip>
     <commons.release.isDistModule>true</commons.release.isDistModule>
     <commons.releaseManagerName>Gary Gregory</commons.releaseManagerName>    
@@ -437,6 +439,22 @@ file comparators, endian transformation classes, and much more.
           <excludeFilterFile>${basedir}/spotbugs-exclude-filter.xml</excludeFilterFile>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>com.github.siom79.japicmp</groupId>
+        <artifactId>japicmp-maven-plugin</artifactId>
+        <configuration>
+          <parameter>
+            <overrideCompatibilityChangeParameters>
+              <overrideCompatibilityChangeParameter>
+                <compatibilityChange>METHOD_NEW_DEFAULT</compatibilityChange>
+                <binaryCompatible>true</binaryCompatible>
+                <sourceCompatible>true</sourceCompatible>
+                <semanticVersionLevel>PATCH</semanticVersionLevel>
+              </overrideCompatibilityChangeParameter>
+            </overrideCompatibilityChangeParameters>
+          </parameter>
+        </configuration>
+      </plugin>
     </plugins>
   </build>
 
@@ -459,6 +477,22 @@ file comparators, endian transformation classes, and much more.
           <excludeFilterFile>${basedir}/spotbugs-exclude-filter.xml</excludeFilterFile>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>com.github.siom79.japicmp</groupId>
+        <artifactId>japicmp-maven-plugin</artifactId>
+        <configuration>
+          <parameter>
+            <overrideCompatibilityChangeParameters>
+              <overrideCompatibilityChangeParameter>
+                <compatibilityChange>METHOD_NEW_DEFAULT</compatibilityChange>
+                <binaryCompatible>true</binaryCompatible>
+                <sourceCompatible>true</sourceCompatible>
+                <semanticVersionLevel>PATCH</semanticVersionLevel>
+              </overrideCompatibilityChangeParameter>
+            </overrideCompatibilityChangeParameters>
+          </parameter>
+        </configuration>
+      </plugin>    
     </plugins>
   </reporting>
   <profiles>
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 4623008..23680ea 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -63,10 +63,16 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="fix" due-to="Michiel Kalkman">
         FileUtils#copyDirectory(File, File, FileFilter, preserveFileDate) clean up #163.
       </action>
+      <action dev="ggregory" type="fix" due-to="Michiel Kalkman">
+        AccumulatorPathVisitor does not track directories properly.
+      </action>
       <!-- ADD -->
       <action dev="ggregory" type="add" due-to="Gary Gregory">
         Add FileSystemProviders class.
       </action>
+      <action dev="ggregory" type="add" due-to="Gary Gregory">
+        Let org.apache.commons.io.filefilter classes work with java.nio.file.Files.walk* APIs.
+      </action>
       <!-- UPDATES -->
       <action dev="ggregory" type="update" due-to="Dependabot">
         Update junit-jupiter from 5.6.2 to 5.7.0 #153.
diff --git a/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java b/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
index 2215b2a..7ff43f0 100644
--- a/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
@@ -19,7 +19,6 @@ package org.apache.commons.io.file;
 
 import java.io.IOException;
 import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
@@ -28,12 +27,34 @@ import java.util.List;
 import java.util.Objects;
 
 import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
 
 /**
  * Accumulates normalized paths during visitation.
  * <p>
  * Use with care on large file trees as each visited Path element is remembered.
  * </p>
+ * <h2>Example</h2>
+ *
+ * <pre>
+ * Path dir = Paths.get(".");
+ * // We are interested in files older than one day
+ * long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ * AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ * //
+ * // Walk one dir
+ * Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.walkFileTree(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
  * @since 2.7
  */
@@ -57,6 +78,28 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
         return new AccumulatorPathVisitor(Counters.longPathCounters());
     }
 
+    /**
+     * Creates a new instance configured with a long {@link PathCounters}.
+     *
+     * @param pathFilter Filters files to accumulate and count.
+     * @return a new instance configured with a long {@link PathCounters}.
+     * @since 2.9.0
+     */
+    public static AccumulatorPathVisitor withLongCounters(final PathFilter pathFilter) {
+        return new AccumulatorPathVisitor(Counters.longPathCounters(), pathFilter);
+    }
+
+    /**
+     * Creates a new instance configured with a BigInteger {@link PathCounters}.
+     *
+     * @param pathFilter Filters files to accumulate and count.
+     * @return a new instance configured with a long {@link PathCounters}.
+     * @since 2.9.0
+     */
+    public static AccumulatorPathVisitor withBigIntegerCounters(final PathFilter pathFilter) {
+        return new AccumulatorPathVisitor(Counters.bigIntegerPathCounters(), pathFilter);
+    }
+
     private final List<Path> dirList = new ArrayList<>();
 
     private final List<Path> fileList = new ArrayList<>();
@@ -64,12 +107,36 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
     /**
      * Constructs a new instance.
      *
+     * @since 2.9.0
+     */
+    public AccumulatorPathVisitor() {
+        super(Counters.noopPathCounters());
+    }
+
+    /**
+     * Constructs a new instance that counts file system elements.
+     *
      * @param pathCounter How to count path visits.
      */
     public AccumulatorPathVisitor(final PathCounters pathCounter) {
         super(pathCounter);
     }
 
+    /**
+     * Constructs a new instance.
+     *
+     * @param pathCounter How to count path visits.
+     * @param pathFilter Filters which paths to count.
+     * @since 2.9.0
+     */
+    public AccumulatorPathVisitor(final PathCounters pathCounter, final PathFilter pathFilter) {
+        super(pathCounter, pathFilter);
+    }
+
+    private void add(final List<Path> list, final Path dir) {
+        list.add(dir.normalize());
+    }
+
     @Override
     public boolean equals(final Object obj) {
         if (this == obj) {
@@ -111,6 +178,12 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
         return result;
     }
 
+    @Override
+    public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
+        add(dirList, dir);
+        return super.postVisitDirectory(dir, exc);
+    }
+
     /**
      * Relativizes each directory path with {@link Path#relativize(Path)} against the given {@code parent}, optionally
      * sorting the result.
@@ -120,7 +193,8 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
      * @param comparator How to sort, null uses default sorting.
      * @return A new list
      */
-    public List<Path> relativizeDirectories(final Path parent, final boolean sort, final Comparator<? super Path> comparator) {
+    public List<Path> relativizeDirectories(final Path parent, final boolean sort,
+        final Comparator<? super Path> comparator) {
         return PathUtils.relativize(getDirList(), parent, sort, comparator);
     }
 
@@ -133,13 +207,14 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
      * @param comparator How to sort, null uses default sorting.
      * @return A new list
      */
-    public List<Path> relativizeFiles(final Path parent, final boolean sort, final Comparator<? super Path> comparator) {
+    public List<Path> relativizeFiles(final Path parent, final boolean sort,
+        final Comparator<? super Path> comparator) {
         return PathUtils.relativize(getFileList(), parent, sort, comparator);
     }
 
     @Override
     public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
-        ((Files.isDirectory(file)) ? dirList : fileList).add(file.normalize());
+        add(fileList, file);
         return super.visitFile(file, attributes);
     }
 
diff --git a/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java b/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
index bb93ba5..ea4e6d1 100644
--- a/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
@@ -27,6 +27,7 @@ import java.util.Arrays;
 import java.util.Objects;
 
 import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
 
 /**
  * Copies a source directory to a target directory.
@@ -35,8 +36,6 @@ import org.apache.commons.io.file.Counters.PathCounters;
  */
 public class CopyDirectoryVisitor extends CountingPathVisitor {
 
-    private static final CopyOption[] EMPTY_COPY_OPTIONS = new CopyOption[0];
-
     private final CopyOption[] copyOptions;
     private final Path sourceDirectory;
     private final Path targetDirectory;
@@ -54,7 +53,25 @@ public class CopyDirectoryVisitor extends CountingPathVisitor {
         super(pathCounter);
         this.sourceDirectory = sourceDirectory;
         this.targetDirectory = targetDirectory;
-        this.copyOptions = copyOptions == null ? EMPTY_COPY_OPTIONS : copyOptions.clone();
+        this.copyOptions = copyOptions == null ? PathUtils.EMPTY_COPY_OPTIONS : copyOptions.clone();
+    }
+
+    /**
+     * Constructs a new visitor that deletes files except for the files and directories explicitly given.
+     *
+     * @param pathCounter How to count visits.
+     * @param pathFilter How to filter paths.
+     * @param sourceDirectory The source directory
+     * @param targetDirectory The target directory
+     * @param copyOptions Specifies how the copying should be done.
+     * @since 2.9.0
+     */
+    public CopyDirectoryVisitor(final PathCounters pathCounter, final PathFilter pathFilter, final Path sourceDirectory, final Path targetDirectory,
+        final CopyOption... copyOptions) {
+        super(pathCounter, pathFilter);
+        this.sourceDirectory = sourceDirectory;
+        this.targetDirectory = targetDirectory;
+        this.copyOptions = copyOptions == null ? PathUtils.EMPTY_COPY_OPTIONS : copyOptions.clone();
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/io/file/Counters.java b/src/main/java/org/apache/commons/io/file/Counters.java
index d1ae34f..3f6d9a8 100644
--- a/src/main/java/org/apache/commons/io/file/Counters.java
+++ b/src/main/java/org/apache/commons/io/file/Counters.java
@@ -44,7 +44,7 @@ public class Counters {
          * @param fileCounter the file counter.
          */
         protected AbstractPathCounters(final Counter byteCounter, final Counter directoryCounter,
-                final Counter fileCounter) {
+            final Counter fileCounter) {
             super();
             this.byteCounter = byteCounter;
             this.directoryCounter = directoryCounter;
@@ -61,8 +61,8 @@ public class Counters {
             }
             final AbstractPathCounters other = (AbstractPathCounters) obj;
             return Objects.equals(byteCounter, other.byteCounter)
-                    && Objects.equals(directoryCounter, other.directoryCounter)
-                    && Objects.equals(fileCounter, other.fileCounter);
+                && Objects.equals(directoryCounter, other.directoryCounter)
+                && Objects.equals(fileCounter, other.fileCounter);
         }
 
         @Override
@@ -91,9 +91,16 @@ public class Counters {
         }
 
         @Override
+        public void reset() {
+            byteCounter.reset();
+            directoryCounter.reset();
+            fileCounter.reset();
+        }
+
+        @Override
         public String toString() {
             return String.format("%,d files, %,d directories, %,d bytes", Long.valueOf(fileCounter.get()),
-                    Long.valueOf(directoryCounter.get()), Long.valueOf(byteCounter.get()));
+                Long.valueOf(directoryCounter.get()), Long.valueOf(byteCounter.get()));
         }
 
     }
@@ -152,6 +159,11 @@ public class Counters {
         public String toString() {
             return value.toString();
         }
+
+        @Override
+        public void reset() {
+            value = BigInteger.ZERO;
+        }
     }
 
     /**
@@ -206,6 +218,13 @@ public class Counters {
          */
         void increment();
 
+        /**
+         * Resets this count to 0.
+         */
+        default void reset() {
+            // binary compat, do nothing
+        }
+
     }
 
     /**
@@ -262,6 +281,11 @@ public class Counters {
         public String toString() {
             return Long.toString(value);
         }
+
+        @Override
+        public void reset() {
+            value = 0L;
+        }
     }
 
     /**
@@ -279,6 +303,56 @@ public class Counters {
     }
 
     /**
+     * Counts nothing.
+     */
+    private final static class NoopCounter implements Counter {
+
+        static final NoopCounter INSTANCE = new NoopCounter();
+
+        @Override
+        public void add(final long add) {
+            // noop
+        }
+
+        @Override
+        public long get() {
+            return 0;
+        }
+
+        @Override
+        public BigInteger getBigInteger() {
+            return BigInteger.ZERO;
+        }
+
+        @Override
+        public Long getLong() {
+            return 0L;
+        }
+
+        @Override
+        public void increment() {
+            // noop
+        }
+
+    }
+
+    /**
+     * Counts nothing.
+     */
+    private static final class NoopPathCounters extends AbstractPathCounters {
+
+        static final NoopPathCounters INSTANCE = new NoopPathCounters();
+
+        /**
+         * Constructs a new initialized instance.
+         */
+        private NoopPathCounters() {
+            super(Counters.noopCounter(), Counters.noopCounter(), Counters.noopCounter());
+        }
+
+    }
+
+    /**
      * Counts files, directories, and sizes, as a visit proceeds.
      */
     public interface PathCounters {
@@ -304,6 +378,13 @@ public class Counters {
          */
         Counter getFileCounter();
 
+        /**
+         * Resets the counts to 0.
+         */
+        default void reset() {
+            // binary compat, do nothing
+        }
+
     }
 
     /**
@@ -341,4 +422,24 @@ public class Counters {
     public static PathCounters longPathCounters() {
         return new LongPathCounters();
     }
+
+    /**
+     * Returns the NOOP Counter.
+     *
+     * @return the NOOP Counter.
+     * @since 2.9.0
+     */
+    public static Counter noopCounter() {
+        return NoopCounter.INSTANCE;
+    }
+
+    /**
+     * Returns the NOOP PathCounters.
+     *
+     * @return the NOOP PathCounters.
+     * @since 2.9.0
+     */
+    public static PathCounters noopPathCounters() {
+        return NoopPathCounters.INSTANCE;
+    }
 }
diff --git a/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java b/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
index ccd0fb1..a7125f5 100644
--- a/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
@@ -25,6 +25,8 @@ import java.nio.file.attribute.BasicFileAttributes;
 import java.util.Objects;
 
 import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
+import org.apache.commons.io.filefilter.TrueFileFilter;
 
 /**
  * Counts files, directories, and sizes, as a visit proceeds.
@@ -54,6 +56,7 @@ public class CountingPathVisitor extends SimplePathVisitor {
     }
 
     private final PathCounters pathCounters;
+    private final PathFilter pathFilter;
 
     /**
      * Constructs a new instance.
@@ -61,8 +64,20 @@ public class CountingPathVisitor extends SimplePathVisitor {
      * @param pathCounter How to count path visits.
      */
     public CountingPathVisitor(final PathCounters pathCounter) {
+        this(pathCounter, TrueFileFilter.INSTANCE);
+    }
+
+    /**
+     * Constructs a new instance.
+     *
+     * @param pathCounter How to count path visits.
+     * @param pathFilter Filters which paths to count.
+     * @since 2.9.0
+     */
+    public CountingPathVisitor(final PathCounters pathCounter, final PathFilter pathFilter) {
         super();
         this.pathCounters = Objects.requireNonNull(pathCounter, "pathCounter");
+        this.pathFilter = Objects.requireNonNull(pathFilter, "pathFilter");
     }
 
     @Override
@@ -115,7 +130,7 @@ public class CountingPathVisitor extends SimplePathVisitor {
 
     @Override
     public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
-        if (Files.exists(file)) {
+        if (Files.exists(file) && pathFilter.accept(file) == FileVisitResult.CONTINUE) {
             updateFileCounters(file, attributes);
         }
         return FileVisitResult.CONTINUE;
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
similarity index 74%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
index 8b2cdc4..b10201d 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
@@ -17,21 +17,15 @@
 
 package org.apache.commons.io.file;
 
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-
 /**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A noop path visitor.
  *
- * @since 2.7
+ * @since 2.9.0
  */
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public class NoopPathVisitor extends SimplePathVisitor {
 
     /**
-     * Constructs a new instance.
+     * The singleton instance.
      */
-    protected SimplePathVisitor() {
-        super();
-    }
-
+    public static NoopPathVisitor INSTANCE = new NoopPathVisitor();
 }
diff --git a/src/main/java/org/apache/commons/io/file/PathUtils.java b/src/main/java/org/apache/commons/io/file/PathUtils.java
index 5902a74..d8de77f 100644
--- a/src/main/java/org/apache/commons/io/file/PathUtils.java
+++ b/src/main/java/org/apache/commons/io/file/PathUtils.java
@@ -17,6 +17,7 @@
 
 package org.apache.commons.io.file;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
@@ -24,6 +25,7 @@ import java.net.URL;
 import java.nio.file.CopyOption;
 import java.nio.file.DirectoryStream;
 import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
 import java.nio.file.FileVisitor;
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
@@ -43,12 +45,16 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.IOFileFilter;
+import org.apache.commons.io.filefilter.PathFilter;
 
 /**
  * NIO Path utilities.
@@ -121,6 +127,13 @@ public final class PathUtils {
     }
 
     /**
+     * Empty {@link CopyOption} array.
+     *
+     * @since 2.8.0
+     */
+    public static final CopyOption[] EMPTY_COPY_OPTIONS = new CopyOption[0];
+
+    /**
      * Empty {@link LinkOption} array.
      *
      * @since 2.8.0
@@ -143,6 +156,12 @@ public final class PathUtils {
     public static final OpenOption[] EMPTY_OPEN_OPTION_ARRAY = new OpenOption[0];
 
     /**
+     * Empty {@link Path} array.
+     * @since 2.9.0
+     */
+    public static final Path[] EMPTY_PATH_ARRAY = new Path[0];
+
+    /**
      * Accumulates file tree information in a {@link AccumulatorPathVisitor}.
      *
      * @param directory The directory to accumulate information.
@@ -587,6 +606,26 @@ public final class PathUtils {
     }
 
     /**
+     * Tests if the specified {@code Path} is newer than the specified time reference.
+     *
+     * @param file the {@code Path} of which the modification date must be compared
+     * @param timeMillis the time reference measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)
+     * @param options options indicating how symbolic links are handled * @return true if the {@code Path} exists and
+     *        has been modified after the given time reference.
+     * @return true if the {@code Path} exists and has been modified after the given time reference.
+     * @throws IOException if an I/O error occurs
+     * @throws NullPointerException if the file is {@code null}
+     * @since 2.9.0
+     */
+    public static boolean isNewer(final Path file, final long timeMillis, final LinkOption... options) throws IOException {
+        Objects.requireNonNull(file, "file");
+        if (!Files.exists(file)) {
+            return false;
+        }
+        return Files.getLastModifiedTime(file, options).toMillis() > timeMillis;
+    }
+
+    /**
      * Returns true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
      *
      * @param options the array to test
@@ -750,4 +789,54 @@ public final class PathUtils {
         // do not instantiate.
     }
 
+    /**
+     * <p>
+     * Applies an {@link IOFileFilter} to the provided {@link File}
+     * objects. The resulting array is a subset of the original file list that
+     * matches the provided filter.
+     * </p>
+     *
+     * <p>
+     * The {@link Set} returned by this method is not guaranteed to be thread safe.
+     * </p>
+     *
+     * <pre>
+     * Set&lt;File&gt; allFiles = ...
+     * Set&lt;File&gt; javaFiles = FileFilterUtils.filterSet(allFiles,
+     *     FileFilterUtils.suffixFileFilter(".java"));
+     * </pre>
+     * @param filter the filter to apply to the set of files.
+     * @param paths the array of files to apply the filter to.
+     *
+     * @return a subset of <code>files</code> that is accepted by the
+     *         file filter.
+     * @throws IllegalArgumentException if the filter is {@code null}
+     *         or <code>files</code> contains a {@code null} value.
+     *
+     * @since 2.9.0
+     */
+    public static Path[] filter(final PathFilter filter, final Path... paths) {
+        Objects.requireNonNull(filter, "filter");
+        if (paths == null) {
+            return EMPTY_PATH_ARRAY;
+        }
+        return filterPaths(filter, Arrays.stream(paths), Collectors.toList()).toArray(EMPTY_PATH_ARRAY);
+    }
+
+    private static <R, A> R filterPaths(final PathFilter filter, final Stream<Path> stream,
+        final Collector<? super Path, A, R> collector) {
+        Objects.requireNonNull(filter, "filter");
+        Objects.requireNonNull(collector, "collector");
+        if (stream == null) {
+            return Stream.<Path>empty().collect(collector);
+        }
+        return stream.filter(t -> {
+            try {
+                return filter.accept(t) == FileVisitResult.CONTINUE;
+            } catch (final IOException e) {
+                return false;
+            }
+        }).collect(collector);
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/PathVisitor.java
similarity index 74%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/file/PathVisitor.java
index 8b2cdc4..dcd7258 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/PathVisitor.java
@@ -17,21 +17,14 @@
 
 package org.apache.commons.io.file;
 
+import java.nio.file.FileVisitor;
 import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
 
 /**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A {@link FileVisitor} typed to a {@link Path}.
  *
- * @since 2.7
+ * @since 2.9.0
  */
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
-
-    /**
-     * Constructs a new instance.
-     */
-    protected SimplePathVisitor() {
-        super();
-    }
-
+public interface PathVisitor extends FileVisitor<Path> {
+    // empty
 }
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
index 8b2cdc4..20241a4 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
@@ -25,7 +25,7 @@ import java.nio.file.SimpleFileVisitor;
  *
  * @since 2.7
  */
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> implements PathVisitor {
 
     /**
      * Constructs a new instance.
diff --git a/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
index a4647fc..ea4a574 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
@@ -17,44 +17,107 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.FileFilter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Objects;
+
+import org.apache.commons.io.file.PathVisitor;
 
 /**
- * An abstract class which implements the Java FileFilter and FilenameFilter
- * interfaces via the IOFileFilter interface.
+ * Abstracts the implementation of the {@link FileFilter} (IO), {@link FilenameFilter} (IO), {@link PathFilter} (NIO)
+ * interfaces via our own {@link IOFileFilter} interface.
  * <p>
- * Note that a subclass <b>must</b> override one of the accept methods,
- * otherwise your class will infinitely loop.
+ * Note that a subclass MUST override one of the {@code accept} methods, otherwise your class will infinitely loop.
+ * </p>
  *
  * @since 1.0
- *
  */
-public abstract class AbstractFileFilter implements IOFileFilter {
+public abstract class AbstractFileFilter implements IOFileFilter, PathVisitor {
+
+    protected static FileVisitResult toFileVisitResult(final boolean accept) {
+        return accept ? FileVisitResult.CONTINUE : FileVisitResult.TERMINATE;
+    }
 
     /**
      * Checks to see if the File should be accepted by this filter.
      *
-     * @param file  the File to check
+     * @param file the File to check
      * @return true if this file matches the test
      */
     @Override
     public boolean accept(final File file) {
+        Objects.requireNonNull(file, "file");
         return accept(file.getParentFile(), file.getName());
     }
 
     /**
      * Checks to see if the File should be accepted by this filter.
      *
-     * @param dir  the directory File to check
-     * @param name  the file name within the directory to check
+     * @param dir the directory File to check
+     * @param name the file name within the directory to check
      * @return true if this file matches the test
      */
     @Override
     public boolean accept(final File dir, final String name) {
+        Objects.requireNonNull(name, "name");
         return accept(new File(dir, name));
     }
 
     /**
-     * Provide a String representation of this file filter.
+     * Checks to see if the Path should be accepted by this filter.
+     *
+     * @param path the Path to check
+     * @return true if this path matches the test
+     * @throws IOException if an I/O error occurs
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path path) throws IOException {
+        Objects.requireNonNull(path, "path");
+        return accept(path.getParent(), path.getFileName());
+    }
+
+    /**
+     * Checks to see if the Path should be accepted by this filter.
+     *
+     * @param dir the directory Path to check
+     * @param name the path name within the directory to check
+     * @return true if this path matches the test
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) throws IOException {
+        Objects.requireNonNull(dir, "dir");
+        return accept(dir.resolve(name));
+    }
+
+    /**
+     * Handles exceptions caught while accepting.
+     *
+     * @param t the caught exception.
+     * @return the given Throwable.
+     * @since 2.9.0
+     */
+    protected FileVisitResult handle(final Throwable t) {
+        return FileVisitResult.TERMINATE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
+        return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attrs) throws IOException {
+        return accept(dir, dir.getFileName());
+    }
+
+    /**
+     * Provides a String representation of this file filter.
      *
      * @return a String representation
      */
@@ -63,4 +126,14 @@ public abstract class AbstractFileFilter implements IOFileFilter {
         return getClass().getSimpleName();
     }
 
+    @Override
+    public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+        return accept(file);
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(final Path file, final IOException exc) throws IOException {
+        return FileVisitResult.CONTINUE;
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
index c3ddbab..17dc0b1 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
@@ -17,28 +17,52 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.Date;
 
 import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.file.PathUtils;
 
 /**
- * Filters files based on a cutoff time, can filter either newer
- * files or files equal to or older.
+ * Filters files based on a cutoff time, can filter either newer files or files equal to or older.
  * <p>
- * For example, to print all files and directories in the
- * current directory older than one day:
- *
+ * For example, to print all files and directories in the current directory older than one day:
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
- * File dir = new File(".");
+ * Path dir = Paths.get(".");
  * // We are interested in files older than one day
  * long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
- * String[] files = dir.list( new AgeFileFilter(cutoff) );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(new AgeFileFilter(cutoff));
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
+ * <h2>Using NIO</h2>
+ * <pre>
+ * Path dir = Paths.get(".");
+ * // We are interested in files older than one day
+ * long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ * AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
  * @see FileFilterUtils#ageFileFilter(Date)
  * @see FileFilterUtils#ageFileFilter(File)
  * @see FileFilterUtils#ageFileFilter(long)
@@ -58,69 +82,64 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
     private final long cutoffMillis;
 
     /**
-     * Constructs a new age file filter for files older than (at or before)
-     * a certain cutoff date.
+     * Constructs a new age file filter for files older than (at or before) a certain cutoff date.
      *
-     * @param cutoffDate  the threshold age of the files
+     * @param cutoffDate the threshold age of the files
      */
     public AgeFileFilter(final Date cutoffDate) {
         this(cutoffDate, true);
     }
 
     /**
-     * Constructs a new age file filter for files on any one side
-     * of a certain cutoff date.
+     * Constructs a new age file filter for files on any one side of a certain cutoff date.
      *
-     * @param cutoffDate  the threshold age of the files
-     * @param acceptOlder  if true, older files (at or before the cutoff)
-     * are accepted, else newer ones (after the cutoff).
+     * @param cutoffDate the threshold age of the files
+     * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+     *        cutoff).
      */
     public AgeFileFilter(final Date cutoffDate, final boolean acceptOlder) {
         this(cutoffDate.getTime(), acceptOlder);
     }
 
     /**
-     * Constructs a new age file filter for files older than (at or before)
-     * a certain File (whose last modification time will be used as reference).
+     * Constructs a new age file filter for files older than (at or before) a certain File (whose last modification time
+     * will be used as reference).
      *
-     * @param cutoffReference  the file whose last modification
-     *        time is used as the threshold age of the files
+     * @param cutoffReference the file whose last modification time is used as the threshold age of the files
      */
     public AgeFileFilter(final File cutoffReference) {
         this(cutoffReference, true);
     }
 
     /**
-     * Constructs a new age file filter for files on any one side
-     * of a certain File (whose last modification time will be used as
-     * reference).
+     * Constructs a new age file filter for files on any one side of a certain File (whose last modification time will
+     * be used as reference).
      *
-     * @param cutoffReference  the file whose last modification
-     *        time is used as the threshold age of the files
-     * @param acceptOlder  if true, older files (at or before the cutoff)
-     * are accepted, else newer ones (after the cutoff).
+     * @param cutoffReference the file whose last modification time is used as the threshold age of the files
+     * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+     *        cutoff).
      */
     public AgeFileFilter(final File cutoffReference, final boolean acceptOlder) {
         this(cutoffReference.lastModified(), acceptOlder);
     }
 
     /**
-     * Constructs a new age file filter for files equal to or older than
-     * a certain cutoff
+     * Constructs a new age file filter for files equal to or older than a certain cutoff
      *
-     * @param cutoffMillis  The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).
+     * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1,
+     *        1970).
      */
     public AgeFileFilter(final long cutoffMillis) {
         this(cutoffMillis, true);
     }
 
     /**
-     * Constructs a new age file filter for files on any one side
-     * of a certain cutoff.
+     * Constructs a new age file filter for files on any one side of a certain cutoff.
      *
-     * @param cutoffMillis  The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).
-     * @param acceptOlder  if true, older files (at or before the cutoff)
-     * are accepted, else newer ones (after the cutoff).
+     * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1,
+     *        1970).
+     * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+     *        cutoff).
      */
     public AgeFileFilter(final long cutoffMillis, final boolean acceptOlder) {
         this.acceptOlder = acceptOlder;
@@ -128,16 +147,13 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
     }
 
     /**
-     * Checks to see if the last modification of the file matches cutoff
-     * favorably.
+     * Checks to see if the last modification of the file matches cutoff favorably.
      * <p>
-     * If last modification time equals cutoff and newer files are required,
-     * file <b>IS NOT</b> selected.
-     * If last modification time equals cutoff and older files are required,
-     * file <b>IS</b> selected.
+     * If last modification time equals cutoff and newer files are required, file <b>IS NOT</b> selected. If last
+     * modification time equals cutoff and older files are required, file <b>IS</b> selected.
      * </p>
      *
-     * @param file  the File to check
+     * @param file the File to check
      * @return true if the file name matches
      */
     @Override
@@ -147,6 +163,28 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
     }
 
     /**
+     * Checks to see if the last modification of the file matches cutoff favorably.
+     * <p>
+     * If last modification time equals cutoff and newer files are required, file <b>IS NOT</b> selected. If last
+     * modification time equals cutoff and older files are required, file <b>IS</b> selected.
+     * </p>
+     *
+     * @param file the File to check
+     * @return true if the file name matches
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        boolean newer;
+        try {
+            newer = PathUtils.isNewer(file, cutoffMillis);
+        } catch (final IOException e) {
+            return handle(e);
+        }
+        return toFileVisitResult(acceptOlder != newer);
+    }
+
+    /**
      * Provide a String representation of this file filter.
      *
      * @return a String representation
diff --git a/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
index 7d889ca..c863e46 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
@@ -17,8 +17,12 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -30,8 +34,6 @@ import java.util.List;
  * {@code false}.
  *
  * @since 1.0
- *
- *
  * @see FileFilterUtils#and(IOFileFilter...)
  */
 public class AndFileFilter
@@ -53,10 +55,10 @@ public class AndFileFilter
     }
 
     /**
-     * Constructs a new file filter that ANDs the result of two other filters.
+     * Constructs a new file filter that ANDs the result of other filters.
      *
-     * @param filter1  the first filter, must not be null
-     * @param filter2  the second filter, must not be null
+     * @param filter1  the first filter, must second be null
+     * @param filter2  the first filter, must not be null
      * @throws IllegalArgumentException if either filter is null
      */
     public AndFileFilter(final IOFileFilter filter1, final IOFileFilter filter2) {
@@ -64,8 +66,24 @@ public class AndFileFilter
             throw new IllegalArgumentException("The filters must not be null");
         }
         this.fileFilters = new ArrayList<>(2);
-        addFileFilter(filter1);
-        addFileFilter(filter2);
+        this.fileFilters.add(filter1);
+        this.fileFilters.add(filter2);
+    }
+
+    /**
+     * Constructs a new file filter that ANDs the result of other filters.
+     *
+     * @param filter1  the first filter, must not be null
+     * @param filters  more filters, must not be null
+     * @throws IllegalArgumentException if either filter is null
+     */
+    public AndFileFilter(final IOFileFilter filter1, final IOFileFilter... filters) {
+        if (filter1 == null || filters == null) {
+            throw new IllegalArgumentException("The filters must not be null");
+        }
+        this.fileFilters = new ArrayList<>(filters.length + 1);
+        this.fileFilters.add(filter1);
+        this.fileFilters.addAll(Arrays.asList(filters));
     }
 
     /**
@@ -88,7 +106,7 @@ public class AndFileFilter
      */
     @Override
     public boolean accept(final File file) {
-        if (this.fileFilters.isEmpty()) {
+        if (isEmpty()) {
             return false;
         }
         for (final IOFileFilter fileFilter : fileFilters) {
@@ -104,7 +122,7 @@ public class AndFileFilter
      */
     @Override
     public boolean accept(final File file, final String name) {
-        if (this.fileFilters.isEmpty()) {
+        if (isEmpty()) {
             return false;
         }
         for (final IOFileFilter fileFilter : fileFilters) {
@@ -117,6 +135,40 @@ public class AndFileFilter
 
     /**
      * {@inheritDoc}
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) throws IOException {
+        if (isEmpty()) {
+            return FileVisitResult.TERMINATE;
+        }
+        for (final IOFileFilter fileFilter : fileFilters) {
+            if (fileFilter.accept(file) != FileVisitResult.CONTINUE) {
+                return FileVisitResult.TERMINATE;
+            }
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    /**
+     * {@inheritDoc}
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file, final Path name) throws IOException {
+        if (isEmpty()) {
+            return FileVisitResult.TERMINATE;
+        }
+        for (final IOFileFilter fileFilter : fileFilters) {
+            if (fileFilter.accept(file, name) != FileVisitResult.CONTINUE) {
+                return FileVisitResult.TERMINATE;
+            }
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    /**
+     * {@inheritDoc}
      */
     @Override
     public void addFileFilter(final IOFileFilter ioFileFilter) {
@@ -131,6 +183,10 @@ public class AndFileFilter
         return Collections.unmodifiableList(this.fileFilters);
     }
 
+    private boolean isEmpty() {
+        return this.fileFilters.isEmpty();
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -158,14 +214,12 @@ public class AndFileFilter
         final StringBuilder buffer = new StringBuilder();
         buffer.append(super.toString());
         buffer.append("(");
-        if (fileFilters != null) {
-            for (int i = 0; i < fileFilters.size(); i++) {
-                if (i > 0) {
-                    buffer.append(",");
-                }
-                final Object filter = fileFilters.get(i);
-                buffer.append(filter == null ? "null" : filter.toString());
+        for (int i = 0; i < fileFilters.size(); i++) {
+            if (i > 0) {
+                buffer.append(",");
             }
+            final Object filter = fileFilters.get(i);
+            buffer.append(filter == null ? "null" : filter.toString());
         }
         buffer.append(")");
         return buffer.toString();
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
index 32fd43d..05b1a5b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
@@ -18,35 +18,39 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that can be executed.
  * <p>
  * Example, showing how to print out a list of the
  * current directory's <i>executable</i> files:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanExecuteFileFilter.CAN_EXECUTE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanExecuteFileFilter.CAN_EXECUTE);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
  * Example, showing how to print out a list of the
- * current directory's <i>un-executable</i> files:
+ * current directory's <i>non-executable</i> files:
+ * </p>
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanExecuteFileFilter.CANNOT_EXECUTE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
+ * String[] files = dir.list(CanExecuteFileFilter.CANNOT_EXECUTE);
+ * for (int i = 0; i &lt; files.length; i++) {
  *     System.out.println(files[i]);
  * }
  * </pre>
  *
  * @since 2.7
- *
  */
 public class CanExecuteFileFilter extends AbstractFileFilter implements Serializable {
 
@@ -54,7 +58,7 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
     public static final IOFileFilter CAN_EXECUTE = new CanExecuteFileFilter();
 
     /** Singleton instance of not <i>executable</i> filter */
-    public static final IOFileFilter CANNOT_EXECUTE = new NotFileFilter(CAN_EXECUTE);
+    public static final IOFileFilter CANNOT_EXECUTE = CAN_EXECUTE.not();
 
     private static final long serialVersionUID = 3179904805251622989L;
 
@@ -62,6 +66,7 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
      * Restrictive constructor.
      */
     protected CanExecuteFileFilter() {
+        // empty.
     }
 
     /**
@@ -75,4 +80,16 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
         return file.canExecute();
     }
 
+    /**
+     * Checks to see if the file can be executed.
+     *
+     * @param file  the File to check.
+     * @return {@code true} if the file can be executed, otherwise {@code false}.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(Files.isExecutable(file));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
index dcd7a7f..9776bdb 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
@@ -18,47 +18,47 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that can be read.
  * <p>
- * Example, showing how to print out a list of the
- * current directory's <i>readable</i> files:
- *
+ * Example, showing how to print out a list of the current directory's <i>readable</i> files:
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.CAN_READ );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.CAN_READ);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
- * Example, showing how to print out a list of the
- * current directory's <i>un-readable</i> files:
+ * Example, showing how to print out a list of the current directory's <i>un-readable</i> files:
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.CANNOT_READ );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.CANNOT_READ);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
- * Example, showing how to print out a list of the
- * current directory's <i>read-only</i> files:
+ * Example, showing how to print out a list of the current directory's <i>read-only</i> files:
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.READ_ONLY );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.READ_ONLY);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * @since 1.3
- *
  */
 public class CanReadFileFilter extends AbstractFileFilter implements Serializable {
 
@@ -66,11 +66,10 @@ public class CanReadFileFilter extends AbstractFileFilter implements Serializabl
     public static final IOFileFilter CAN_READ = new CanReadFileFilter();
 
     /** Singleton instance of not <i>readable</i> filter */
-    public static final IOFileFilter CANNOT_READ = new NotFileFilter(CAN_READ);
+    public static final IOFileFilter CANNOT_READ = CAN_READ.not();
 
     /** Singleton instance of <i>read-only</i> filter */
-    public static final IOFileFilter READ_ONLY = new AndFileFilter(CAN_READ,
-                                                CanWriteFileFilter.CANNOT_WRITE);
+    public static final IOFileFilter READ_ONLY = CAN_READ.and(CanWriteFileFilter.CANNOT_WRITE);
 
     private static final long serialVersionUID = 3179904805251622989L;
 
@@ -83,13 +82,24 @@ public class CanReadFileFilter extends AbstractFileFilter implements Serializabl
     /**
      * Checks to see if the file can be read.
      *
-     * @param file  the File to check.
-     * @return {@code true} if the file can be
-     *  read, otherwise {@code false}.
+     * @param file the File to check.
+     * @return {@code true} if the file can be read, otherwise {@code false}.
      */
     @Override
     public boolean accept(final File file) {
         return file.canRead();
     }
 
+    /**
+     * Checks to see if the file can be read.
+     *
+     * @param file the File to check.
+     * @return {@code true} if the file can be read, otherwise {@code false}.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(Files.isReadable(file));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
index e1a41b2..e69de26 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
@@ -18,39 +18,39 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that can be written to.
  * <p>
- * Example, showing how to print out a list of the
- * current directory's <i>writable</i> files:
- *
+ * Example, showing how to print out a list of the current directory's <i>writable</i> files:
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanWriteFileFilter.CAN_WRITE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanWriteFileFilter.CAN_WRITE);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
- * Example, showing how to print out a list of the
- * current directory's <i>un-writable</i> files:
+ * Example, showing how to print out a list of the current directory's <i>un-writable</i> files:
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( CanWriteFileFilter.CANNOT_WRITE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(CanWriteFileFilter.CANNOT_WRITE);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
- * <b>N.B.</b> For read-only files, use
- *    <code>CanReadFileFilter.READ_ONLY</code>.
+ * <b>N.B.</b> For read-only files, use <code>CanReadFileFilter.READ_ONLY</code>.
  *
  * @since 1.3
- *
  */
 public class CanWriteFileFilter extends AbstractFileFilter implements Serializable {
 
@@ -58,7 +58,7 @@ public class CanWriteFileFilter extends AbstractFileFilter implements Serializab
     public static final IOFileFilter CAN_WRITE = new CanWriteFileFilter();
 
     /** Singleton instance of not <i>writable</i> filter */
-    public static final IOFileFilter CANNOT_WRITE = new NotFileFilter(CAN_WRITE);
+    public static final IOFileFilter CANNOT_WRITE = CAN_WRITE.not();
 
     private static final long serialVersionUID = 5132005214688990379L;
 
@@ -71,13 +71,24 @@ public class CanWriteFileFilter extends AbstractFileFilter implements Serializab
     /**
      * Checks to see if the file can be written to.
      *
-     * @param file  the File to check
-     * @return {@code true} if the file can be
-     *  written to, otherwise {@code false}.
+     * @param file the File to check
+     * @return {@code true} if the file can be written to, otherwise {@code false}.
      */
     @Override
     public boolean accept(final File file) {
         return file.canWrite();
     }
 
+    /**
+     * Checks to see if the file can be written to.
+     *
+     * @param file the File to check
+     * @return {@code true} if the file can be written to, otherwise {@code false}.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(Files.isWritable(file));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
index 380a2ef..88f4ea4 100644
--- a/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
@@ -25,8 +25,6 @@ import java.io.Serializable;
  * This class turns a Java FileFilter or FilenameFilter into an IO FileFilter.
  *
  * @since 1.0
- *
- *
  * @see FileFilterUtils#asFileFilter(FileFilter)
  * @see FileFilterUtils#asFileFilter(FilenameFilter)
  */
diff --git a/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
index 2bf020b..8a88ca5 100644
--- a/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
@@ -18,30 +18,53 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that are directories.
  * <p>
  * For example, here is how to print out a list of the current directory's subdirectories:
+ * </p>
+ * <h2>Using Classic IO</h2>
  *
  * <pre>
  * File dir = new File(".");
  * String[] files = dir.list(DirectoryFileFilter.INSTANCE);
- * for (int i = 0; i &lt; files.length; i++) {
- *     System.out.println(files[i]);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.0
+ * <h2>Using NIO</h2>
  *
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(DirectoryFileFilter.INSTANCE);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.0
  * @see FileFilterUtils#directoryFileFilter()
  */
 public class DirectoryFileFilter extends AbstractFileFilter implements Serializable {
 
     /**
      * Singleton instance of directory filter.
-     * 
+     *
      * @since 1.3
      */
     public static final IOFileFilter DIRECTORY = new DirectoryFileFilter();
@@ -72,4 +95,16 @@ public class DirectoryFileFilter extends AbstractFileFilter implements Serializa
         return file.isDirectory();
     }
 
+    /**
+     * Checks to see if the file is a directory.
+     *
+     * @param file the File to check
+     * @return true if the file is a directory
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(Files.isDirectory(file));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
index 2914951..71a89b8 100644
--- a/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
@@ -17,39 +17,62 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
 
 /**
  * This filter accepts files or directories that are empty.
  * <p>
- * If the <code>File</code> is a directory it checks that
- * it contains no files.
+ * If the <code>File</code> is a directory it checks that it contains no files.
+ * </p>
  * <p>
- * Example, showing how to print out a list of the
- * current directory's empty files/directories:
- *
+ * Example, showing how to print out a list of the current directory's empty files/directories:
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( EmptyFileFilter.EMPTY );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(EmptyFileFilter.EMPTY);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
- * Example, showing how to print out a list of the
- * current directory's non-empty files/directories:
+ * Example, showing how to print out a list of the current directory's non-empty files/directories:
+ * </p>
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( EmptyFileFilter.NOT_EMPTY );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(EmptyFileFilter.NOT_EMPTY);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(EmptyFileFilter.EMPTY);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.3
  */
 public class EmptyFileFilter extends AbstractFileFilter implements Serializable {
 
@@ -57,7 +80,7 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
     public static final IOFileFilter EMPTY = new EmptyFileFilter();
 
     /** Singleton instance of <i>not-empty</i> filter */
-    public static final IOFileFilter NOT_EMPTY = new NotFileFilter(EMPTY);
+    public static final IOFileFilter NOT_EMPTY = EMPTY.not();
 
     private static final long serialVersionUID = 3631422087512832211L;
 
@@ -70,9 +93,8 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
     /**
      * Checks to see if the file is empty.
      *
-     * @param file  the file or directory to check
-     * @return {@code true} if the file or directory
-     *  is <i>empty</i>, otherwise {@code false}.
+     * @param file the file or directory to check
+     * @return {@code true} if the file or directory is <i>empty</i>, otherwise {@code false}.
      */
     @Override
     public boolean accept(final File file) {
@@ -83,4 +105,25 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
         return file.length() == 0;
     }
 
+    /**
+     * Checks to see if the file is empty.
+     *
+     * @param file the file or directory to check
+     * @return {@code true} if the file or directory is <i>empty</i>, otherwise {@code false}.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        try {
+            if (Files.isDirectory(file)) {
+                try (Stream<Path> stream = Files.list(file)) {
+                    return toFileVisitResult(!stream.findFirst().isPresent());
+                }
+            }
+            return toFileVisitResult(Files.size(file) == 0);
+        } catch (final IOException e) {
+            return handle(e);
+        }
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
index 47ad394..f19deae 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
@@ -18,29 +18,30 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 
 /**
  * A file filter that always returns false.
  *
  * @since 1.0
- *
- *
  * @see FileFilterUtils#falseFileFilter()
  */
 public class FalseFileFilter implements IOFileFilter, Serializable {
 
     /**
      * Singleton instance of false filter.
+     *
      * @since 1.3
      */
+
     public static final IOFileFilter FALSE = new FalseFileFilter();
     /**
-     * Singleton instance of false filter.
-     * Please use the identical FalseFileFilter.FALSE constant.
-     * The new name is more JDK 1.5 friendly as it doesn't clash with other
-     * values when using static imports.
+     * Singleton instance of false filter. Please use the identical FalseFileFilter.FALSE constant. The new name is more
+     * JDK 1.5 friendly as it doesn't clash with other values when using static imports.
      */
     public static final IOFileFilter INSTANCE = FALSE;
+
     private static final long serialVersionUID = 6210271677940926200L;
 
     /**
@@ -52,7 +53,7 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
     /**
      * Returns false.
      *
-     * @param file  the file to check (ignored)
+     * @param file the file to check (ignored)
      * @return false
      */
     @Override
@@ -63,8 +64,8 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
     /**
      * Returns false.
      *
-     * @param dir  the directory to check (ignored)
-     * @param name  the file name (ignored)
+     * @param dir the directory to check (ignored)
+     * @param name the file name (ignored)
      * @return false
      */
     @Override
@@ -72,4 +73,29 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
         return false;
     }
 
+    /**
+     * Returns false.
+     *
+     * @param file the file to check (ignored)
+     * @return false
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return FileVisitResult.TERMINATE;
+    }
+
+    /**
+     * Returns false.
+     *
+     * @param dir the directory to check (ignored)
+     * @param name the file name (ignored)
+     * @return false
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        return FileVisitResult.TERMINATE;
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
index e639b61..2223251 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
@@ -18,23 +18,45 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that are files (not directories).
  * <p>
  * For example, here is how to print out a list of the real files
  * within the current directory:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( FileFileFilter.FILE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(FileFileFilter.FILE);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(FileFileFilter.FILE);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.3
  * @see FileFilterUtils#fileFileFilter()
  */
 public class FileFileFilter extends AbstractFileFilter implements Serializable {
@@ -60,4 +82,16 @@ public class FileFileFilter extends AbstractFileFilter implements Serializable {
         return file.isFile();
     }
 
+    /**
+     * Checks to see if the file is a file.
+     *
+     * @param file  the File to check
+     * @return true if the file is a file
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(Files.isRegularFile(file));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java b/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
index d7722c0..9ff5d9b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
@@ -21,11 +21,16 @@ import java.io.FileFilter;
 import java.io.FilenameFilter;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOCase;
@@ -36,7 +41,6 @@ import org.apache.commons.io.IOCase;
  * every class you use.
  *
  * @since 1.0
- *
  */
 public class FileFilterUtils {
 
@@ -223,10 +227,6 @@ public class FileFilterUtils {
      * matches the provided filter.
      * </p>
      *
-     * <p>
-     * The {@link Set} returned by this method is not guaranteed to be thread safe.
-     * </p>
-     *
      * <pre>
      * Set&lt;File&gt; allFiles = ...
      * Set&lt;File&gt; javaFiles = FileFilterUtils.filterSet(allFiles,
@@ -249,16 +249,34 @@ public class FileFilterUtils {
         if (files == null) {
             return FileUtils.EMPTY_FILE_ARRAY;
         }
-        final List<File> acceptedFiles = new ArrayList<>();
-        for (final File file : files) {
-            if (file == null) {
-                throw new IllegalArgumentException("file array contains null");
-            }
-            if (filter.accept(file)) {
-                acceptedFiles.add(file);
-            }
+        return filterFiles(filter, Arrays.stream(files), Collectors.toList()).toArray(FileUtils.EMPTY_FILE_ARRAY);
+    }
+
+    /**
+     * <p>
+     * Applies an {@link IOFileFilter} to the provided {@link File} stream and collects the accepted files.
+     * </p>
+     *
+     * @param filter the filter to apply to the stream of files.
+     * @param stream the stream of files on which to apply the filter.
+     * @param collector how to collect the end result.
+     *
+     * @param <R> the return type.
+     * @param <A> the mutable accumulation type of the reduction operation (often hidden as an implementation detail)
+     * @return a subset of files from the stream that is accepted by the filter.
+     * @throws IllegalArgumentException if the filter is {@code null}.
+     */
+    private static <R, A> R filterFiles(final IOFileFilter filter, final Stream<File> stream,
+        final Collector<? super File, A, R> collector) {
+        //Objects.requireNonNull(filter, "filter");
+        Objects.requireNonNull(collector, "collector");
+        if (filter == null) {
+            throw new IllegalArgumentException("file filter is null");
+        }
+        if (stream == null) {
+            return Stream.<File>empty().collect(collector);
         }
-        return acceptedFiles.toArray(FileUtils.EMPTY_FILE_ARRAY);
+        return stream.filter(filter::accept).collect(collector);
     }
 
     /**
@@ -294,46 +312,6 @@ public class FileFilterUtils {
     /**
      * <p>
      * Applies an {@link IOFileFilter} to the provided {@link File}
-     * objects and appends the accepted files to the other supplied collection.
-     * </p>
-     *
-     * <pre>
-     * List&lt;File&gt; files = ...
-     * List&lt;File&gt; directories = FileFilterUtils.filterList(files,
-     *     FileFilterUtils.sizeFileFilter(FileUtils.FIFTY_MB),
-     *         new ArrayList&lt;File&gt;());
-     * </pre>
-     * @param filter the filter to apply to the collection of files.
-     * @param files the collection of files to apply the filter to.
-     * @param acceptedFiles the list of files to add accepted files to.
-     *
-     * @param <T> the type of the file collection.
-     * @return a subset of <code>files</code> that is accepted by the
-     *         file filter.
-     * @throws IllegalArgumentException if the filter is {@code null}
-     *         or <code>files</code> contains a {@code null} value.
-     */
-    private static <T extends Collection<File>> T filter(final IOFileFilter filter,
-            final Iterable<File> files, final T acceptedFiles) {
-        if (filter == null) {
-            throw new IllegalArgumentException("file filter is null");
-        }
-        if (files != null) {
-            for (final File file : files) {
-                if (file == null) {
-                    throw new IllegalArgumentException("file collection contains null");
-                }
-                if (filter.accept(file)) {
-                    acceptedFiles.add(file);
-                }
-            }
-        }
-        return acceptedFiles;
-    }
-
-    /**
-     * <p>
-     * Applies an {@link IOFileFilter} to the provided {@link File}
      * objects. The resulting list is a subset of the original files that
      * matches the provided filter.
      * </p>
@@ -382,11 +360,13 @@ public class FileFilterUtils {
      * @return a subset of <code>files</code> that is accepted by the
      *         file filter.
      * @throws IllegalArgumentException if the filter is {@code null}
-     *         or <code>files</code> contains a {@code null} value.
      * @since 2.0
      */
     public static List<File> filterList(final IOFileFilter filter, final Iterable<File> files) {
-        return filter(filter, files, new ArrayList<>());
+        if (files == null) {
+            return Collections.emptyList();
+        }
+        return filterFiles(filter, StreamSupport.stream(files.spliterator(), false), Collectors.toList());
     }
 
     /**
@@ -441,12 +421,14 @@ public class FileFilterUtils {
      * @return a subset of <code>files</code> that is accepted by the
      *         file filter.
      * @throws IllegalArgumentException if the filter is {@code null}
-     *         or <code>files</code> contains a {@code null} value.
      *
      * @since 2.0
      */
     public static Set<File> filterSet(final IOFileFilter filter, final Iterable<File> files) {
-        return filter(filter, files, new HashSet<>());
+        if (files == null) {
+            return Collections.emptySet();
+        }
+        return filterFiles(filter, StreamSupport.stream(files.spliterator(), false), Collectors.toSet());
     }
 
     /**
@@ -555,7 +537,7 @@ public class FileFilterUtils {
         if (filter == null) {
             return DirectoryFileFilter.DIRECTORY;
         }
-        return new AndFileFilter(DirectoryFileFilter.DIRECTORY, filter);
+        return DirectoryFileFilter.DIRECTORY.and(filter);
     }
 
     /**
@@ -570,7 +552,7 @@ public class FileFilterUtils {
         if (filter == null) {
             return FileFileFilter.FILE;
         }
-        return new AndFileFilter(FileFileFilter.FILE, filter);
+        return FileFileFilter.FILE.and(filter);
     }
 
     /**
@@ -618,7 +600,7 @@ public class FileFilterUtils {
      * @see NotFileFilter
      */
     public static IOFileFilter notFileFilter(final IOFileFilter filter) {
-        return new NotFileFilter(filter);
+        return filter.not();
     }
 
     /**
@@ -714,7 +696,7 @@ public class FileFilterUtils {
     public static IOFileFilter sizeRangeFileFilter(final long minSizeInclusive, final long maxSizeInclusive ) {
         final IOFileFilter minimumFilter = new SizeFileFilter(minSizeInclusive, true);
         final IOFileFilter maximumFilter = new SizeFileFilter(maxSizeInclusive + 1L, false);
-        return new AndFileFilter(minimumFilter, maximumFilter);
+        return minimumFilter.and(maximumFilter);
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
index 2145274..6d4812f 100644
--- a/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
@@ -17,36 +17,60 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This filter accepts <code>File</code>s that are hidden.
  * <p>
  * Example, showing how to print out a list of the
  * current directory's <i>hidden</i> files:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( HiddenFileFilter.HIDDEN );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(HiddenFileFilter.HIDDEN);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
  * <p>
  * Example, showing how to print out a list of the
  * current directory's <i>visible</i> (i.e. not hidden) files:
+ * </p>
  *
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( HiddenFileFilter.VISIBLE );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(HiddenFileFilter.VISIBLE);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(HiddenFileFilter.HIDDEN);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.3
  */
 public class HiddenFileFilter extends AbstractFileFilter implements Serializable {
 
@@ -56,7 +80,7 @@ public class HiddenFileFilter extends AbstractFileFilter implements Serializable
     private static final long serialVersionUID = 8930842316112759062L;
 
     /** Singleton instance of <i>visible</i> filter */
-    public static final IOFileFilter VISIBLE = new NotFileFilter(HIDDEN);
+    public static final IOFileFilter VISIBLE = HIDDEN.not();
 
     /**
      * Restrictive constructor.
@@ -76,4 +100,21 @@ public class HiddenFileFilter extends AbstractFileFilter implements Serializable
         return file.isHidden();
     }
 
+    /**
+     * Checks to see if the file is hidden.
+     *
+     * @param file  the File to check
+     * @return {@code true} if the file is
+     *  <i>hidden</i>, otherwise {@code false}.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        try {
+            return toFileVisitResult(Files.isHidden(file));
+        } catch (final IOException e) {
+            return handle(e);
+        }
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
index 068d041..aa67949 100644
--- a/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
@@ -19,14 +19,16 @@ package org.apache.commons.io.filefilter;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 
 /**
- * An interface which brings the FileFilter and FilenameFilter
- * interfaces together.
+ * An interface which brings the FileFilter, FilenameFilter, and PathFilter interfaces together.
  *
  * @since 1.0
  */
-public interface IOFileFilter extends FileFilter, FilenameFilter {
+public interface IOFileFilter extends FileFilter, FilenameFilter, PathFilter {
 
     /**
      * An empty String array.
@@ -38,7 +40,8 @@ public interface IOFileFilter extends FileFilter, FilenameFilter {
      * <p>
      * Defined in {@link java.io.FileFilter}.
      * </p>
-     * @param file  the File to check
+     *
+     * @param file the File to check
      * @return true if this file matches the test
      */
     @Override
@@ -49,11 +52,71 @@ public interface IOFileFilter extends FileFilter, FilenameFilter {
      * <p>
      * Defined in {@link java.io.FilenameFilter}.
      * </p>
-     * @param dir  the directory File to check
-     * @param name  the file name within the directory to check
+     *
+     * @param dir the directory File to check
+     * @param name the file name within the directory to check
      * @return true if this file matches the test
      */
     @Override
     boolean accept(File dir, String name);
 
+    /**
+     * Checks to see if the Path should be accepted by this filter.
+     *
+     * @param path the Path to check
+     * @return true if this path matches the test
+     * @throws IOException if an I/O error occurs
+     * @since 2.9.0
+     */
+    @Override
+    default FileVisitResult accept(final Path path) throws IOException {
+        return AbstractFileFilter.toFileVisitResult(accept(path.toFile()));
+    }
+
+    /**
+     * Checks to see if the File should be accepted by this filter.
+     *
+     * @param path the directory File to check
+     * @param name the file name within the directory to check
+     * @return true if this file matches the test
+     * @throws IOException if an I/O error occurs
+     * @since 2.9.0
+     */
+    @Override
+    default FileVisitResult accept(final Path path, final Path name) throws IOException {
+        return AbstractFileFilter.toFileVisitResult(accept(path.toFile(), name.toString()));
+    }
+
+    /**
+     * Creates a new "and" filter with this filter and the given filters.
+     *
+     * @param fileFilter the filters to "and".
+     * @return a new filter
+     * @since 2.9.0
+     */
+    default AndFileFilter and(final IOFileFilter... fileFilter) {
+        return new AndFileFilter(this, fileFilter);
+    }
+
+    /**
+     * Creates a new "not" filter with this filter.
+     *
+     * @return a new filter
+     * @since 2.9.0
+     */
+    default NotFileFilter not() {
+        return new NotFileFilter(this);
+    }
+
+    /**
+     * Creates a new "or" filter with this filter and the given filters.
+     *
+     * @param fileFilter the filters to "or".
+     * @return a new filter
+     * @since 2.9.0
+     */
+    default OrFileFilter or(final IOFileFilter... fileFilter) {
+        return new OrFileFilter(this, fileFilter);
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
index 88e3347..aec6051 100644
--- a/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
@@ -20,7 +20,12 @@ import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.io.Serializable;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
 import java.nio.charset.Charset;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Arrays;
 
 /**
@@ -30,7 +35,7 @@ import java.util.Arrays;
  * For instance, all Java class files begin with the bytes
  * <code>0xCAFEBABE</code>.
  * </p>
- *
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
  * MagicNumberFileFilter javaClassFileFilter =
@@ -57,6 +62,24 @@ import java.util.Arrays;
  *     System.out.println(tarFile);
  * }
  * </pre>
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(MagicNumberFileFilter("ustar", 257));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
  * @since 2.0
  * @see FileFilterUtils#magicNumberFileFilter(byte[])
@@ -252,6 +275,43 @@ public class MagicNumberFileFilter extends AbstractFileFilter implements
     }
 
     /**
+     * <p>
+     * Accepts the provided file if the file contains the file filter's magic
+     * number at the specified offset.
+     * </p>
+     *
+     * <p>
+     * If any {@link IOException}s occur while reading the file, the file will
+     * be rejected.
+     * </p>
+     *
+     * @param file the file to accept or reject.
+     *
+     * @return {@code true} if the file contains the filter's magic number
+     *         at the specified offset, {@code false} otherwise.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        if (file != null && Files.isRegularFile(file) && Files.isReadable(file)) {
+            try {
+                try (final FileChannel fileChannel = FileChannel.open(file)) {
+                    final ByteBuffer byteBuffer = ByteBuffer.allocate(this.magicNumbers.length);
+                    final int read = fileChannel.read(byteBuffer);
+                    if (read != magicNumbers.length) {
+                        return FileVisitResult.TERMINATE;
+                    }
+                    return toFileVisitResult(Arrays.equals(this.magicNumbers, byteBuffer.array()));
+                }
+            }
+            catch (final IOException ioe) {
+                // Do nothing, fall through and do not accept file
+            }
+        }
+        return FileVisitResult.TERMINATE;
+    }
+
+    /**
      * Returns a String representation of the file filter, which includes the
      * magic number bytes and byte offset.
      *
diff --git a/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
index 9dcde3b..b3a12a6 100644
--- a/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.apache.commons.io.IOCase;
@@ -27,25 +29,46 @@ import org.apache.commons.io.IOCase;
  * <p>
  * For example, to print all files and directories in the
  * current directory whose name is <code>Test</code>:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( new NameFileFilter("Test") );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(new NameFileFilter("Test"));
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new NameFileFilter("Test"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.0
  * @see FileFilterUtils#nameFileFilter(String)
  * @see FileFilterUtils#nameFileFilter(String, IOCase)
  */
 public class NameFileFilter extends AbstractFileFilter implements Serializable {
 
     private static final long serialVersionUID = 176844364689077340L;
+
     /** The file names to search for */
     private final String[] names;
+
     /** Whether the comparison is case sensitive. */
     private final IOCase caseSensitivity;
 
@@ -130,7 +153,6 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
         this.caseSensitivity = caseSensitivity == null ? IOCase.SENSITIVE : caseSensitivity;
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Checks to see if the file name matches.
      *
@@ -139,13 +161,7 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
      */
     @Override
     public boolean accept(final File file) {
-        final String name = file.getName();
-        for (final String name2 : this.names) {
-            if (caseSensitivity.checkEquals(name, name2)) {
-                return true;
-            }
-        }
-        return false;
+        return acceptBaseName(file.getName());
     }
 
     /**
@@ -157,8 +173,36 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
      */
     @Override
     public boolean accept(final File dir, final String name) {
-        for (final String name2 : names) {
-            if (caseSensitivity.checkEquals(name, name2)) {
+        return acceptBaseName(name);
+    }
+
+    /**
+     * Checks to see if the file name matches.
+     *
+     * @param dir  the File directory (ignored)
+     * @param name  the file name
+     * @return true if the file name matches
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        return toFileVisitResult(acceptBaseName(dir.getFileName().toString()));
+    }
+
+    /**
+     * Checks to see if the file name matches.
+     *
+     * @param file  the File to check
+     * @return true if the file name matches
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(acceptBaseName(file.getFileName().toString()));
+    }
+
+    private boolean acceptBaseName(final String baseName) {
+        for (final String testName : names) {
+            if (caseSensitivity.checkEquals(baseName, testName)) {
                 return true;
             }
         }
diff --git a/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
index 3a76d2e..c6dfa5a 100644
--- a/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
@@ -17,18 +17,21 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 
 /**
  * This filter produces a logical NOT of the filters specified.
  *
  * @since 1.0
- *
  * @see FileFilterUtils#notFileFilter(IOFileFilter)
  */
 public class NotFileFilter extends AbstractFileFilter implements Serializable {
 
     private static final long serialVersionUID = 6131563330944994230L;
+
     /** The filter */
     private final IOFileFilter filter;
 
@@ -69,6 +72,38 @@ public class NotFileFilter extends AbstractFileFilter implements Serializable {
     }
 
     /**
+     * Returns the logical NOT of the underlying filter's return value for the same File.
+     *
+     * @param file the File to check
+     * @return true if the filter returns false
+     * @throws IOException if an I/O error occurs
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) throws IOException {
+        return not(filter.accept(file));
+    }
+
+    /**
+     * Returns the logical NOT of the underlying filter's return value for the same arguments.
+     *
+     * @param file the File directory
+     * @param name the file name
+     * @return true if the filter returns false
+     * @throws IOException if an I/O error occurs
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file, final Path name) throws IOException {
+        return not(filter.accept(file, name));
+    }
+
+    private FileVisitResult not(final FileVisitResult accept) {
+        return accept == FileVisitResult.CONTINUE ? FileVisitResult.TERMINATE
+            : FileVisitResult.CONTINUE;
+    }
+
+    /**
      * Provide a String representation of this file filter.
      *
      * @return a String representation
diff --git a/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
index 85b7efd..fd4c73e 100644
--- a/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
@@ -17,8 +17,12 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -28,7 +32,6 @@ import java.util.List;
  * file filter list stops when the first filter returns {@code true}.
  *
  * @since 1.0
- *
  * @see FileFilterUtils#or(IOFileFilter...)
  */
 public class OrFileFilter extends AbstractFileFilter implements ConditionalFileFilter, Serializable {
@@ -48,7 +51,7 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
     }
 
     /**
-     * Constructs a new file filter that ORs the result of two other filters.
+     * Constructs a new file filter that ORs the result of other filters.
      *
      * @param filter1 the first filter, must not be null
      * @param filter2 the second filter, must not be null
@@ -59,8 +62,24 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
             throw new IllegalArgumentException("The filters must not be null");
         }
         this.fileFilters = new ArrayList<>(2);
-        addFileFilter(filter1);
-        addFileFilter(filter2);
+        this.fileFilters.add(filter1);
+        this.fileFilters.add(filter2);
+    }
+
+    /**
+     * Constructs a new file filter that ORs the result of other filters.
+     *
+     * @param filter1 the first filter, must not be null
+     * @param filters more filter, must not be null
+     * @throws IllegalArgumentException if either filter is null
+     */
+    public OrFileFilter(final IOFileFilter filter1, final IOFileFilter... filters) {
+        if (filter1 == null || filters == null) {
+            throw new IllegalArgumentException("The filters must not be null");
+        }
+        this.fileFilters = new ArrayList<>(filters.length + 1);
+        this.fileFilters.add(filter1);
+        this.fileFilters.addAll(Arrays.asList(filters));
     }
 
     /**
@@ -107,6 +126,32 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
      * {@inheritDoc}
      */
     @Override
+    public FileVisitResult accept(final Path file) throws IOException {
+        for (final IOFileFilter fileFilter : fileFilters) {
+            if (fileFilter.accept(file) == FileVisitResult.CONTINUE) {
+                return FileVisitResult.CONTINUE;
+            }
+        }
+        return FileVisitResult.TERMINATE;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public FileVisitResult accept(final Path file, final Path name) throws IOException {
+        for (final IOFileFilter fileFilter : fileFilters) {
+            if (fileFilter.accept(file, name) == FileVisitResult.CONTINUE) {
+                return FileVisitResult.CONTINUE;
+            }
+        }
+        return FileVisitResult.TERMINATE;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
     public void addFileFilter(final IOFileFilter ioFileFilter) {
         this.fileFilters.add(ioFileFilter);
     }
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/filefilter/PathFilter.java
similarity index 52%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/filefilter/PathFilter.java
index 8b2cdc4..71976aa 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/filefilter/PathFilter.java
@@ -15,23 +15,35 @@
  * limitations under the License.
  */
 
-package org.apache.commons.io.file;
+package org.apache.commons.io.filefilter;
 
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
 import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
 
 /**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A filter for {@link Path}s.
  *
- * @since 2.7
+ * @since 2.9.0
  */
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public interface PathFilter {
 
     /**
-     * Constructs a new instance.
+     * Tests whether or not to include the specified Path in a result.
+     *
+     * @param path The Path to test.
+     * @return a FileVisitResult
+     * @throws IOException if an I/O error occurs
      */
-    protected SimplePathVisitor() {
-        super();
-    }
+    FileVisitResult accept(Path path) throws IOException;
 
+    /**
+     * Tests whether or not to include the specified Path in a result.
+     *
+     * @param path The dir path to test.
+     * @param name The path base name to test.
+     * @return a FileVisitResult
+     * @throws IOException if an I/O error occurs
+     */
+    FileVisitResult accept(Path path, Path name) throws IOException;
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java
new file mode 100644
index 0000000..dd93842
--- /dev/null
+++ b/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.filefilter;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
+
+import org.apache.commons.io.file.NoopPathVisitor;
+import org.apache.commons.io.file.PathVisitor;
+
+/**
+ * A file filter backed by a path visitor.
+ *
+ * @since 2.9.0
+ */
+public class PathVisitorFileFilter extends AbstractFileFilter {
+
+    private final PathVisitor pathVisitor;
+
+    /**
+     * Constructs a new instance that will forward calls to the given visitor.
+     *
+     * @param pathVisitor visit me.
+     */
+    public PathVisitorFileFilter(final PathVisitor pathVisitor) {
+        super();
+        this.pathVisitor = pathVisitor == null ? NoopPathVisitor.INSTANCE : pathVisitor;
+    }
+
+    @Override
+    public boolean accept(final File file) {
+        try {
+            final Path path = file.toPath();
+            return visitFile(path, file.exists() ? getBasicFileAttributeView(path) : null) == FileVisitResult.CONTINUE;
+        } catch (final IOException e) {
+            return handle(e) == FileVisitResult.CONTINUE;
+        }
+    }
+
+    @Override
+    public boolean accept(final File dir, final String name) {
+        try {
+            return accept(dir.toPath(), Paths.get(name)) == FileVisitResult.CONTINUE;
+        } catch (final IOException e) {
+            return handle(e) == FileVisitResult.CONTINUE;
+        }
+    }
+
+    @Override
+    public FileVisitResult accept(final Path path) throws IOException {
+        return visitFile(path, getBasicFileAttributeView(path));
+    }
+
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) throws IOException {
+        return pathVisitor.postVisitDirectory(dir, null);
+
+    }
+
+    protected BasicFileAttributes getBasicFileAttributeView(final Path path) throws IOException {
+        return Files.readAttributes(path, BasicFileAttributes.class);
+    }
+
+    @Override
+    public FileVisitResult visitFile(final Path path, final BasicFileAttributes basicFileAttributeView)
+        throws IOException {
+        return pathVisitor.visitFile(path, basicFileAttributeView);
+    }
+
+}
diff --git a/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
index a57af74..cacad30 100644
--- a/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.apache.commons.io.IOCase;
@@ -27,17 +29,36 @@ import org.apache.commons.io.IOCase;
  * <p>
  * For example, to print all files and directories in the
  * current directory whose name starts with <code>Test</code>:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( new PrefixFileFilter("Test") );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(new PrefixFileFilter("Test"));
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new PrefixFileFilter("Test"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.0
  * @see FileFilterUtils#prefixFileFilter(String)
  * @see FileFilterUtils#prefixFileFilter(String, IOCase)
  */
@@ -149,13 +170,28 @@ public class PrefixFileFilter extends AbstractFileFilter implements Serializable
         return accept(file.getName());
     }
 
-    private boolean accept(final String name) {
-        for (final String prefix : prefixes) {
-            if (caseSensitivity.checkStartsWith(name, prefix)) {
-                return true;
-            }
-        }
-        return false;
+    /**
+     * Checks to see if the file name starts with the prefix.
+     *
+     * @param file  the File directory
+     * @param name  the file name
+     * @return true if the file name starts with one of our prefixes
+     */
+    @Override
+    public boolean accept(final File file, final String name) {
+        return accept(name);
+    }
+
+    /**
+     * Checks to see if the file name starts with the prefix.
+     *
+     * @param file  the File to check
+     * @return true if the file name starts with one of our prefixes
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(accept(file.getFileName().toFile()));
     }
 
     /**
@@ -164,12 +200,22 @@ public class PrefixFileFilter extends AbstractFileFilter implements Serializable
      * @param file  the File directory
      * @param name  the file name
      * @return true if the file name starts with one of our prefixes
+     * @since 2.9.0
      */
     @Override
-    public boolean accept(final File file, final String name) {
+    public FileVisitResult accept(final Path file, final Path name) {
         return accept(name);
     }
 
+    private boolean accept(final String name) {
+        for (final String prefix : prefixes) {
+            if (caseSensitivity.checkStartsWith(name, prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Provide a String representation of this file filter.
      *
diff --git a/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
index 36617dc..87879e3 100644
--- a/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.regex.Pattern;
 
 import org.apache.commons.io.IOCase;
@@ -27,18 +29,37 @@ import org.apache.commons.io.IOCase;
  * <p>
  * See java.util.regex.Pattern for regex matching rules.
  * </p>
- *
+ * <h2>Using Classic IO</h2>
  * <p>
  * e.g.
  * <pre>
  * File dir = new File(".");
  * FileFilter fileFilter = new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$");
  * File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i &lt; files.length; i++) {
- *   System.out.println(files[i]);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
  * @since 1.4
  */
 public class RegexFileFilter extends AbstractFileFilter implements Serializable {
@@ -119,4 +140,16 @@ public class RegexFileFilter extends AbstractFileFilter implements Serializable
         return pattern.matcher(name).matches();
     }
 
+    /**
+     * Checks to see if the file name matches one of the regular expressions.
+     *
+     * @param dir   the file directory (ignored)
+     * @param name  the file name
+     * @return true if the file name matches one of the regular expressions
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        return toFileVisitResult(pattern.matcher(name.toString()).matches());
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
index 3bf5286..f8bf49b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
@@ -17,7 +17,12 @@
 package org.apache.commons.io.filefilter;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
 
 /**
  * Filters files based on size, can filter either smaller files or
@@ -25,15 +30,35 @@ import java.io.Serializable;
  * <p>
  * For example, to print all files and directories in the
  * current directory whose size is greater than 1 MB:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( new SizeFileFilter(1024 * 1024) );
- * for ( int i = 0; i &lt; files.length; i++ ) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(new SizeFileFilter(1024 * 1024));
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new SizeFileFilter(1024 * 1024));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
  * @since 1.2
  * @see FileFilterUtils#sizeFileFilter(long)
  * @see FileFilterUtils#sizeFileFilter(long, boolean)
@@ -43,12 +68,12 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
 
     private static final long serialVersionUID = 7388077430788600069L;
 
-    /** The size threshold. */
-    private final long size;
-
     /** Whether the files accepted will be larger or smaller. */
     private final boolean acceptLarger;
 
+    /** The size threshold. */
+    private final long size;
+
     /**
      * Constructs a new size file filter for files equal to or
      * larger than a certain size.
@@ -91,7 +116,32 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
      */
     @Override
     public boolean accept(final File file) {
-        return acceptLarger != file.length() < size;
+        return accept(file.length());
+    }
+
+    private boolean accept(final long length) {
+        return acceptLarger != length < size;
+    }
+
+    /**
+     * Checks to see if the size of the file is favorable.
+     * <p>
+     * If size equals threshold and smaller files are required,
+     * file <b>IS NOT</b> selected.
+     * If size equals threshold and larger files are required,
+     * file <b>IS</b> selected.
+     * </p>
+     *
+     * @param file  the File to check
+     * @return true if the file name matches
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        try {
+            return toFileVisitResult(accept(Files.size(file)));
+        } catch (final IOException e) {
+            return handle(e);
+        }
     }
 
     /**
@@ -105,4 +155,9 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
         return super.toString() + "(" + condition + size + ")";
     }
 
+    @Override
+    public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+        return toFileVisitResult(accept(Files.size(file)));
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
index 88ef695..2dff98f 100644
--- a/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.apache.commons.io.IOCase;
@@ -28,17 +30,36 @@ import org.apache.commons.io.IOCase;
  * <p>
  * For example, to retrieve and print all <code>*.java</code> files
  * in the current directory:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
- * String[] files = dir.list( new SuffixFileFilter(".java") );
- * for (int i = 0; i &lt; files.length; i++) {
- *     System.out.println(files[i]);
+ * String[] files = dir.list(new SuffixFileFilter(".java"));
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new SuffixFileFilter(".java"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
  *
+ * @since 1.0
  * @see FileFilterUtils#suffixFileFilter(String)
  * @see FileFilterUtils#suffixFileFilter(String, IOCase)
  */
@@ -162,6 +183,30 @@ public class SuffixFileFilter extends AbstractFileFilter implements Serializable
         return accept(name);
     }
 
+    /**
+     * Checks to see if the file name ends with the suffix.
+     *
+     * @param file  the File to check
+     * @return true if the file name ends with one of our suffixes
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(accept(file.getFileName().toString()));
+    }
+
+    /**
+     * Checks to see if the file name ends with the suffix.
+     *
+     * @param file  the File directory
+     * @param name  the file name
+     * @return true if the file name ends with one of our suffixes
+     */
+    @Override
+    public FileVisitResult accept(final Path file, final Path name) {
+        return accept(name);
+    }
+
     private boolean accept(final String name) {
         for (final String suffix : this.suffixes) {
             if (caseSensitivity.checkEndsWith(name, suffix)) {
diff --git a/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
index 1f2f13c..0b54a43 100644
--- a/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
@@ -18,12 +18,13 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 
 /**
  * A file filter that always returns true.
  *
  * @since 1.0
- *
  * @see FileFilterUtils#trueFileFilter()
  */
 public class TrueFileFilter implements IOFileFilter, Serializable {
@@ -72,4 +73,29 @@ public class TrueFileFilter implements IOFileFilter, Serializable {
         return true;
     }
 
+    /**
+     * Returns true.
+     *
+     * @param file the file to check (ignored)
+     * @return true
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return FileVisitResult.CONTINUE;
+    }
+
+    /**
+     * Returns true.
+     *
+     * @param dir the directory to check (ignored)
+     * @param name the file name (ignored)
+     * @return true
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        return FileVisitResult.CONTINUE;
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
index 33a3d21..5a6ac11 100644
--- a/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.apache.commons.io.FilenameUtils;
@@ -39,22 +41,44 @@ import org.apache.commons.io.IOCase;
  * <p>
  * For example:
  * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
  * FileFilter fileFilter = new WildcardFileFilter("*test*.java~*~");
  * File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i &lt; files.length; i++) {
- *   System.out.println(files[i]);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new WildcardFileFilter("*test*.java~*~"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
  * @since 1.3
  */
 public class WildcardFileFilter extends AbstractFileFilter implements Serializable {
 
     private static final long serialVersionUID = -7426486598995782105L;
+
     /** The wildcards that will be used to match file names. */
     private final String[] wildcards;
+
     /** Whether the comparison is case sensitive. */
     private final IOCase caseSensitivity;
 
@@ -149,7 +173,6 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
         return accept(file.getName());
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Checks to see if the file name matches one of the wildcards.
      *
@@ -162,6 +185,30 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
         return accept(name);
     }
 
+    /**
+     * Checks to see if the file name matches one of the wildcards.
+     *
+     * @param file  the file to check
+     * @return true if the file name matches one of the wildcards.
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        return toFileVisitResult(accept(file.getFileName().toString()));
+    }
+
+    /**
+     * Checks to see if the file name matches one of the wildcards.
+     *
+     * @param dir  the file directory (ignored)
+     * @param name  the file name
+     * @return true if the file name matches one of the wildcards
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        return accept(name);
+    }
+
     private boolean accept(final String name) {
         for (final String wildcard : wildcards) {
             if (FilenameUtils.wildcardMatch(name, wildcard, caseSensitivity)) {
@@ -181,13 +228,11 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
         final StringBuilder buffer = new StringBuilder();
         buffer.append(super.toString());
         buffer.append("(");
-        if (wildcards != null) {
-            for (int i = 0; i < wildcards.length; i++) {
-                if (i > 0) {
-                    buffer.append(",");
-                }
-                buffer.append(wildcards[i]);
+        for (int i = 0; i < wildcards.length; i++) {
+            if (i > 0) {
+                buffer.append(",");
             }
+            buffer.append(wildcards[i]);
         }
         buffer.append(")");
         return buffer.toString();
diff --git a/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java b/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
index 7658398..eacb008 100644
--- a/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
@@ -18,6 +18,9 @@ package org.apache.commons.io.filefilter;
 
 import java.io.File;
 import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
 
 import org.apache.commons.io.FilenameUtils;
@@ -27,23 +30,46 @@ import org.apache.commons.io.FilenameUtils;
  * <p>
  * This filter selects files, but not directories, based on one or more wildcards
  * and using case-sensitive comparison.
+ * </p>
  * <p>
  * The wildcard matcher uses the characters '?' and '*' to represent a
  * single or multiple wildcard characters.
  * This is the same as often found on Dos/Unix command lines.
  * The extension check is case-sensitive.
  * See {@link FilenameUtils#wildcardMatch(String, String)} for more information.
+ * </p>
  * <p>
  * For example:
+ * </p>
+ * <h2>Using Classic IO</h2>
  * <pre>
  * File dir = new File(".");
  * FileFilter fileFilter = new WildcardFilter("*test*.java~*~");
  * File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i &lt; files.length; i++) {
- *   System.out.println(files[i]);
+ * for (String file : files) {
+ *     System.out.println(file);
  * }
  * </pre>
  *
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new WildcardFilter("*test*.java~*~"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
  * @since 1.1
  * @deprecated Use WildcardFileFilter. Deprecated as this class performs directory
  * filtering which it shouldn't do, but that can't be removed due to compatibility.
@@ -117,7 +143,28 @@ public class WildcardFilter extends AbstractFileFilter implements Serializable {
         return false;
     }
 
-    //-----------------------------------------------------------------------
+    /**
+     * Checks to see if the file name matches one of the wildcards.
+     *
+     * @param file the file to check
+     * @return true if the file name matches one of the wildcards
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path file) {
+        if (Files.isDirectory(file)) {
+            return FileVisitResult.TERMINATE;
+        }
+
+        for (final String wildcard : wildcards) {
+            if (FilenameUtils.wildcardMatch(file.getFileName().toString(), wildcard)) {
+                return FileVisitResult.CONTINUE;
+            }
+        }
+
+        return FileVisitResult.TERMINATE;
+    }
+
     /**
      * Checks to see if the file name matches one of the wildcards.
      *
@@ -140,4 +187,27 @@ public class WildcardFilter extends AbstractFileFilter implements Serializable {
         return false;
     }
 
+    /**
+     * Checks to see if the file name matches one of the wildcards.
+     *
+     * @param dir  the file directory
+     * @param name  the file name
+     * @return true if the file name matches one of the wildcards
+     * @since 2.9.0
+     */
+    @Override
+    public FileVisitResult accept(final Path dir, final Path name) {
+        if (dir != null && Files.isDirectory(dir.resolve(name))) {
+            return FileVisitResult.TERMINATE;
+        }
+
+        for (final String wildcard : wildcards) {
+            if (FilenameUtils.wildcardMatch(name.toString(), wildcard)) {
+                return FileVisitResult.CONTINUE;
+            }
+        }
+
+        return FileVisitResult.TERMINATE;
+    }
+
 }
diff --git a/src/main/java/org/apache/commons/io/filefilter/package.html b/src/main/java/org/apache/commons/io/filefilter/package.html
index e32a192..9612aee 100644
--- a/src/main/java/org/apache/commons/io/filefilter/package.html
+++ b/src/main/java/org/apache/commons/io/filefilter/package.html
@@ -24,6 +24,7 @@ IOFileFilter interface including implementation that allow you to combine
 other such filters.</p>
 <p>These filter can be used to list files or in {@link java.awt.FileDialog}, 
 for example.</p>
+
 <table>
     <caption>There are a number of 'primitive' filters:</caption>
        <tbody>
@@ -83,7 +84,8 @@ for example.</p>
      
   </tbody>
 </table>
-      
+
+<h2>Using Classic IO</h2>      
 <p>These boolean FilenameFilters can be nested, to allow arbitrary expressions.
 For example, here is how one could print all non-directory files in the
 current directory, starting with "A", and ending in ".java" or ".class":</p>
@@ -104,11 +106,26 @@ current directory, starting with "A", and ending in ".java" or ".class":</p>
       )
     )
   );
-  for ( int i=0; i&lt;files.length; i++ ) {
+  for (int i=0; i&lt;files.length; i++) {
+    System.out.println(files[i]);
+  }
+</pre>
+<p>
+You can alternatively build a filter tree using the "and", "or", and "not" methods on filters themselves:
+</p>
+<pre>
+  File dir = new File(".");
+  String[] files = dir.list( 
+    new AndFileFilter(
+      new PrefixFileFilter("A").and(
+        new SuffixFileFilter(".class").or(new SuffixFileFilter(".java"))),
+      new DirectoryFileFilter().not()
+    )
+  );
+  for (int i=0; i&lt;files.length; i++) {
     System.out.println(files[i]);
   }
 </pre>
-
 <p>This package also contains a utility class: 
 <a href="FileFilterUtils.html">FileFilterUtils</a>. It allows you to use all 
 file filters without having to put them in the import section. Here's how the 
@@ -129,10 +146,31 @@ above example will look using FileFilterUtils:</p>
       )
     )
   );
-  for ( int i=0; i&lt;files.length; i++ ) {
+  for (int i=0; i&lt;files.length; i++) {
     System.out.println(files[i]);
   }
 </pre>
+<h2>Using NIO</h2>
+<p>You can combine Java <b>file tree walking</b> by using <code>java.nio.file.Files.walk()</code> APIs with filters:</p>
+<pre>
+   final Path dir = Paths.get(".");
+   // We are interested in files older than one day
+   final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+   final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+   //
+   // Walk one dir
+   Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+   System.out.println(visitor.getPathCounters());
+   System.out.println(visitor.getFileList());
+   //
+   visitor.getPathCounters().reset();
+   //
+   // Walk dir tree
+   Files.<b>walkFileTree</b>(dir, visitor);
+   System.out.println(visitor.getPathCounters());
+   System.out.println(visitor.getDirList());
+   System.out.println(visitor.getFileList());
+</pre>
 <p>There are a few other goodies in that class so please have a look at the 
 documentation in detail.</p>
     </body>
diff --git a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
index 299d9e7..7042ac3 100644
--- a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
+++ b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
@@ -64,8 +64,8 @@ public class DirectoryWalkerTestCase {
     private static final IOFileFilter dirsFilter        = createNameFilter(dirs);
     private static final IOFileFilter iofilesFilter     = createNameFilter(ioFiles);
     private static final IOFileFilter outputFilesFilter = createNameFilter(outputFiles);
-    private static final IOFileFilter ioDirAndFilesFilter = new OrFileFilter(dirsFilter, iofilesFilter);
-    private static final IOFileFilter dirsAndFilesFilter = new OrFileFilter(ioDirAndFilesFilter, outputFilesFilter);
+    private static final IOFileFilter ioDirAndFilesFilter = dirsFilter.or(iofilesFilter);
+    private static final IOFileFilter dirsAndFilesFilter = ioDirAndFilesFilter.or(outputFilesFilter);
 
     // Filter to exclude SVN files
     private static final IOFileFilter NOT_SVN = FileFilterUtils.makeSVNAware(null);
diff --git a/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java b/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java
new file mode 100644
index 0000000..931bfba
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.file;
+
+import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.filefilter.AndFileFilter;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.filefilter.EmptyFileFilter;
+import org.apache.commons.io.filefilter.PathVisitorFileFilter;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests both {@link AccumulatorPathVisitor} and {@link PathVisitorFileFilter}.
+ */
+public class AccumulatorPathVisitorTest {
+
+    static Stream<Arguments> testParameters() {
+        // @formatter:off
+        return Stream.of(
+            Arguments.of((Supplier<AccumulatorPathVisitor>) () -> {
+                return AccumulatorPathVisitor.withLongCounters();
+            }),
+            Arguments.of((Supplier<AccumulatorPathVisitor>) () -> {
+                return AccumulatorPathVisitor.withBigIntegerCounters();
+            }));
+        // @formatter:on
+    }
+
+    @TempDir
+    File tempDirFile;
+
+    /**
+     * Tests an empty folder.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testEmptyFolder(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final Path tempDir = tempDirFile.toPath();
+        final AccumulatorPathVisitor accPathVisitor = supplier.get();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+        Files.walkFileTree(tempDir,
+            new AndFileFilter(countingFileFilter, DirectoryFileFilter.INSTANCE, EmptyFileFilter.EMPTY));
+        assertCounts(1, 0, 0, accPathVisitor.getPathCounters());
+        assertEquals(1, accPathVisitor.getDirList().size());
+        assertTrue(accPathVisitor.getFileList().isEmpty());
+    }
+
+    /**
+     * Tests a directory with one file of size 0.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testFolders1FileSize0(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final AccumulatorPathVisitor accPathVisitor = supplier.get();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-0"),
+            countingFileFilter);
+        assertCounts(1, 1, 0, accPathVisitor.getPathCounters());
+        assertEquals(1, accPathVisitor.getDirList().size());
+        assertEquals(1, accPathVisitor.getFileList().size());
+    }
+
+    /**
+     * Tests a directory with one file of size 1.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testFolders1FileSize1(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final AccumulatorPathVisitor accPathVisitor = supplier.get();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-1"),
+            countingFileFilter);
+        assertCounts(1, 1, 1, accPathVisitor.getPathCounters());
+        assertEquals(1, accPathVisitor.getDirList().size());
+        assertEquals(1, accPathVisitor.getFileList().size());
+    }
+
+    /**
+     * Tests a directory with two subdirectories, each containing one file of size 1.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testFolders2FileSize2(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final AccumulatorPathVisitor accPathVisitor = supplier.get();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-2-file-size-2"),
+            countingFileFilter);
+        assertCounts(3, 2, 2, accPathVisitor.getPathCounters());
+        assertEquals(3, accPathVisitor.getDirList().size());
+        assertEquals(2, accPathVisitor.getFileList().size());
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/io/file/CounterAssertions.java b/src/test/java/org/apache/commons/io/file/CounterAssertions.java
index ff27231..8a0332b 100644
--- a/src/test/java/org/apache/commons/io/file/CounterAssertions.java
+++ b/src/test/java/org/apache/commons/io/file/CounterAssertions.java
@@ -24,7 +24,7 @@ import java.math.BigInteger;
 import org.apache.commons.io.file.Counters.Counter;
 import org.apache.commons.io.file.Counters.PathCounters;
 
-class CounterAssertions {
+public class CounterAssertions {
 
     static void assertCounter(final long expected, final Counter actual, final String message) {
         assertEquals(expected, actual.get(), message);
@@ -33,15 +33,20 @@ class CounterAssertions {
     }
 
     static void assertCounts(final long expectedDirCount, final long expectedFileCount, final long expectedByteCount,
-            final CountingPathVisitor actualVisitor) {
+        final CountingPathVisitor actualVisitor) {
         assertCounts(expectedDirCount, expectedFileCount, expectedByteCount, actualVisitor.getPathCounters());
     }
 
     static void assertCounts(final long expectedDirCount, final long expectedFileCount, final long expectedByteCount,
-            final PathCounters actualPathCounters) {
+        final PathCounters actualPathCounters) {
         assertCounter(expectedDirCount, actualPathCounters.getDirectoryCounter(), "getDirectoryCounter");
         assertCounter(expectedFileCount, actualPathCounters.getFileCounter(), "getFileCounter");
         assertCounter(expectedByteCount, actualPathCounters.getByteCounter(), "getByteCounter");
     }
 
+    public static void assertZeroCounters(final PathCounters pathCounters) {
+        assertCounts(0, 0, 0, pathCounters);
+        assertEquals(Counters.longPathCounters(), pathCounters);
+    }
+
 }
diff --git a/src/test/java/org/apache/commons/io/file/CountersTest.java b/src/test/java/org/apache/commons/io/file/CountersTest.java
index 1992e0a..d386b69 100644
--- a/src/test/java/org/apache/commons/io/file/CountersTest.java
+++ b/src/test/java/org/apache/commons/io/file/CountersTest.java
@@ -19,6 +19,7 @@ package org.apache.commons.io.file;
 
 import static org.apache.commons.io.file.CounterAssertions.assertCounter;
 import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.apache.commons.io.file.Counters.Counter;
 import org.apache.commons.io.file.Counters.PathCounters;
@@ -41,6 +42,28 @@ public class CountersTest extends TestArguments {
     }
 
     @ParameterizedTest
+    @MethodSource("pathCounters")
+    public void testResetCounter(final PathCounters pathCounter) {
+        final Counter byteCounter = pathCounter.getByteCounter();
+        final long old = byteCounter.get();
+        byteCounter.add(1);
+        assertEquals(old + 1, byteCounter.get());
+        byteCounter.reset();
+        assertEquals(0, byteCounter.get());
+    }
+
+    @ParameterizedTest
+    @MethodSource("pathCounters")
+    public void testResetPathCounter(final PathCounters pathCounter) {
+        final Counter byteCounter = pathCounter.getByteCounter();
+        final long old = byteCounter.get();
+        byteCounter.add(1);
+        assertEquals(old + 1, byteCounter.get());
+        pathCounter.reset();
+        assertEquals(0, byteCounter.get());
+    }
+
+    @ParameterizedTest
     @MethodSource("numberCounters")
     public void testToString(final Counter counter) {
         // Does not blow up
diff --git a/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java b/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java
new file mode 100644
index 0000000..80a06c6
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.file;
+
+import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.filefilter.AndFileFilter;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.filefilter.EmptyFileFilter;
+import org.apache.commons.io.filefilter.PathVisitorFileFilter;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests {@link PathUtils}.
+ */
+public class PathUtilsVisitorTest {
+
+    static Stream<Arguments> testParameters() {
+        return AccumulatorPathVisitorTest.testParameters();
+    }
+
+    @TempDir
+    File tempDirFile;
+
+    /**
+     * Tests an empty folder.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testCountEmptyFolder(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final Path tempDir = tempDirFile.toPath();
+        final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+        Files.walkFileTree(tempDir,
+            new AndFileFilter(countingFileFilter, DirectoryFileFilter.INSTANCE, EmptyFileFilter.EMPTY));
+        assertCounts(1, 0, 0, countingPathVisitor.getPathCounters());
+    }
+
+    /**
+     * Tests a directory with one file of size 0.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testCountFolders1FileSize0(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-0"),
+            countingFileFilter);
+        assertCounts(1, 1, 0, countingPathVisitor.getPathCounters());
+    }
+
+    /**
+     * Tests a directory with one file of size 1.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testCountFolders1FileSize1(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-1"),
+            countingFileFilter);
+        assertCounts(1, 1, 1, countingPathVisitor.getPathCounters());
+    }
+
+    /**
+     * Tests a directory with two subdirectories, each containing one file of size 1.
+     */
+    @ParameterizedTest
+    @MethodSource("testParameters")
+    public void testCountFolders2FileSize2(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+        final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+        final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+        Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-2-file-size-2"),
+            countingFileFilter);
+        assertCounts(3, 2, 2, countingPathVisitor.getPathCounters());
+    }
+}
diff --git a/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java b/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java
new file mode 100644
index 0000000..4ab22df
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.io.filefilter;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+
+import org.apache.commons.io.file.AccumulatorPathVisitor;
+import org.apache.commons.io.file.CounterAssertions;
+import org.apache.commons.io.file.Counters;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link AgeFileFilter}.
+ */
+public class AgeFileFilterTest {
+
+    /**
+     * Javadoc example.
+     *
+     * System.out calls are commented out here but not in the Javadoc.
+     */
+    @Test
+    public void testJavadocExampleUsingIo() {
+        final File dir = new File(".");
+        // We are interested in files older than one day
+        final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+        final String[] files = dir.list(new AgeFileFilter(cutoff));
+        for (final String file : files) {
+            // System.out.println(files[i]);
+        }
+        // End of Javadoc example
+        assertTrue(files.length > 0);
+    }
+
+    /**
+     * Javadoc example.
+     *
+     * System.out calls are commented out here but not in the Javadoc.
+     */
+    @Test
+    public void testJavadocExampleUsingNio() throws IOException {
+        final Path dir = Paths.get(".");
+        // We are interested in files older than one day
+        final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+        final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+        //
+        // Walk one dir
+        Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+        // System.out.println(visitor.getPathCounters());
+        // System.out.println(visitor.getFileList());
+        //
+        visitor.getPathCounters().reset();
+        //
+        // Walk dir tree
+        Files.walkFileTree(dir, visitor);
+        // System.out.println(visitor.getPathCounters());
+        // System.out.println(visitor.getDirList());
+        // System.out.println(visitor.getFileList());
+        //
+        // End of Javadoc example
+        assertTrue(visitor.getPathCounters().getFileCounter().get() > 0);
+        assertTrue(visitor.getPathCounters().getDirectoryCounter().get() > 0);
+        assertTrue(visitor.getPathCounters().getByteCounter().get() > 0);
+        // We counted and accumulated
+        assertFalse(visitor.getDirList().isEmpty());
+        assertFalse(visitor.getFileList().isEmpty());
+        //
+        assertNotEquals(Counters.noopPathCounters(), visitor.getPathCounters());
+        visitor.getPathCounters().reset();
+        CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+    }
+
+    @Test
+    public void testNoCounting() throws IOException {
+        final Path dir = Paths.get(".");
+        final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+        final AccumulatorPathVisitor visitor = new AccumulatorPathVisitor(Counters.noopPathCounters(),
+            new AgeFileFilter(cutoff));
+        Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+        //
+        CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+        // We did not count, but we still accumulated
+        assertFalse(visitor.getDirList().isEmpty());
+        assertFalse(visitor.getFileList().isEmpty());
+    }
+}
diff --git a/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java b/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java
new file mode 100644
index 0000000..77ea8fb
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.io.filefilter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+
+import org.apache.commons.io.file.AccumulatorPathVisitor;
+import org.apache.commons.io.file.CounterAssertions;
+import org.apache.commons.io.file.Counters;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link DirectoryFileFilter}.
+ */
+public class DirectoryFileFilterTest {
+
+    /**
+     * Javadoc example.
+     *
+     * System.out calls are commented out here but not in the Javadoc.
+     */
+    @Test
+    public void testJavadocExampleUsingIo() {
+        final File dir = new File(".");
+        final String[] files = dir.list(DirectoryFileFilter.INSTANCE);
+        for (String file : files) {
+            // System.out.println(files[i]);
+        }
+        // End of Javadoc example
+        assertTrue(files.length > 0);
+    }
+
+    /**
+     * Javadoc example.
+     *
+     * System.out calls are commented out here but not in the Javadoc.
+     */
+    @Test
+    public void testJavadocExampleUsingNio() throws IOException {
+        final Path dir = Paths.get(".");
+        final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(DirectoryFileFilter.INSTANCE);
+        //
+        // Walk one dir
+        Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+        // System.out.println(visitor.getPathCounters());
+        // System.out.println(visitor.getFileList());
+        //
+        visitor.getPathCounters().reset();
+        //
+        // Walk dir tree
+        Files.walkFileTree(dir, visitor);
+        // System.out.println(visitor.getPathCounters());
+        // System.out.println(visitor.getDirList());
+        // System.out.println(visitor.getFileList());
+        //
+        // End of Javadoc example
+        assertEquals(0, visitor.getPathCounters().getFileCounter().get());
+        assertTrue(visitor.getPathCounters().getDirectoryCounter().get() > 0);
+        assertEquals(0, visitor.getPathCounters().getByteCounter().get());
+        // We counted and accumulated
+        assertFalse(visitor.getDirList().isEmpty());
+        assertFalse(visitor.getFileList().isEmpty());
+        //
+        assertNotEquals(Counters.noopPathCounters(), visitor.getPathCounters());
+        visitor.getPathCounters().reset();
+        CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+    }
+
+}
diff --git a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
index c59cdf9..2f3f451 100644
--- a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
@@ -33,6 +33,10 @@ import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -44,6 +48,7 @@ import java.util.Set;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOCase;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.file.PathUtils;
 import org.apache.commons.io.test.TestUtils;
 import org.apache.commons.lang3.SystemUtils;
 import org.junit.jupiter.api.Test;
@@ -66,51 +71,86 @@ public class FileFilterTestCase {
 
     public void assertFiltering(final IOFileFilter filter, final File file, final boolean expected) throws Exception {
         // Note. This only tests the (File, String) version if the parent of
-        //       the File passed in is not null
+        // the File passed in is not null
         assertEquals(expected, filter.accept(file),
-                "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+            "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
 
         if (file != null && file.getParentFile() != null) {
             assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
-                    "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
+                "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
         } else if (file == null) {
             assertEquals(expected, filter.accept(file),
-                    "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
+                "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
         }
         assertNotNull(filter.toString());
     }
 
-
+    public void assertFiltering(final IOFileFilter filter, final Path path, final boolean expected) throws Exception {
+        // Note. This only tests the (Path, Path) version if the parent of
+        // the File passed in is not null
+        final FileVisitResult expectedFileVisitResult = AbstractFileFilter.toFileVisitResult(expected);
+        assertEquals(expectedFileVisitResult, filter.accept(path),
+            "Filter(Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for " + path);
+
+        if (path != null && path.getParent() != null) {
+            assertEquals(expectedFileVisitResult, filter.accept(path.getParent(), path.getFileName()),
+                "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for "
+                    + path);
+        } else if (path == null) {
+            assertEquals(expectedFileVisitResult, filter.accept(path),
+                "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for null");
+        }
+        assertNotNull(filter.toString());
+    }
 
     @Test
     public void testSuffix() throws Exception {
-        IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" });
-        final File testFile = new File( "test" );
-        final File fredFile = new File( "fred" );
+        IOFileFilter filter = new SuffixFileFilter(new String[] {"tes", "est"});
+        final File testFile = new File("test");
+        final Path testPath = testFile.toPath();
+        final File fredFile = new File("fred");
+        final Path fredPath = fredFile.toPath();
+        //
         assertFiltering(filter, new File("fred.tes"), true);
         assertFiltering(filter, new File("fred.est"), true);
-        assertFiltering(filter, new File("fred.EST"), false); //case-sensitive
+        assertFiltering(filter, new File("fred.EST"), false); // case-sensitive
         assertFiltering(filter, new File("fred.exe"), false);
+        //
+        assertFiltering(filter, new File("fred.tes").toPath(), true);
+        assertFiltering(filter, new File("fred.est").toPath(), true);
+        assertFiltering(filter, new File("fred.EST").toPath(), false); // case-sensitive
+        assertFiltering(filter, new File("fred.exe").toPath(), false);
 
-        filter = FileFilterUtils.or(
-                    FileFilterUtils.suffixFileFilter( "tes" ),
-                    FileFilterUtils.suffixFileFilter( "est" ) );
+        filter = FileFilterUtils.or(FileFilterUtils.suffixFileFilter("tes"), FileFilterUtils.suffixFileFilter("est"));
         assertFiltering(filter, new File("fred"), false);
         assertFiltering(filter, new File(".tes"), true);
         assertFiltering(filter, new File("fred.test"), true);
+        //
+        assertFiltering(filter, new File("fred").toPath(), false);
+        assertFiltering(filter, new File(".tes").toPath(), true);
+        assertFiltering(filter, new File("fred.test").toPath(), true);
 
         filter = new SuffixFileFilter("est");
         assertFiltering(filter, new File("test"), true);
         assertFiltering(filter, new File("fred"), false);
+        //
+        assertFiltering(filter, new File("test").toPath(), true);
+        assertFiltering(filter, new File("fred").toPath(), false);
 
-        assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
-        assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+        assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
+        assertTrue(!filter.accept(fredFile.getParentFile(), fredFile.getName()));
+        //
+        assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath.getParent(), testPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath.getParent(), fredPath.getFileName()));
 
         final List<String> prefixes = Arrays.asList("ood", "red");
-        final IOFileFilter listFilter = new SuffixFileFilter( prefixes );
+        final IOFileFilter listFilter = new SuffixFileFilter(prefixes);
 
-        assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
-        assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+        assertTrue(!listFilter.accept(testFile.getParentFile(), testFile.getName()));
+        assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
+        //
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath.getParent(), testPath.getFileName()));
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath.getParent(), fredPath.getFileName()));
 
         try {
             new SuffixFileFilter((String) null);
@@ -129,16 +169,16 @@ public class FileFilterTestCase {
             fail();
         } catch (final IllegalArgumentException ignore) {
         }
-}
+    }
 
     @Test
     public void testSuffixCaseInsensitive() throws Exception {
 
-        IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" }, IOCase.INSENSITIVE);
+        IOFileFilter filter = new SuffixFileFilter(new String[] {"tes", "est"}, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo.tes"), true);
         assertFiltering(filter, new File("foo.est"), true);
-        assertFiltering(filter, new File("foo.EST"), true); //case-sensitive
-        assertFiltering(filter, new File("foo.TES"), true); //case-sensitive
+        assertFiltering(filter, new File("foo.EST"), true); // case-sensitive
+        assertFiltering(filter, new File("foo.TES"), true); // case-sensitive
         assertFiltering(filter, new File("foo.exe"), false);
 
         filter = new SuffixFileFilter("est", IOCase.INSENSITIVE);
@@ -149,8 +189,8 @@ public class FileFilterTestCase {
         filter = new SuffixFileFilter(suffixes, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("bar.tes"), true);
         assertFiltering(filter, new File("bar.est"), true);
-        assertFiltering(filter, new File("bar.EST"), true); //case-sensitive
-        assertFiltering(filter, new File("bar.TES"), true); //case-sensitive
+        assertFiltering(filter, new File("bar.EST"), true); // case-sensitive
+        assertFiltering(filter, new File("bar.TES"), true); // case-sensitive
         assertFiltering(filter, new File("bar.exe"), false);
 
         try {
@@ -189,14 +229,20 @@ public class FileFilterTestCase {
         final IOFileFilter filter = new DirectoryFileFilter();
 
         assertFiltering(filter, new File("src/"), true);
+        assertFiltering(filter, new File("src/").toPath(), true);
         assertFiltering(filter, new File("src/main/java/"), true);
+        assertFiltering(filter, new File("src/main/java/").toPath(), true);
 
         assertFiltering(filter, new File("pom.xml"), false);
+        assertFiltering(filter, new File("pom.xml").toPath(), false);
 
         assertFiltering(filter, new File("imaginary"), false);
+        assertFiltering(filter, new File("imaginary").toPath(), false);
         assertFiltering(filter, new File("imaginary/"), false);
+        assertFiltering(filter, new File("imaginary/").toPath(), false);
 
         assertFiltering(filter, new File("LICENSE.txt"), false);
+        assertFiltering(filter, new File("LICENSE.txt").toPath(), false);
 
         assertSame(DirectoryFileFilter.DIRECTORY, DirectoryFileFilter.INSTANCE);
     }
@@ -207,47 +253,74 @@ public class FileFilterTestCase {
         final IOFileFilter filter = FileFileFilter.FILE;
 
         assertFiltering(filter, new File("src/"), false);
+        assertFiltering(filter, new File("src/").toPath(), false);
         assertFiltering(filter, new File("src/java/"), false);
+        assertFiltering(filter, new File("src/java/").toPath(), false);
 
         assertFiltering(filter, new File("pom.xml"), true);
+        assertFiltering(filter, new File("pom.xml").toPath(), true);
 
         assertFiltering(filter, new File("imaginary"), false);
+        assertFiltering(filter, new File("imaginary").toPath(), false);
         assertFiltering(filter, new File("imaginary/"), false);
+        assertFiltering(filter, new File("imaginary/").toPath(), false);
 
         assertFiltering(filter, new File("LICENSE.txt"), true);
+        assertFiltering(filter, new File("LICENSE.txt").toPath(), true);
     }
 
     @Test
     public void testPrefix() throws Exception {
-        IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" });
-        final File testFile = new File( "test" );
-        final File fredFile = new File( "fred" );
+        IOFileFilter filter = new PrefixFileFilter(new String[] {"foo", "bar"});
+        final File testFile = new File("test");
+        final Path testPath = testFile.toPath();
+        final File fredFile = new File("fred");
+        final Path fredPath = fredFile.toPath();
 
         assertFiltering(filter, new File("foo.test"), true);
-        assertFiltering(filter, new File("FOO.test"), false);  //case-sensitive
+        assertFiltering(filter, new File("FOO.test"), false); // case-sensitive
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("food/"), true);
-
-        filter = FileFilterUtils.prefixFileFilter( "bar" );
+        //
+        assertFiltering(filter, new File("foo.test").toPath(), true);
+        assertFiltering(filter, new File("FOO.test").toPath(), false); // case-sensitive
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("food/").toPath(), true);
+
+        filter = FileFilterUtils.prefixFileFilter("bar");
         assertFiltering(filter, new File("barred\\"), true);
         assertFiltering(filter, new File("test"), false);
         assertFiltering(filter, new File("fo_o.test"), false);
         assertFiltering(filter, new File("abar.exe"), false);
+        //
+        assertFiltering(filter, new File("barred\\").toPath(), true);
+        assertFiltering(filter, new File("test").toPath(), false);
+        assertFiltering(filter, new File("fo_o.test").toPath(), false);
+        assertFiltering(filter, new File("abar.exe").toPath(), false);
 
         filter = new PrefixFileFilter("tes");
         assertFiltering(filter, new File("test"), true);
         assertFiltering(filter, new File("fred"), false);
+        //
+        assertFiltering(filter, new File("test").toPath(), true);
+        assertFiltering(filter, new File("fred").toPath(), false);
 
-        assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
-        assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+        assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
+        assertTrue(!filter.accept(fredFile.getParentFile(), fredFile.getName()));
+        //
+        assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath.getParent(), testPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath.getParent(), fredPath.getFileName()));
 
         final List<String> prefixes = Arrays.asList("foo", "fre");
-        final IOFileFilter listFilter = new PrefixFileFilter( prefixes );
-
-        assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
-        assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+        final IOFileFilter listFilter = new PrefixFileFilter(prefixes);
 
+        assertTrue(!listFilter.accept(testFile.getParentFile(), testFile.getName()));
+        assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
+        //
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath.getParent(), testPath.getFileName()));
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath.getParent(), fredPath.getFileName()));
 
         try {
             new PrefixFileFilter((String) null);
@@ -271,24 +344,24 @@ public class FileFilterTestCase {
     @Test
     public void testPrefixCaseInsensitive() throws Exception {
 
-        IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
+        IOFileFilter filter = new PrefixFileFilter(new String[] {"foo", "bar"}, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo.test1"), true);
         assertFiltering(filter, new File("bar.test1"), true);
-        assertFiltering(filter, new File("FOO.test1"), true);  //case-sensitive
-        assertFiltering(filter, new File("BAR.test1"), true);  //case-sensitive
+        assertFiltering(filter, new File("FOO.test1"), true); // case-sensitive
+        assertFiltering(filter, new File("BAR.test1"), true); // case-sensitive
 
         filter = new PrefixFileFilter("bar", IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo.test2"), false);
         assertFiltering(filter, new File("bar.test2"), true);
-        assertFiltering(filter, new File("FOO.test2"), false); //case-sensitive
-        assertFiltering(filter, new File("BAR.test2"), true);  //case-sensitive
+        assertFiltering(filter, new File("FOO.test2"), false); // case-sensitive
+        assertFiltering(filter, new File("BAR.test2"), true); // case-sensitive
 
         final List<String> prefixes = Arrays.asList("foo", "bar");
         filter = new PrefixFileFilter(prefixes, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo.test3"), true);
         assertFiltering(filter, new File("bar.test3"), true);
-        assertFiltering(filter, new File("FOO.test3"), true);  //case-sensitive
-        assertFiltering(filter, new File("BAR.test3"), true);  //case-sensitive
+        assertFiltering(filter, new File("FOO.test3"), true); // case-sensitive
+        assertFiltering(filter, new File("BAR.test3"), true); // case-sensitive
 
         try {
             new PrefixFileFilter((String) null, IOCase.INSENSITIVE);
@@ -312,8 +385,8 @@ public class FileFilterTestCase {
         filter = FileFilterUtils.prefixFileFilter("bar", IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo.test2"), false);
         assertFiltering(filter, new File("bar.test2"), true);
-        assertFiltering(filter, new File("FOO.test2"), false); //case-sensitive
-        assertFiltering(filter, new File("BAR.test2"), true);  //case-sensitive
+        assertFiltering(filter, new File("FOO.test2"), false); // case-sensitive
+        assertFiltering(filter, new File("BAR.test2"), true); // case-sensitive
 
         try {
             FileFilterUtils.prefixFileFilter(null, IOCase.INSENSITIVE);
@@ -324,34 +397,55 @@ public class FileFilterTestCase {
 
     @Test
     public void testNameFilter() throws Exception {
-        IOFileFilter filter = new NameFileFilter(new String[] { "foo", "bar" });
+        IOFileFilter filter = new NameFileFilter(new String[] {"foo", "bar"});
+        assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("fred"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("fred").toPath(), false);
 
-        filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SENSITIVE);
+        filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.SENSITIVE);
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("FOO"), false);
         assertFiltering(filter, new File("BAR"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), false);
+        assertFiltering(filter, new File("BAR").toPath(), false);
 
-        filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
+        filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("FOO"), true);
         assertFiltering(filter, new File("BAR"), true);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), true);
+        assertFiltering(filter, new File("BAR").toPath(), true);
 
-        filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SYSTEM);
+        filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.SYSTEM);
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("FOO"), WINDOWS);
         assertFiltering(filter, new File("BAR"), WINDOWS);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), WINDOWS);
+        assertFiltering(filter, new File("BAR").toPath(), WINDOWS);
 
-        filter = new NameFileFilter(new String[]{"foo", "bar"}, null);
+        filter = new NameFileFilter(new String[] {"foo", "bar"}, null);
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("FOO"), false);
         assertFiltering(filter, new File("BAR"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), false);
+        assertFiltering(filter, new File("BAR").toPath(), false);
 
         // repeat for a List
         final java.util.ArrayList<String> list = new java.util.ArrayList<>();
@@ -361,21 +455,34 @@ public class FileFilterTestCase {
         assertFiltering(filter, new File("foo"), true);
         assertFiltering(filter, new File("bar"), true);
         assertFiltering(filter, new File("fred"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("bar").toPath(), true);
+        assertFiltering(filter, new File("fred").toPath(), false);
 
         filter = new NameFileFilter("foo");
         assertFiltering(filter, new File("foo"), true);
-        assertFiltering(filter, new File("FOO"), false); //case-sensitive
+        assertFiltering(filter, new File("FOO"), false); // case-sensitive
         assertFiltering(filter, new File("barfoo"), false);
         assertFiltering(filter, new File("foobar"), false);
         assertFiltering(filter, new File("fred"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), false); // case-sensitive
+        assertFiltering(filter, new File("barfoo").toPath(), false);
+        assertFiltering(filter, new File("foobar").toPath(), false);
+        assertFiltering(filter, new File("fred").toPath(), false);
 
         // FileFilterUtils.nameFileFilter(String, IOCase) tests
         filter = FileFilterUtils.nameFileFilter("foo", IOCase.INSENSITIVE);
         assertFiltering(filter, new File("foo"), true);
-        assertFiltering(filter, new File("FOO"), true); //case-insensitive
+        assertFiltering(filter, new File("FOO"), true); // case-insensitive
         assertFiltering(filter, new File("barfoo"), false);
         assertFiltering(filter, new File("foobar"), false);
         assertFiltering(filter, new File("fred"), false);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, new File("FOO").toPath(), true); // case-insensitive
+        assertFiltering(filter, new File("barfoo").toPath(), false);
+        assertFiltering(filter, new File("foobar").toPath(), false);
+        assertFiltering(filter, new File("fred").toPath(), false);
     }
 
     @Test
@@ -383,14 +490,14 @@ public class FileFilterTestCase {
         final String test = null;
         try {
             new NameFileFilter(test);
-            fail( "constructing a NameFileFilter with a null String argument should fail.");
-        } catch( final IllegalArgumentException ignore ) {
+            fail("constructing a NameFileFilter with a null String argument should fail.");
+        } catch (final IllegalArgumentException ignore) {
         }
 
         try {
             FileFilterUtils.nameFileFilter(test, IOCase.INSENSITIVE);
-            fail( "constructing a NameFileFilter with a null String argument should fail.");
-        } catch( final IllegalArgumentException ignore ) {
+            fail("constructing a NameFileFilter with a null String argument should fail.");
+        } catch (final IllegalArgumentException ignore) {
         }
     }
 
@@ -410,7 +517,12 @@ public class FileFilterTestCase {
         final IOFileFilter filter = FileFilterUtils.trueFileFilter();
         assertFiltering(filter, new File("foo.test"), true);
         assertFiltering(filter, new File("foo"), true);
-        assertFiltering(filter, null, true);
+        assertFiltering(filter, (File) null, true);
+        //
+        assertFiltering(filter, new File("foo.test").toPath(), true);
+        assertFiltering(filter, new File("foo").toPath(), true);
+        assertFiltering(filter, (Path) null, true);
+        //
         assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
     }
 
@@ -418,8 +530,11 @@ public class FileFilterTestCase {
     public void testFalse() throws Exception {
         final IOFileFilter filter = FileFilterUtils.falseFileFilter();
         assertFiltering(filter, new File("foo.test"), false);
+        assertFiltering(filter, new File("foo.test").toPath(), false);
         assertFiltering(filter, new File("foo"), false);
-        assertFiltering(filter, null, false);
+        assertFiltering(filter, new File("foo").toPath(), false);
+        assertFiltering(filter, (File) null, false);
+        assertFiltering(filter, (Path) null, false);
         assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
     }
 
@@ -428,12 +543,13 @@ public class FileFilterTestCase {
         final IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
         assertFiltering(filter, new File("foo.test"), false);
         assertFiltering(filter, new File("foo"), false);
-        assertFiltering(filter, null, false);
+        assertFiltering(filter.not(), new File("foo"), true);
+        assertFiltering(filter, (File) null, false);
         assertThrows(IllegalArgumentException.class, () -> new NotFileFilter(null));
     }
 
     @Test
-    public void testAnd() throws Exception {
+    public void testAnd2() throws Exception {
         final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
         final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
         assertFiltering(new AndFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
@@ -442,62 +558,95 @@ public class FileFilterTestCase {
         assertFiltering(new AndFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
 
         final List<IOFileFilter> filters = new ArrayList<>();
-        assertFiltering( new AndFileFilter( filters ), new File( "test" ), false );
-        assertFiltering( new AndFileFilter(), new File( "test" ), false );
+        assertFiltering(new AndFileFilter(filters), new File("test"), false);
+        assertFiltering(new AndFileFilter(), new File("test"), false);
 
-        try {
-            new AndFileFilter(falseFilter, null);
-            fail();
-        } catch (final IllegalArgumentException ignore) {
-        }
+        assertThrows(IllegalArgumentException.class, () -> new AndFileFilter(falseFilter, (IOFileFilter) null));
+        assertThrows(IllegalArgumentException.class, () -> new AndFileFilter(null, falseFilter));
 
-        try {
-            new AndFileFilter(null, falseFilter);
-            fail();
-        } catch (final IllegalArgumentException ignore) {
-        }
-
-        final AndFileFilter f = new AndFileFilter(null);
+        final AndFileFilter f = new AndFileFilter((List) null);
         assertTrue(f.getFileFilters().isEmpty());
 
         assertNotNull(f.toString()); // TODO better tests
     }
 
     @Test
+    public void testAnd() throws Exception {
+        final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
+        final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
+        assertFiltering(trueFilter.and(trueFilter), new File("foo.test"), true);
+        assertFiltering(trueFilter.and(falseFilter), new File("foo.test"), false);
+        assertFiltering(falseFilter.and(trueFilter), new File("foo.test"), false);
+        assertFiltering(falseFilter.and(trueFilter), new File("foo.test"), false);
+        assertFiltering(falseFilter.and(trueFilter, trueFilter), new File("foo.test"), false);
+        assertFiltering(falseFilter.and(trueFilter, trueFilter, trueFilter), new File("foo.test"), false);
+    }
+
+    @Test
+    public void testAndArray() throws Exception {
+        final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
+        final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
+        assertFiltering(new AndFileFilter(trueFilter, trueFilter, trueFilter), new File("foo.test"), true);
+        assertFiltering(new AndFileFilter(trueFilter, falseFilter, falseFilter), new File("foo.test"), false);
+        assertFiltering(new AndFileFilter(falseFilter, trueFilter, trueFilter), new File("foo.test"), false);
+        assertFiltering(new AndFileFilter(falseFilter, falseFilter, falseFilter), new File("foo.test"), false);
+
+        final List<IOFileFilter> filters = new ArrayList<>();
+        assertFiltering(new AndFileFilter(filters), new File("test"), false);
+        assertFiltering(new AndFileFilter(), new File("test"), false);
+    }
+
+    @Test
     public void testOr() throws Exception {
         final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
         final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
-        final File testFile = new File( "foo.test" );
+        final File testFile = new File("foo.test");
+        final Path testPath = testFile.toPath();
         assertFiltering(new OrFileFilter(trueFilter, trueFilter), testFile, true);
         assertFiltering(new OrFileFilter(trueFilter, falseFilter), testFile, true);
         assertFiltering(new OrFileFilter(falseFilter, trueFilter), testFile, true);
         assertFiltering(new OrFileFilter(falseFilter, falseFilter), testFile, false);
         assertFiltering(new OrFileFilter(), testFile, false);
+        //
+        assertFiltering(new OrFileFilter(trueFilter, trueFilter), testPath, true);
+        assertFiltering(new OrFileFilter(trueFilter, falseFilter), testPath, true);
+        assertFiltering(new OrFileFilter(falseFilter, trueFilter), testPath, true);
+        assertFiltering(new OrFileFilter(falseFilter, falseFilter), testPath, false);
+        assertFiltering(new OrFileFilter(), testPath, false);
+        //
+        assertFiltering(falseFilter.or(trueFilter), testPath, true);
+        assertFiltering(falseFilter.or(falseFilter, trueFilter), testPath, true);
+        assertFiltering(falseFilter.or(falseFilter, falseFilter, trueFilter), testPath, true);
 
         final List<IOFileFilter> filters = new ArrayList<>();
-        filters.add( trueFilter );
-        filters.add( falseFilter );
+        filters.add(trueFilter);
+        filters.add(falseFilter);
 
-        final OrFileFilter orFilter = new OrFileFilter( filters );
+        final OrFileFilter orFilter = new OrFileFilter(filters);
 
         assertFiltering(orFilter, testFile, true);
-        assertEquals( orFilter.getFileFilters(), filters );
-        orFilter.removeFileFilter( trueFilter );
+        assertFiltering(orFilter, testPath, true);
+        assertEquals(orFilter.getFileFilters(), filters);
+        orFilter.removeFileFilter(trueFilter);
         assertFiltering(orFilter, testFile, false);
-        orFilter.setFileFilters( filters );
+        assertFiltering(orFilter, testPath, false);
+        orFilter.setFileFilters(filters);
         assertFiltering(orFilter, testFile, true);
+        assertFiltering(orFilter, testPath, true);
 
-        assertTrue( orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
-        orFilter.removeFileFilter( trueFilter );
-        assertTrue( !orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
+        assertTrue(orFilter.accept(testFile.getParentFile(), testFile.getName()));
+        assertEquals(FileVisitResult.CONTINUE, orFilter.accept(testPath.getParent(), testPath.getFileName()));
+        orFilter.removeFileFilter(trueFilter);
+        assertTrue(!orFilter.accept(testFile.getParentFile(), testFile.getName()));
+        assertEquals(FileVisitResult.TERMINATE, orFilter.accept(testPath.getParent(), testPath.getFileName()));
 
         try {
-            new OrFileFilter(falseFilter, null);
+            new OrFileFilter(falseFilter, (IOFileFilter) null);
             fail();
         } catch (final IllegalArgumentException ex) {
         }
 
-        final OrFileFilter f = new OrFileFilter(null);
+        final OrFileFilter f = new OrFileFilter((List<IOFileFilter>) null);
         assertTrue(f.getFileFilters().isEmpty());
     }
 
@@ -515,7 +664,7 @@ public class FileFilterTestCase {
     public void testFileFilterUtils_or() throws Exception {
         final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
         final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
-        final File testFile = new File( "foo.test" );
+        final File testFile = new File("foo.test");
         assertFiltering(FileFilterUtils.or(trueFilter, trueFilter), testFile, true);
         assertFiltering(FileFilterUtils.or(trueFilter, trueFilter, falseFilter), testFile, true);
         assertFiltering(FileFilterUtils.or(falseFilter, trueFilter), testFile, true);
@@ -527,41 +676,70 @@ public class FileFilterTestCase {
     public void testDeprecatedWildcard() throws Exception {
         IOFileFilter filter = new WildcardFilter("*.txt");
         final List<String> patternList = Arrays.asList("*.txt", "*.xml", "*.gif");
-        final IOFileFilter listFilter = new WildcardFilter( patternList );
-        final File txtFile = new File( "test.txt" );
-        final File bmpFile = new File( "test.bmp" );
-        final File dir = new File( "src/java" );
+        final IOFileFilter listFilter = new WildcardFilter(patternList);
+        final File txtFile = new File("test.txt");
+        final Path txtPath = txtFile.toPath();
+        final File bmpFile = new File("test.bmp");
+        final Path bmpPath = bmpFile.toPath();
+        final File dirFile = new File("src/java");
+        final Path dirPath = dirFile.toPath();
 
         assertFiltering(filter, new File("log.txt"), true);
 //        assertFiltering(filter, new File("log.txt.bak"), false);
+        assertFiltering(filter, new File("log.txt").toPath(), true);
 
         filter = new WildcardFilter("log?.txt");
         assertFiltering(filter, new File("log1.txt"), true);
         assertFiltering(filter, new File("log12.txt"), false);
+        //
+        assertFiltering(filter, new File("log1.txt").toPath(), true);
+        assertFiltering(filter, new File("log12.txt").toPath(), false);
 
         filter = new WildcardFilter("open??.????04");
         assertFiltering(filter, new File("openAB.102504"), true);
         assertFiltering(filter, new File("openA.102504"), false);
         assertFiltering(filter, new File("openXY.123103"), false);
 //        assertFiltering(filter, new File("openAB.102504.old"), false);
+        //
+        assertFiltering(filter, new File("openAB.102504").toPath(), true);
+        assertFiltering(filter, new File("openA.102504").toPath(), false);
+        assertFiltering(filter, new File("openXY.123103").toPath(), false);
+//        assertFiltering(filter, new File("openAB.102504.old").toPath(), false);
 
         filter = new WildcardFilter(new String[] {"*.java", "*.class"});
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.class"), true);
         assertFiltering(filter, new File("Test.jsp"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.class").toPath(), true);
+        assertFiltering(filter, new File("Test.jsp").toPath(), false);
 
         assertFiltering(listFilter, new File("Test.txt"), true);
         assertFiltering(listFilter, new File("Test.xml"), true);
         assertFiltering(listFilter, new File("Test.gif"), true);
         assertFiltering(listFilter, new File("Test.bmp"), false);
-
-        assertTrue( listFilter.accept( txtFile ) );
-        assertTrue( !listFilter.accept( bmpFile ) );
-        assertTrue( !listFilter.accept( dir ) );
-
-        assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
-        assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
-        assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
+        //
+        assertFiltering(listFilter, new File("Test.txt").toPath(), true);
+        assertFiltering(listFilter, new File("Test.xml").toPath(), true);
+        assertFiltering(listFilter, new File("Test.gif").toPath(), true);
+        assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
+
+        assertTrue(listFilter.accept(txtFile));
+        assertTrue(!listFilter.accept(bmpFile));
+        assertTrue(!listFilter.accept(dirFile));
+        //
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath));
+
+        assertTrue(listFilter.accept(txtFile.getParentFile(), txtFile.getName()));
+        assertTrue(!listFilter.accept(bmpFile.getParentFile(), bmpFile.getName()));
+        assertTrue(!listFilter.accept(dirFile.getParentFile(), dirFile.getName()));
+        //
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath.getParent(), txtPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath.getParent(), bmpPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath.getParent(), dirPath.getFileName()));
 
         try {
             new WildcardFilter((String) null);
@@ -590,99 +768,149 @@ public class FileFilterTestCase {
         IOFileFilter filter = new WildcardFileFilter("*.txt");
         assertFiltering(filter, new File("log.txt"), true);
         assertFiltering(filter, new File("log.TXT"), false);
+        //
+        assertFiltering(filter, new File("log.txt").toPath(), true);
+        assertFiltering(filter, new File("log.TXT").toPath(), false);
 
         filter = new WildcardFileFilter("*.txt", IOCase.SENSITIVE);
         assertFiltering(filter, new File("log.txt"), true);
         assertFiltering(filter, new File("log.TXT"), false);
+        //
+        assertFiltering(filter, new File("log.txt").toPath(), true);
+        assertFiltering(filter, new File("log.TXT").toPath(), false);
 
         filter = new WildcardFileFilter("*.txt", IOCase.INSENSITIVE);
         assertFiltering(filter, new File("log.txt"), true);
         assertFiltering(filter, new File("log.TXT"), true);
+        //
+        assertFiltering(filter, new File("log.txt").toPath(), true);
+        assertFiltering(filter, new File("log.TXT").toPath(), true);
 
         filter = new WildcardFileFilter("*.txt", IOCase.SYSTEM);
         assertFiltering(filter, new File("log.txt"), true);
         assertFiltering(filter, new File("log.TXT"), WINDOWS);
+        //
+        assertFiltering(filter, new File("log.txt").toPath(), true);
+        assertFiltering(filter, new File("log.TXT").toPath(), WINDOWS);
 
         filter = new WildcardFileFilter("*.txt", null);
         assertFiltering(filter, new File("log.txt"), true);
         assertFiltering(filter, new File("log.TXT"), false);
+        //
+        assertFiltering(filter, new File("log.txt").toPath(), true);
+        assertFiltering(filter, new File("log.TXT").toPath(), false);
 
         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"});
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.class"), true);
         assertFiltering(filter, new File("Test.jsp"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.class").toPath(), true);
+        assertFiltering(filter, new File("Test.jsp").toPath(), false);
 
         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SENSITIVE);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.JAVA"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.JAVA").toPath(), false);
 
         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.INSENSITIVE);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.JAVA"), true);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.JAVA").toPath(), true);
 
         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SYSTEM);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.JAVA"), WINDOWS);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.JAVA").toPath(), WINDOWS);
 
-        filter = new WildcardFileFilter(new String[]{"*.java", "*.class"}, null);
+        filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, null);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("Test.JAVA"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("Test.JAVA").toPath(), false);
 
         final List<String> patternList = Arrays.asList("*.txt", "*.xml", "*.gif");
-        final IOFileFilter listFilter = new WildcardFileFilter( patternList );
+        final IOFileFilter listFilter = new WildcardFileFilter(patternList);
         assertFiltering(listFilter, new File("Test.txt"), true);
         assertFiltering(listFilter, new File("Test.xml"), true);
         assertFiltering(listFilter, new File("Test.gif"), true);
         assertFiltering(listFilter, new File("Test.bmp"), false);
-
-        final File txtFile = new File( "test.txt" );
-        final File bmpFile = new File( "test.bmp" );
-        final File dir = new File( "src/java" );
-        assertTrue( listFilter.accept( txtFile ) );
-        assertTrue( !listFilter.accept( bmpFile ) );
-        assertTrue( !listFilter.accept( dir ) );
-
-        assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
-        assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
-        assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
+        //
+        assertFiltering(listFilter, new File("Test.txt").toPath(), true);
+        assertFiltering(listFilter, new File("Test.xml").toPath(), true);
+        assertFiltering(listFilter, new File("Test.gif").toPath(), true);
+        assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
+
+        final File txtFile = new File("test.txt");
+        final Path txtPath = txtFile.toPath();
+        final File bmpFile = new File("test.bmp");
+        final Path bmpPath = bmpFile.toPath();
+        final File dirFile = new File("src/java");
+        final Path dirPath = dirFile.toPath();
+        assertTrue(listFilter.accept(txtFile));
+        assertTrue(!listFilter.accept(bmpFile));
+        assertTrue(!listFilter.accept(dirFile));
+        //
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtFile.toPath()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpFile.toPath()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirFile.toPath()));
+
+        assertTrue(listFilter.accept(txtFile.getParentFile(), txtFile.getName()));
+        assertTrue(!listFilter.accept(bmpFile.getParentFile(), bmpFile.getName()));
+        assertTrue(!listFilter.accept(dirFile.getParentFile(), dirFile.getName()));
+        //
+        assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath.getParent(), txtPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath.getParent(), bmpPath.getFileName()));
+        assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath.getParent(), dirPath.getFileName()));
 
         try {
             new WildcardFileFilter((String) null);
             fail();
-        } catch (final IllegalArgumentException ignore) {}
+        } catch (final IllegalArgumentException ignore) {
+        }
         try {
             new WildcardFileFilter((String[]) null);
             fail();
-        } catch (final IllegalArgumentException ignore) {}
+        } catch (final IllegalArgumentException ignore) {
+        }
         try {
             new WildcardFileFilter((List<String>) null);
             fail();
-        } catch (final IllegalArgumentException ignore) {}
+        } catch (final IllegalArgumentException ignore) {
+        }
     }
 
     @Test
     public void testDelegateFileFilter() throws Exception {
         final OrFileFilter orFilter = new OrFileFilter();
-        final File testFile = new File( "test.txt" );
+        final File testFile = new File("test.txt");
 
         IOFileFilter filter = new DelegateFileFilter((FileFilter) orFilter);
-        assertFiltering( filter, testFile, false );
+        assertFiltering(filter, testFile, false);
         assertNotNull(filter.toString()); // TODO better test
 
         filter = new DelegateFileFilter((FilenameFilter) orFilter);
-        assertFiltering( filter, testFile, false );
+        assertFiltering(filter, testFile, false);
         assertNotNull(filter.toString()); // TODO better test
 
         try {
             new DelegateFileFilter((FileFilter) null);
             fail();
-        } catch( final IllegalArgumentException ignore ) {
+        } catch (final IllegalArgumentException ignore) {
         }
 
         try {
             new DelegateFileFilter((FilenameFilter) null);
             fail();
-        } catch( final IllegalArgumentException ignore ) {
+        } catch (final IllegalArgumentException ignore) {
         }
 
     }
@@ -690,8 +918,7 @@ public class FileFilterTestCase {
     @Test
     public void testMakeCVSAware() throws Exception {
         final IOFileFilter filter1 = FileFilterUtils.makeCVSAware(null);
-        final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils
-            .nameFileFilter("test-file1.txt"));
+        final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
 
         File file = new File(temporaryFolder, "CVS");
         file.mkdirs();
@@ -701,11 +928,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, "test-file1.txt");
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output2 =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output2 = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output2, 0);
         }
         assertFiltering(filter1, file, true);
@@ -713,11 +938,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, "test-file2.log");
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output1, 0);
         }
         assertFiltering(filter1, file, true);
@@ -725,11 +948,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, "CVS");
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output, 0);
         }
         assertFiltering(filter1, file, true);
@@ -739,8 +960,7 @@ public class FileFilterTestCase {
     @Test
     public void testMakeSVNAware() throws Exception {
         final IOFileFilter filter1 = FileFilterUtils.makeSVNAware(null);
-        final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils
-            .nameFileFilter("test-file1.txt"));
+        final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
 
         File file = new File(temporaryFolder, SVN_DIR_NAME);
         file.mkdirs();
@@ -750,11 +970,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, "test-file1.txt");
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output2 =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output2 = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output2, 0);
         }
         assertFiltering(filter1, file, true);
@@ -762,11 +980,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, "test-file2.log");
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output1, 0);
         }
         assertFiltering(filter1, file, true);
@@ -774,11 +990,9 @@ public class FileFilterTestCase {
 
         file = new File(temporaryFolder, SVN_DIR_NAME);
         if (!file.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + file
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(file))) {
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file))) {
             TestUtils.generateTestData(output, 0);
         }
         assertFiltering(filter1, file, true);
@@ -788,33 +1002,31 @@ public class FileFilterTestCase {
     @Test
     public void testAgeFilter() throws Exception {
         final File oldFile = new File(temporaryFolder, "old.txt");
+        final Path oldPath = oldFile.toPath();
         final File reference = new File(temporaryFolder, "reference.txt");
         final File newFile = new File(temporaryFolder, "new.txt");
+        final Path newPath = newFile.toPath();
 
         if (!oldFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + oldFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + oldFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(oldFile))) {
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(oldFile))) {
             TestUtils.generateTestData(output1, 0);
         }
 
         do {
             try {
                 TestUtils.sleep(1000);
-            } catch(final InterruptedException ie) {
+            } catch (final InterruptedException ie) {
                 // ignore
             }
             if (!reference.getParentFile().exists()) {
-                throw new IOException("Cannot create file " + reference
-                        + " as the parent directory does not exist");
+                throw new IOException("Cannot create file " + reference + " as the parent directory does not exist");
             }
-            try (final BufferedOutputStream output =
-                    new BufferedOutputStream(new FileOutputStream(reference))) {
+            try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(reference))) {
                 TestUtils.generateTestData(output, 0);
             }
-        } while( oldFile.lastModified() == reference.lastModified() );
+        } while (oldFile.lastModified() == reference.lastModified());
 
         final Date date = new Date();
         final long now = date.getTime();
@@ -822,18 +1034,16 @@ public class FileFilterTestCase {
         do {
             try {
                 TestUtils.sleep(1000);
-            } catch(final InterruptedException ie) {
+            } catch (final InterruptedException ie) {
                 // ignore
             }
             if (!newFile.getParentFile().exists()) {
-                throw new IOException("Cannot create file " + newFile
-                        + " as the parent directory does not exist");
+                throw new IOException("Cannot create file " + newFile + " as the parent directory does not exist");
             }
-            try (final BufferedOutputStream output =
-                    new BufferedOutputStream(new FileOutputStream(newFile))) {
+            try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(newFile))) {
                 TestUtils.generateTestData(output, 0);
             }
-        } while( reference.lastModified() == newFile.lastModified() );
+        } while (reference.lastModified() == newFile.lastModified());
 
         final IOFileFilter filter1 = FileFilterUtils.ageFileFilter(now);
         final IOFileFilter filter2 = FileFilterUtils.ageFileFilter(now, true);
@@ -863,26 +1073,41 @@ public class FileFilterTestCase {
         assertFiltering(filter7, newFile, false);
         assertFiltering(filter8, newFile, false);
         assertFiltering(filter9, newFile, true);
+        //
+        assertFiltering(filter1, oldPath, true);
+        assertFiltering(filter2, oldPath, true);
+        assertFiltering(filter3, oldPath, false);
+        assertFiltering(filter4, oldPath, true);
+        assertFiltering(filter5, oldPath, true);
+        assertFiltering(filter6, oldPath, false);
+        assertFiltering(filter7, oldPath, true);
+        assertFiltering(filter8, oldPath, true);
+        assertFiltering(filter9, oldPath, false);
+        assertFiltering(filter1, newPath, false);
+        assertFiltering(filter2, newPath, false);
+        assertFiltering(filter3, newPath, true);
+        assertFiltering(filter4, newPath, false);
+        assertFiltering(filter5, newPath, false);
+        assertFiltering(filter6, newPath, true);
+        assertFiltering(filter7, newPath, false);
+        assertFiltering(filter8, newPath, false);
+        assertFiltering(filter9, newPath, true);
     }
 
     @Test
-    public void testSizeFilter() throws Exception {
+    public void testSizeFilterOnFiles() throws Exception {
         final File smallFile = new File(temporaryFolder, "small.txt");
         if (!smallFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + smallFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + smallFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(smallFile))) {
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(smallFile))) {
             TestUtils.generateTestData(output1, 32);
         }
         final File largeFile = new File(temporaryFolder, "large.txt");
         if (!largeFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + largeFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + largeFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(largeFile))){
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(largeFile))) {
             TestUtils.generateTestData(output, 128);
         }
         final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
@@ -922,28 +1147,89 @@ public class FileFilterTestCase {
     }
 
     @Test
-    public void testHidden() throws Exception {
-        final File hiddenDir = new File(SVN_DIR_NAME);
-        if (hiddenDir.exists()) {
-            assertFiltering(HiddenFileFilter.HIDDEN,  hiddenDir, hiddenDir.isHidden());
-            assertFiltering(HiddenFileFilter.VISIBLE, hiddenDir, !hiddenDir.isHidden());
+    public void testSizeFilterOnPaths() throws Exception {
+        final Path smallFile = Paths.get(temporaryFolder.toString(), "small.txt");
+        if (!Files.exists(smallFile.getParent())) {
+            throw new IOException("Cannot create file " + smallFile + " as the parent directory does not exist");
+        }
+        try (OutputStream output = Files.newOutputStream(smallFile)) {
+            TestUtils.generateTestData(output, 32);
+        }
+        final Path largeFile = Paths.get(temporaryFolder.toString(), "large.txt");
+        if (!Files.exists(largeFile.getParent())) {
+            throw new IOException("Cannot create file " + largeFile + " as the parent directory does not exist");
+        }
+        try (OutputStream output = Files.newOutputStream(largeFile)) {
+            TestUtils.generateTestData(output, 128);
+        }
+        final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
+        final IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
+        final IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
+
+        assertFiltering(filter1, smallFile, false);
+        assertFiltering(filter2, smallFile, false);
+        assertFiltering(filter3, smallFile, true);
+        assertFiltering(filter1, largeFile, true);
+        assertFiltering(filter2, largeFile, true);
+        assertFiltering(filter3, largeFile, false);
+
+        // size range tests
+        final IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
+        final IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
+        final IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
+        final IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
+        final IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
+
+        assertFiltering(filter4, smallFile, false);
+        assertFiltering(filter4, largeFile, false);
+        assertFiltering(filter5, smallFile, true);
+        assertFiltering(filter5, largeFile, false);
+        assertFiltering(filter6, smallFile, false);
+        assertFiltering(filter6, largeFile, true);
+        assertFiltering(filter7, smallFile, true);
+        assertFiltering(filter7, largeFile, true);
+        assertFiltering(filter8, largeFile, true);
+
+        try {
+            FileFilterUtils.sizeFileFilter(-1);
+            fail();
+        } catch (final IllegalArgumentException ex) {
+            // expected
         }
-        assertFiltering(HiddenFileFilter.HIDDEN,  temporaryFolder, false);
+    }
+
+    @Test
+    public void testHidden() throws Exception {
+        final File hiddenDirFile = new File(SVN_DIR_NAME);
+        final Path hiddenDirPath = hiddenDirFile.toPath();
+        if (hiddenDirFile.exists()) {
+            assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirFile, hiddenDirFile.isHidden());
+            assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirPath, hiddenDirFile.isHidden());
+            assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirFile, !hiddenDirFile.isHidden());
+            assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirPath, !hiddenDirFile.isHidden());
+        }
+        final Path path = temporaryFolder.toPath();
+        assertFiltering(HiddenFileFilter.HIDDEN, temporaryFolder, false);
+        assertFiltering(HiddenFileFilter.HIDDEN, path, false);
         assertFiltering(HiddenFileFilter.VISIBLE, temporaryFolder, true);
+        assertFiltering(HiddenFileFilter.VISIBLE, path, true);
     }
 
     @Test
     public void testCanExecute() throws Exception {
         assumeTrue(SystemUtils.IS_OS_WINDOWS);
         final File executableFile = File.createTempFile(getClass().getSimpleName(), ".temp");
+        final Path executablePath = executableFile.toPath();
         try {
             try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(executableFile))) {
                 TestUtils.generateTestData(output, 32);
             }
             assertTrue(executableFile.setExecutable(true));
             assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executableFile, true);
+            assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executablePath, true);
             executableFile.setExecutable(false);
             assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executableFile, false);
+            assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executablePath, false);
         } finally {
             executableFile.delete();
         }
@@ -952,37 +1238,40 @@ public class FileFilterTestCase {
     @Test
     public void testCanRead() throws Exception {
         final File readOnlyFile = new File(temporaryFolder, "read-only-file1.txt");
+        final Path readOnlyPath = readOnlyFile.toPath();
         if (!readOnlyFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + readOnlyFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(readOnlyFile))) {
             TestUtils.generateTestData(output, 32);
         }
         assertTrue(readOnlyFile.setReadOnly());
-        assertFiltering(CanReadFileFilter.CAN_READ,  readOnlyFile, true);
-        assertFiltering(CanReadFileFilter.CANNOT_READ,  readOnlyFile, false);
+        assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
+        assertFiltering(CanReadFileFilter.CAN_READ, readOnlyPath, true);
+        assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
+        assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyPath, false);
         assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
+        assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyPath, true);
         readOnlyFile.delete();
     }
 
     @Test
     public void testCanWrite() throws Exception {
         final File readOnlyFile = new File(temporaryFolder, "read-only-file2.txt");
+        final Path readOnlyPath = readOnlyFile.toPath();
         if (!readOnlyFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + readOnlyFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(readOnlyFile))) {
             TestUtils.generateTestData(output, 32);
         }
         assertTrue(readOnlyFile.setReadOnly());
-        assertFiltering(CanWriteFileFilter.CAN_WRITE,    temporaryFolder, true);
+        assertFiltering(CanWriteFileFilter.CAN_WRITE, temporaryFolder, true);
         assertFiltering(CanWriteFileFilter.CANNOT_WRITE, temporaryFolder, false);
-        assertFiltering(CanWriteFileFilter.CAN_WRITE,    readOnlyFile, false);
+        assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
+        assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyPath, false);
         assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
+        assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyPath, true);
         readOnlyFile.delete();
     }
 
@@ -990,50 +1279,56 @@ public class FileFilterTestCase {
     public void testEmpty() throws Exception {
 
         // Empty Dir
-        final File emptyDir  = new File(temporaryFolder, "empty-dir");
-        emptyDir.mkdirs();
-        assertFiltering(EmptyFileFilter.EMPTY, emptyDir, true);
-        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, false);
+        final File emptyDirFile = new File(temporaryFolder, "empty-dir");
+        final Path emptyDirPath = emptyDirFile.toPath();
+        emptyDirFile.mkdirs();
+        assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, true);
+        assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, true);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, false);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, false);
 
         // Empty File
-        final File emptyFile = new File(emptyDir, "empty-file.txt");
+        final File emptyFile = new File(emptyDirFile, "empty-file.txt");
+        final Path emptyPath = emptyFile.toPath();
         if (!emptyFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + emptyFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + emptyFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(emptyFile))){
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(emptyFile))) {
             TestUtils.generateTestData(output1, 0);
         }
         assertFiltering(EmptyFileFilter.EMPTY, emptyFile, true);
+        assertFiltering(EmptyFileFilter.EMPTY, emptyPath, true);
         assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyFile, false);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyPath, false);
 
         // Not Empty Dir
-        assertFiltering(EmptyFileFilter.EMPTY, emptyDir, false);
-        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, true);
+        assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, false);
+        assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, false);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, true);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, true);
 
         // Not Empty File
-        final File notEmptyFile = new File(emptyDir, "not-empty-file.txt");
+        final File notEmptyFile = new File(emptyDirFile, "not-empty-file.txt");
+        final Path notEmptyPath = notEmptyFile.toPath();
         if (!notEmptyFile.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + notEmptyFile
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + notEmptyFile + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(notEmptyFile))){
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(notEmptyFile))) {
             TestUtils.generateTestData(output, 32);
         }
         assertFiltering(EmptyFileFilter.EMPTY, notEmptyFile, false);
+        assertFiltering(EmptyFileFilter.EMPTY, notEmptyPath, false);
         assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyFile, true);
-        FileUtils.forceDelete(emptyDir);
+        assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyPath, true);
+        FileUtils.forceDelete(emptyDirFile);
     }
 
-    //-----------------------------------------------------------------------
+    // -----------------------------------------------------------------------
     @Test
     public void testMakeDirectoryOnly() throws Exception {
         assertSame(DirectoryFileFilter.DIRECTORY, FileFilterUtils.makeDirectoryOnly(null));
 
-        final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(
-                FileFilterUtils.nameFileFilter("B"));
+        final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(FileFilterUtils.nameFileFilter("B"));
 
         final File fileA = new File(temporaryFolder, "A");
         final File fileB = new File(temporaryFolder, "B");
@@ -1048,19 +1343,15 @@ public class FileFilterTestCase {
         FileUtils.deleteDirectory(fileB);
 
         if (!fileA.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + fileA
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + fileA + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(fileA))) {
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(fileA))) {
             TestUtils.generateTestData(output1, 32);
         }
         if (!fileB.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + fileB
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + fileB + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(fileB))) {
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(fileB))) {
             TestUtils.generateTestData(output, 32);
         }
 
@@ -1071,13 +1362,12 @@ public class FileFilterTestCase {
         fileB.delete();
     }
 
-    //-----------------------------------------------------------------------
+    // -----------------------------------------------------------------------
     @Test
     public void testMakeFileOnly() throws Exception {
         assertSame(FileFileFilter.FILE, FileFilterUtils.makeFileOnly(null));
 
-        final IOFileFilter filter = FileFilterUtils.makeFileOnly(
-                FileFilterUtils.nameFileFilter("B"));
+        final IOFileFilter filter = FileFilterUtils.makeFileOnly(FileFilterUtils.nameFileFilter("B"));
 
         final File fileA = new File(temporaryFolder, "A");
         final File fileB = new File(temporaryFolder, "B");
@@ -1092,19 +1382,15 @@ public class FileFilterTestCase {
         FileUtils.deleteDirectory(fileB);
 
         if (!fileA.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + fileA
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + fileA + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output1 =
-                new BufferedOutputStream(new FileOutputStream(fileA))){
+        try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(fileA))) {
             TestUtils.generateTestData(output1, 32);
         }
         if (!fileB.getParentFile().exists()) {
-            throw new IOException("Cannot create file " + fileB
-                    + " as the parent directory does not exist");
+            throw new IOException("Cannot create file " + fileB + " as the parent directory does not exist");
         }
-        try (final BufferedOutputStream output =
-                new BufferedOutputStream(new FileOutputStream(fileB))){
+        try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(fileB))) {
             TestUtils.generateTestData(output, 32);
         }
 
@@ -1115,45 +1401,57 @@ public class FileFilterTestCase {
         fileB.delete();
     }
 
-    //-----------------------------------------------------------------------
+    // -----------------------------------------------------------------------
 
     @Test
     public void testMagicNumberFileFilterBytes() throws Exception {
-        final byte[] classFileMagicNumber = new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };
+        final byte[] classFileMagicNumber = new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
         final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
 
-        final File classFileA = new File(temporaryFolder, "A.class");
-        final File xmlFileB = new File(temporaryFolder, "B.xml");
+        final File classAFile = new File(temporaryFolder, "A.class");
+        final Path classAPath = classAFile.toPath();
+        final File xmlBFile = new File(temporaryFolder, "B.xml");
+        final Path xmlBPath = xmlBFile.toPath();
         final File emptyFile = new File(temporaryFolder, "C.xml");
-        final File dir = new File(temporaryFolder, "D");
-        dir.mkdirs();
+        final Path emptyPath = emptyFile.toPath();
+        final File dirFile = new File(temporaryFolder, "D");
+        final Path dirPath = dirFile.toPath();
+        dirFile.mkdirs();
 
-        try (final OutputStream classFileAStream = FileUtils.openOutputStream(classFileA)) {
+        try (final OutputStream classFileAStream = FileUtils.openOutputStream(classAFile)) {
             IOUtils.write(classFileMagicNumber, classFileAStream);
             TestUtils.generateTestData(classFileAStream, 32);
         }
 
-        FileUtils.write(xmlFileB, xmlFileContent, StandardCharsets.UTF_8);
+        FileUtils.write(xmlBFile, xmlFileContent, StandardCharsets.UTF_8);
         FileUtils.touch(emptyFile);
 
         IOFileFilter filter = new MagicNumberFileFilter(classFileMagicNumber);
 
-        assertFiltering(filter, classFileA, true);
-        assertFiltering(filter, xmlFileB, false);
+        assertFiltering(filter, classAFile, true);
+        assertFiltering(filter, classAPath, true);
+        assertFiltering(filter, xmlBFile, false);
+        assertFiltering(filter, xmlBPath, false);
         assertFiltering(filter, emptyFile, false);
-        assertFiltering(filter, dir, false);
+        assertFiltering(filter, emptyPath, false);
+        assertFiltering(filter, dirFile, false);
+        assertFiltering(filter, dirPath, false);
 
         filter = FileFilterUtils.magicNumberFileFilter(classFileMagicNumber);
 
-        assertFiltering(filter, classFileA, true);
-        assertFiltering(filter, xmlFileB, false);
+        assertFiltering(filter, classAFile, true);
+        assertFiltering(filter, classAPath, true);
+        assertFiltering(filter, xmlBFile, false);
+        assertFiltering(filter, xmlBPath, false);
         assertFiltering(filter, emptyFile, false);
-        assertFiltering(filter, dir, false);
+        assertFiltering(filter, emptyPath, false);
+        assertFiltering(filter, dirFile, false);
+        assertFiltering(filter, dirPath, false);
     }
 
     @Test
     public void testMagicNumberFileFilterBytesOffset() throws Exception {
-        final byte[] tarMagicNumber = new byte[] { 0x75, 0x73, 0x74, 0x61, 0x72 };
+        final byte[] tarMagicNumber = new byte[] {0x75, 0x73, 0x74, 0x61, 0x72};
         final long tarMagicNumberOffset = 257;
 
         final File tarFileA = new File(temporaryFolder, "A.tar");
@@ -1188,7 +1486,7 @@ public class FileFilterTestCase {
 
     @Test
     public void testMagicNumberFileFilterString() throws Exception {
-        final byte[] classFileMagicNumber = new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };
+        final byte[] classFileMagicNumber = new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
         final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
         final String xmlMagicNumber = "<?xml version=\"1.0\"";
 
@@ -1255,7 +1553,7 @@ public class FileFilterTestCase {
     @Test
     public void testMagicNumberFileFilterValidation() {
         try {
-            new MagicNumberFileFilter((String)null, 0);
+            new MagicNumberFileFilter((String) null, 0);
             fail();
         } catch (final IllegalArgumentException iae) {
             // expected
@@ -1273,31 +1571,31 @@ public class FileFilterTestCase {
             // expected
         }
         try {
-            new MagicNumberFileFilter((byte[])null, 0);
+            new MagicNumberFileFilter((byte[]) null, 0);
             fail();
         } catch (final IllegalArgumentException iae) {
             // expected
         }
         try {
-            new MagicNumberFileFilter(new byte[]{0}, -1);
+            new MagicNumberFileFilter(new byte[] {0}, -1);
             fail();
         } catch (final IllegalArgumentException iae) {
             // expected
         }
         try {
-            new MagicNumberFileFilter(new byte[]{}, 0);
+            new MagicNumberFileFilter(new byte[] {}, 0);
             fail();
         } catch (final IllegalArgumentException iae) {
             // expected
         }
-}
+    }
 
     /*
-     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)}
-     * that tests that the method properly filters files from the list.
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+     * files from the list.
      */
     @Test
-    public void testFilterArray() throws Exception {
+    public void testFilterArray_IOFileFilter() throws Exception {
         final File fileA = TestUtils.newFile(temporaryFolder, "A");
         final File fileB = TestUtils.newFile(temporaryFolder, "B");
 
@@ -1310,8 +1608,43 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filter(IOFileFilter, java.lang.Iterable)}
-     * that tests that the method properly filters files from the list.
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+     * files from the list.
+     */
+    @Test
+    public void testFilterArray_PathVisitorFileFilter_FileExistsNo() throws Exception {
+        final File fileA = TestUtils.newFile(temporaryFolder, "A");
+        final File fileB = TestUtils.newFile(temporaryFolder, "B");
+
+        final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
+
+        final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
+
+        assertEquals(1, filtered.length);
+        assertEquals(fileA, filtered[0]);
+    }
+
+    /*
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+     * files from the list.
+     */
+    @Test
+    public void testFilterArray_PathVisitorFileFilter_FileExistsYes() throws Exception {
+        final File fileA = TestUtils.newFile(temporaryFolder, "A");
+        final File fileB = TestUtils.newFile(temporaryFolder, "B");
+        FileUtils.write(fileA, "test", StandardCharsets.US_ASCII);
+
+        final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
+
+        final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
+
+        assertEquals(1, filtered.length);
+        assertEquals(fileA, filtered[0]);
+    }
+
+    /*
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, java.lang.Iterable)} that tests that the method
+     * properly filters files from the list.
      */
     @Test
     public void testFilterArray_fromList() throws Exception {
@@ -1328,12 +1661,10 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)}
-     * that tests {@code null} parameters and {@code null} elements
-     * in the provided list.
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests {@code null} parameters.
      */
     @Test
-    public void testFilterArrayNullParameters() throws Exception {
+    public void testFilterFilesArrayNullParameters() throws Exception {
         final File fileA = TestUtils.newFile(temporaryFolder, "A");
         final File fileB = TestUtils.newFile(temporaryFolder, "B");
         try {
@@ -1344,20 +1675,36 @@ public class FileFilterTestCase {
         }
 
         final IOFileFilter filter = FileFilterUtils.trueFileFilter();
+        FileFilterUtils.filter(filter, fileA, null);
+
+        final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
+        assertEquals(0, filtered.length);
+    }
+
+    /*
+     * Test method for {@link FileFilterUtils#filter(IOFileFilter, Path...)}.
+     */
+    @Test
+    public void testFilterPathsArrayNullParameters() throws Exception {
+        final Path fileA = TestUtils.newFile(temporaryFolder, "A").toPath();
+        final Path fileB = TestUtils.newFile(temporaryFolder, "B").toPath();
         try {
-            FileFilterUtils.filter(filter, fileA, null);
+            PathUtils.filter(null, fileA, fileB);
             fail();
-        } catch (final IllegalArgumentException iae) {
-            // Test passes, exception thrown for list containing null
+        } catch (final NullPointerException iae) {
+            // Test passes, exception thrown for null filter
         }
 
-        final File[] filtered = FileFilterUtils.filter(filter, (File[])null);
+        final IOFileFilter filter = FileFilterUtils.trueFileFilter();
+        PathUtils.filter(filter, fileA, null);
+
+        final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
         assertEquals(0, filtered.length);
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)}
-     * that tests that the method properly filters files from the list.
+     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)} that tests that the method
+     * properly filters files from the list.
      */
     @Test
     public void testFilterList() throws Exception {
@@ -1374,8 +1721,8 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, File...)}
-     * that tests that the method properly filters files from the list.
+     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, File...)} that tests that the method properly
+     * filters files from the list.
      */
     @Test
     public void testFilterList_fromArray() throws Exception {
@@ -1391,9 +1738,8 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)}
-     * that tests {@code null} parameters and {@code null} elements
-     * in the provided list.
+     * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)} that tests {@code null}
+     * parameters and {@code null} elements in the provided list.
      */
     @Test
     public void testFilterListNullParameters() {
@@ -1407,18 +1753,17 @@ public class FileFilterTestCase {
         final IOFileFilter filter = FileFilterUtils.trueFileFilter();
         try {
             FileFilterUtils.filterList(filter, Collections.singletonList((File) null));
-            fail();
         } catch (final IllegalArgumentException iae) {
             // Test passes, exception thrown for list containing null
         }
 
-        final List<File> filteredList = FileFilterUtils.filterList(filter, (List<File>)null);
+        final List<File> filteredList = FileFilterUtils.filterList(filter, (List<File>) null);
         assertEquals(0, filteredList.size());
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)}
-     * that tests that the method properly filters files from the set.
+     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)} that tests that the method
+     * properly filters files from the set.
      */
     @Test
     public void testFilterSet() throws Exception {
@@ -1435,8 +1780,8 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, File...)}
-     * that tests that the method properly filters files from the set.
+     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, File...)} that tests that the method properly
+     * filters files from the set.
      */
     @Test
     public void testFilterSet_fromArray() throws Exception {
@@ -1452,12 +1797,11 @@ public class FileFilterTestCase {
     }
 
     /*
-     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)}
-     * that tests {@code null} parameters and {@code null} elements
-     * in the provided set.
+     * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)} that tests {@code null}
+     * parameters and {@code null} elements in the provided set.
      */
     @Test
-   public void testFilterSetNullParameters() {
+    public void testFilterSetNullParameters() {
         try {
             FileFilterUtils.filterSet(null, Collections.<File>emptySet());
             fail();
@@ -1468,12 +1812,11 @@ public class FileFilterTestCase {
         final IOFileFilter filter = FileFilterUtils.trueFileFilter();
         try {
             FileFilterUtils.filterSet(filter, new HashSet<>(Collections.singletonList((File) null)));
-            fail();
         } catch (final IllegalArgumentException iae) {
             // Test passes, exception thrown for set containing null
         }
 
-        final Set<File> filteredSet = FileFilterUtils.filterSet(filter, (Set<File>)null);
+        final Set<File> filteredSet = FileFilterUtils.filterSet(filter, (Set<File>) null);
         assertEquals(0, filteredSet.size());
     }
 
@@ -1491,7 +1834,7 @@ public class FileFilterTestCase {
             // expected
         }
         try {
-            FileFilterUtils.toList(new IOFileFilter[]{null});
+            FileFilterUtils.toList(new IOFileFilter[] {null});
             fail("Expected IllegalArgumentException");
         } catch (final IllegalArgumentException ignore) {
             // expected
diff --git a/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java b/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
index 3b2783f..0962973 100644
--- a/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
@@ -40,7 +40,9 @@ public abstract class IOFileFilterAbstractTestCase {
         // Note. This only tests the (File, String) version if the parent of
         //       the File passed in is not null
         assertEquals(expected, filter.accept(file),
-                "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+            "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+        assertEquals(expected, filter.accept(file.toPath()),
+            "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
 
         if (file != null && file.getParentFile() != null) {
             assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
diff --git a/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java b/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
index ed75f14..cc16f84 100644
--- a/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
@@ -20,6 +20,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import java.io.File;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
 import java.util.regex.Pattern;
 
 import org.apache.commons.io.IOCase;
@@ -45,32 +47,69 @@ public class RegexFileFilterTestCase {
         }
     }
 
+    public void assertFiltering(final IOFileFilter filter, final Path file, final boolean expected) throws Exception {
+        // Note. This only tests the (Path, Path) version if the parent of
+        // the Path passed in is not null
+        final FileVisitResult expectedFileVisitResult = AbstractFileFilter.toFileVisitResult(expected);
+        assertEquals(expectedFileVisitResult, filter.accept(file),
+            "Filter(Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for " + file);
+
+        if (file != null && file.getParent() != null) {
+            assertEquals(expectedFileVisitResult, filter.accept(file.getParent(), file.getFileName()),
+                "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for "
+                    + file);
+        } else if (file == null) {
+            assertEquals(expectedFileVisitResult, filter.accept(file),
+                "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for null");
+        }
+    }
+
     @Test
     public void testRegex() throws Exception {
         IOFileFilter filter = new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$");
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("test-10.java"), true);
         assertFiltering(filter, new File("test-.java"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("test-10.java").toPath(), true);
+        assertFiltering(filter, new File("test-.java").toPath(), false);
 
         filter = new RegexFileFilter("^[Tt]est.java$");
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("test.java"), true);
         assertFiltering(filter, new File("tEST.java"), false);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("test.java").toPath(), true);
+        assertFiltering(filter, new File("tEST.java").toPath(), false);
 
         filter = new RegexFileFilter(Pattern.compile("^test.java$", Pattern.CASE_INSENSITIVE));
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("test.java"), true);
         assertFiltering(filter, new File("tEST.java"), true);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("test.java").toPath(), true);
+        assertFiltering(filter, new File("tEST.java").toPath(), true);
 
         filter = new RegexFileFilter("^test.java$", Pattern.CASE_INSENSITIVE);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("test.java"), true);
         assertFiltering(filter, new File("tEST.java"), true);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("test.java").toPath(), true);
+        assertFiltering(filter, new File("tEST.java").toPath(), true);
 
         filter = new RegexFileFilter("^test.java$", IOCase.INSENSITIVE);
         assertFiltering(filter, new File("Test.java"), true);
         assertFiltering(filter, new File("test.java"), true);
         assertFiltering(filter, new File("tEST.java"), true);
+        //
+        assertFiltering(filter, new File("Test.java").toPath(), true);
+        assertFiltering(filter, new File("test.java").toPath(), true);
+        assertFiltering(filter, new File("tEST.java").toPath(), true);
 
         try {
             new RegexFileFilter((String)null);