see 08/10 log

README-CN.md

@@ -192,40 +192,38 @@ setBufferSize              : 设置缓冲区尺寸
 
 * ### 文件相关→[FileUtils.java][file.java]→[Test][file.test]
 ```
-getFileByPath            : 根据文件路径获取文件
-isFileExists             : 判断文件是否存在
-rename                   : 重命名文件
-isDir                    : 判断是否是目录
-isFile                   : 判断是否是文件
-createOrExistsDir        : 判断目录是否存在，不存在则判断是否创建成功
-createOrExistsFile       : 判断文件是否存在，不存在则判断是否创建成功
-createFileByDeleteOldFile: 判断文件是否存在，存在则在创建之前删除
-copyDir                  : 复制目录
-copyFile                 : 复制文件
-moveDir                  : 移动目录
-moveFile                 : 移动文件
-deleteDir                : 删除目录
-deleteFile               : 删除文件
-listFilesInDir           : 获取目录下所有文件
-listFilesInDir           : 获取目录下所有文件包括子目录
-listFilesInDirWithFilter : 获取目录下所有后缀名为suffix的文件
-listFilesInDirWithFilter : 获取目录下所有后缀名为suffix的文件包括子目录
-listFilesInDirWithFilter : 获取目录下所有符合filter的文件
-listFilesInDirWithFilter : 获取目录下所有符合filter的文件包括子目录
-searchFileInDir          : 获取目录下指定文件名的文件包括子目录
-getFileLastModified      : 获取文件最后修改的毫秒时间戳
-getFileCharsetSimple     : 简单获取文件编码格式
-getFileLines             : 获取文件行数
-getDirSize               : 获取目录大小
-getFileSize              : 获取文件大小
-getDirLength             : 获取目录长度
-getFileLength            : 获取文件长度
-getFileMD5               : 获取文件的MD5校验码
-getFileMD5ToString       : 获取文件的MD5校验码
-getDirName               : 根据全路径获取最长目录
-getFileName              : 根据全路径获取文件名
-getFileNameNoExtension   : 根据全路径获取文件名不带拓展名
-getFileExtension         : 根据全路径获取文件拓展名
+getFileByPath             : 根据文件路径获取文件
+isFileExists              : 判断文件是否存在
+rename                    : 重命名文件
+isDir                     : 判断是否是目录
+isFile                    : 判断是否是文件
+createOrExistsDir         : 判断目录是否存在，不存在则判断是否创建成功
+createOrExistsFile        : 判断文件是否存在，不存在则判断是否创建成功
+createFileByDeleteOldFile : 判断文件是否存在，存在则在创建之前删除
+copyDir                   : 复制目录
+copyFile                  : 复制文件
+moveDir                   : 移动目录
+moveFile                  : 移动文件
+deleteDir                 : 删除目录
+deleteFile                : 删除文件
+deleteAllInDir            : 删除目录下所有东西
+deleteFilesInDir          : 删除目录下所有文件
+deleteFilesInDirWithFilter: 删除目录下所有过滤的文件
+listFilesInDir            : 获取目录下所有文件
+listFilesInDirWithFilter  : 获取目录下所有过滤的文件
+getFileLastModified       : 获取文件最后修改的毫秒时间戳
+getFileCharsetSimple      : 简单获取文件编码格式
+getFileLines              : 获取文件行数
+getDirSize                : 获取目录大小
+getFileSize               : 获取文件大小
+getDirLength              : 获取目录长度
+getFileLength             : 获取文件长度
+getFileMD5                : 获取文件的MD5校验码
+getFileMD5ToString        : 获取文件的MD5校验码
+getDirName                : 根据全路径获取最长目录
+getFileName               : 根据全路径获取文件名
+getFileNameNoExtension    : 根据全路径获取文件名不带拓展名
+getFileExtension          : 根据全路径获取文件拓展名
 ```
 
 * ### Fragment相关→[FragmentUtils.java][fragment.java]→[Demo][fragment.demo]

README.md

@@ -206,13 +206,11 @@ moveDir
 moveFile
 deleteDir
 deleteFile
+deleteAllInDir
+deleteFilesInDir
+deleteFilesInDirWithFilter
 listFilesInDir
-listFilesInDir
-listFilesInDirWithFilter
-listFilesInDirWithFilter
-listFilesInDirWithFilter
 listFilesInDirWithFilter
-searchFileInDir
 getFileLastModified
 getFileCharsetSimple
 getFileLines

update_log.md

+* 17/08/10 优化FileUtils的deleteFilesInDir和listFilesInDir
 * 17/08/08 新增反射工具类ReflectUtils
 * 17/08/06 更改为按功能分包，增加subutil的Demo
 * 17/07/31 修复isAvailableByPing循环递归，发布1.8.1

utilcode/src/main/java/com/blankj/utilcode/util/FileUtils.java

@@ -4,16 +4,15 @@ import android.annotation.SuppressLint;
 
 import java.io.BufferedInputStream;
 import java.io.File;
+import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 /**
@@ -434,279 +433,206 @@ public final class FileUtils {
     }
 
     /**
-     * 删除目录下的所有文件
+     * 删除目录下所有东西
      *
      * @param dirPath 目录路径
      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static boolean deleteFilesInDir(final String dirPath) {
-        return deleteFilesInDir(getFileByPath(dirPath));
+    public static boolean deleteAllInDir(final String dirPath) {
+        return deleteAllInDir(getFileByPath(dirPath));
     }
 
     /**
-     * 删除目录下的所有文件
+     * 删除目录下所有东西
      *
      * @param dir 目录
      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static boolean deleteFilesInDir(final File dir) {
-        if (dir == null) return false;
-        // 目录不存在返回true
-        if (!dir.exists()) return true;
-        // 不是目录返回false
-        if (!dir.isDirectory()) return false;
-        // 现在文件存在且是文件夹
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            for (File file : files) {
-                if (file.isFile()) {
-                    if (!file.delete()) return false;
-                } else if (file.isDirectory()) {
-                    if (!deleteDir(file)) return false;
-                }
+    public static boolean deleteAllInDir(final File dir) {
+        return deleteFilesInDirWithFilter(dir, new FileFilter() {
+            @Override
+            public boolean accept(File pathname) {
+                return true;
             }
-        }
-        return true;
-    }
-
-    /**
-     * 获取目录下所有文件
-     *
-     * @param dirPath     目录路径
-     * @param isRecursive 是否递归进子目录
-     * @return 文件链表
-     */
-    public static List<File> listFilesInDir(final String dirPath, final boolean isRecursive) {
-        return listFilesInDir(getFileByPath(dirPath), isRecursive);
+        });
     }
 
     /**
-     * 获取目录下所有文件
-     *
-     * @param dir         目录
-     * @param isRecursive 是否递归进子目录
-     * @return 文件链表
-     */
-    public static List<File> listFilesInDir(final File dir, final boolean isRecursive) {
-        if (!isDir(dir)) return null;
-        if (isRecursive) return listFilesInDir(dir);
-        List<File> list = new ArrayList<>();
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            Collections.addAll(list, files);
-        }
-        return list;
-    }
-
-    /**
-     * 获取目录下所有文件包括子目录
+     * 删除目录下所有文件
      *
      * @param dirPath 目录路径
-     * @return 文件链表
+     * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static List<File> listFilesInDir(final String dirPath) {
-        return listFilesInDir(getFileByPath(dirPath));
+    public static boolean deleteFilesInDir(final String dirPath) {
+        return deleteFilesInDir(getFileByPath(dirPath));
     }
 
     /**
-     * 获取目录下所有文件包括子目录
+     * 删除目录下所有文件
      *
      * @param dir 目录
-     * @return 文件链表
+     * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static List<File> listFilesInDir(final File dir) {
-        if (!isDir(dir)) return null;
-        List<File> list = new ArrayList<>();
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            for (File file : files) {
-                list.add(file);
-                if (file.isDirectory()) {
-                    List<File> fileList = listFilesInDir(file);
-                    if (fileList != null) {
-                        list.addAll(fileList);
-                    }
-                }
+    public static boolean deleteFilesInDir(final File dir) {
+        return deleteFilesInDirWithFilter(dir, new FileFilter() {
+            @Override
+            public boolean accept(File pathname) {
+                return pathname.isFile();
             }
-        }
-        return list;
+        });
     }
 
     /**
-     * 获取目录下所有后缀名为suffix的文件
-     * <p>大小写忽略</p>
+     * 删除目录下所有过滤的文件
      *
-     * @param dirPath     目录路径
-     * @param suffix      后缀名
-     * @param isRecursive 是否递归进子目录
-     * @return 文件链表
+     * @param dirPath 目录路径
+     * @param filter  过滤器
+     * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static List<File> listFilesInDirWithFilter(final String dirPath, final String suffix, final boolean isRecursive) {
-        return listFilesInDirWithFilter(getFileByPath(dirPath), suffix, isRecursive);
+    public static boolean deleteFilesInDirWithFilter(final String dirPath, final FileFilter filter) {
+        return deleteFilesInDirWithFilter(getFileByPath(dirPath), filter);
     }
 
     /**
-     * 获取目录下所有后缀名为suffix的文件
-     * <p>大小写忽略</p>
+     * 删除目录下所有过滤的文件
      *
-     * @param dir         目录
-     * @param suffix      后缀名
-     * @param isRecursive 是否递归进子目录
-     * @return 文件链表
+     * @param dir    目录
+     * @param filter 过滤器
+     * @return {@code true}: 删除成功<br>{@code false}: 删除失败
      */
-    public static List<File> listFilesInDirWithFilter(final File dir, final String suffix, final boolean isRecursive) {
-        if (isRecursive) return listFilesInDirWithFilter(dir, suffix);
-        if (dir == null || !isDir(dir)) return null;
-        List<File> list = new ArrayList<>();
+    public static boolean deleteFilesInDirWithFilter(final File dir, final FileFilter filter) {
+        if (dir == null) return false;
+        // 目录不存在返回true
+        if (!dir.exists()) return true;
+        // 不是目录返回false
+        if (!dir.isDirectory()) return false;
+        // 现在文件存在且是文件夹
         File[] files = dir.listFiles();
         if (files != null && files.length != 0) {
             for (File file : files) {
-                if (file.getName().toUpperCase().endsWith(suffix.toUpperCase())) {
-                    list.add(file);
+                if (filter.accept(file)) {
+                    if (file.isFile()) {
+                        if (!file.delete()) return false;
+                    } else if (file.isDirectory()) {
+                        if (!deleteDir(file)) return false;
+                    }
                 }
             }
         }
-        return list;
+        return true;
     }
 
     /**
-     * 获取目录下所有后缀名为suffix的文件包括子目录
-     * <p>大小写忽略</p>
+     * 获取目录下所有文件
+     *  <p>不递归进子目录</p>
      *
      * @param dirPath 目录路径
-     * @param suffix  后缀名
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final String dirPath, final String suffix) {
-        return listFilesInDirWithFilter(getFileByPath(dirPath), suffix);
+    public static List<File> listFilesInDir(final String dirPath) {
+        return listFilesInDir(dirPath, false);
     }
 
     /**
-     * 获取目录下所有后缀名为suffix的文件包括子目录
-     * <p>大小写忽略</p>
+     * 获取目录下所有文件
+     *  <p>不递归进子目录</p>
      *
-     * @param dir    目录
-     * @param suffix 后缀名
+     * @param dir 目录
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final File dir, final String suffix) {
-        if (dir == null || !isDir(dir)) return null;
-        List<File> list = new ArrayList<>();
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            for (File file : files) {
-                if (file.getName().toUpperCase().endsWith(suffix.toUpperCase())) {
-                    list.add(file);
-                }
-                if (file.isDirectory()) {
-                    list.addAll(listFilesInDirWithFilter(file, suffix));
-                }
-            }
-        }
-        return list;
+    public static List<File> listFilesInDir(final File dir) {
+        return listFilesInDir(dir, false);
     }
 
     /**
-     * 获取目录下所有符合filter的文件
+     * 获取目录下所有文件
      *
      * @param dirPath     目录路径
-     * @param filter      过滤器
      * @param isRecursive 是否递归进子目录
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final String dirPath, final FilenameFilter filter, final boolean isRecursive) {
-        return listFilesInDirWithFilter(getFileByPath(dirPath), filter, isRecursive);
+    public static List<File> listFilesInDir(final String dirPath, final boolean isRecursive) {
+        return listFilesInDir(getFileByPath(dirPath), isRecursive);
     }
 
     /**
-     * 获取目录下所有符合filter的文件
+     * 获取目录下所有文件
      *
      * @param dir         目录
-     * @param filter      过滤器
      * @param isRecursive 是否递归进子目录
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final File dir, final FilenameFilter filter, final boolean isRecursive) {
-        if (isRecursive) return listFilesInDirWithFilter(dir, filter);
-        if (dir == null || !isDir(dir)) return null;
-        List<File> list = new ArrayList<>();
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            for (File file : files) {
-                if (filter.accept(file.getParentFile(), file.getName())) {
-                    list.add(file);
-                }
+    public static List<File> listFilesInDir(final File dir, final boolean isRecursive) {
+        return listFilesInDirWithFilter(dir, new FileFilter() {
+            @Override
+            public boolean accept(File pathname) {
+                return true;
             }
-        }
-        return list;
+        }, isRecursive);
     }
 
     /**
-     * 获取目录下所有符合filter的文件包括子目录
+     * 获取目录下所有过滤的文件
+     * <p>不递归进子目录</p>
      *
      * @param dirPath 目录路径
      * @param filter  过滤器
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final String dirPath, final FilenameFilter filter) {
-        return listFilesInDirWithFilter(getFileByPath(dirPath), filter);
+    public static List<File> listFilesInDirWithFilter(final String dirPath,
+                                                      final FileFilter filter) {
+        return listFilesInDirWithFilter(getFileByPath(dirPath), filter, false);
     }
 
     /**
-     * 获取目录下所有符合filter的文件包括子目录
+     * 获取目录下所有过滤的文件
+     * <p>不递归进子目录</p>
      *
      * @param dir    目录
      * @param filter 过滤器
      * @return 文件链表
      */
-    public static List<File> listFilesInDirWithFilter(final File dir, final FilenameFilter filter) {
-        if (dir == null || !isDir(dir)) return null;
-        List<File> list = new ArrayList<>();
-        File[] files = dir.listFiles();
-        if (files != null && files.length != 0) {
-            for (File file : files) {
-                if (filter.accept(file.getParentFile(), file.getName())) {
-                    list.add(file);
-                }
-                if (file.isDirectory()) {
-                    list.addAll(listFilesInDirWithFilter(file, filter));
-                }
-            }
-        }
-        return list;
+    public static List<File> listFilesInDirWithFilter(final File dir,
+                                                      final FileFilter filter) {
+        return listFilesInDirWithFilter(dir, filter, false);
     }
 
     /**
-     * 获取目录下指定文件名的文件包括子目录
-     * <p>大小写忽略</p>
+     * 获取目录下所有过滤的文件
      *
-     * @param dirPath  目录路径
-     * @param fileName 文件名
+     * @param dirPath     目录路径
+     * @param filter      过滤器
+     * @param isRecursive 是否递归进子目录
      * @return 文件链表
      */
-    public static List<File> searchFileInDir(final String dirPath, final String fileName) {
-        return searchFileInDir(getFileByPath(dirPath), fileName);
+    public static List<File> listFilesInDirWithFilter(final String dirPath,
+                                                      final FileFilter filter,
+                                                      final boolean isRecursive) {
+        return listFilesInDirWithFilter(getFileByPath(dirPath), filter, isRecursive);
     }
 
     /**
-     * 获取目录下指定文件名的文件包括子目录
-     * <p>大小写忽略</p>
+     * 获取目录下所有过滤的文件
      *
-     * @param dir      目录
-     * @param fileName 文件名
+     * @param dir         目录
+     * @param filter      过滤器
+     * @param isRecursive 是否递归进子目录
      * @return 文件链表
      */
-    public static List<File> searchFileInDir(final File dir, final String fileName) {
-        if (dir == null || !isDir(dir)) return null;
+    public static List<File> listFilesInDirWithFilter(final File dir,
+                                                      final FileFilter filter,
+                                                      final boolean isRecursive) {
+        if (!isDir(dir)) return null;
         List<File> list = new ArrayList<>();
         File[] files = dir.listFiles();
         if (files != null && files.length != 0) {
             for (File file : files) {
-                if (file.getName().toUpperCase().equals(fileName.toUpperCase())) {
+                if (filter.accept(file)) {
                     list.add(file);
                 }
-                if (file.isDirectory()) {
-                    list.addAll(searchFileInDir(file, fileName));
+                if (isRecursive && file.isDirectory()) {
+                    //noinspection ConstantConditions
+                    list.addAll(listFilesInDirWithFilter(file, filter, true));
                 }
             }
         }
@@ -719,6 +645,7 @@ public final class FileUtils {
      * @param filePath 文件路径
      * @return 文件最后修改的毫秒时间戳
      */
+
     public static long getFileLastModified(final String filePath) {
         return getFileLastModified(getFileByPath(filePath));
     }