Linux Find Command

https://leetcode.com/discuss/interview-question/369272/Amazon-or-Onsite-or-Linux-Find-Command Version 1:

class File {
    String name;
    int size;
    int type;
    boolean isDirectory;
    File[] children;
}

abstract class Filter {
    abstract boolean apply(File file);
}

class MinSizeFilter extends Filter {

    int minSize;

    public MinSizeFilter(int minSize) {
        this.minSize = minSize;
    }

    @Override
    boolean apply(File file) {
        return file.size > minSize;
    }
}

class TypeFilter extends Filter {

    int type;

    public TypeFilter(int type) {
        this.type = type;
    }

    @Override
    boolean apply(File file) {
        return file.type == type;
    }
}

class FindCommand {

    public List<File> findWithFilters(File directory, List<Filter> filters) {
        if (!directory.isDirectory) {
            return new NotADirectoryException();
        }
        List<File> output = new ArrayList<>();
        findWithFilters(directory, filters, output);
        return output;
    }

    private void findWithFilters(File directory, List<Filter> filters, List<File> output) {
        if (directory.children == null) {
            return;
        }
        for (File file : directory.children) {
            if (file.isDirectory) {
                findWithFilters(file, filters, output);
            } else {
                boolean selectFile = true;
                for (Filter filter : filters) {
                    if (!filter.apply(file)) {
                        selectFile = false;
                    }
                }
                if (selectFile) {
                    output.add(file);
                }
            }
        }
    }
}

Version 2:

 public interface Filter {
       public boolean match(File f);
   }

public class ExtensionFilter implements Filter {
       final private String ext;
   
       public ExtensionFilter(String ext) {
           this.ext = ext;
       }
   
       public boolean match(File f) {
           return f.getName().endsWith("." + ext);
       }
   }

public class SizeFilter implements Filter {
       enum SizeOperator {
           LT,
           LTE,
           EQ,
           GT,
           GTE
       };
   
       private final int size;
       private final SizeOperator op;
   
       public SizeFilter(int size, SizeOperator op) {
           this.size = size;
           this.op = op;
       }
   
       public boolean match(File f) {
          int actualSize = f.length();
           switch (op) {
               case LT:
                   return actualSize < size;
               case LTE:
                   return actualSize <= size;
               case EQ:
                   return actualSize == size;
               case GT:
                   return actualSize > size;
               case GTE:
                   return actualSize >= size;
           }
   
           return false;
       }
   }

public void find(File f, Filter filter, List<Files> files) {
           if (f.isDirectory()) {
               for (File file : baseDir.listFiles()) {
                  find(file, filter, files);
               }
           } else {
                  if (filter.match(f)) {
                       files.add(f);
                   }
             }
       }