java编程笔记13 过滤文件

  

    1 
   package
    FileOperation;

    2 
   

    3 
   
   import
    java.io.File;

    4 
   
   import
    java.io.FileFilter;

    5 
   
   import
    java.util.ArrayList;

    6 
   
   import
    java.util.List;

    7 
   

    8 
   
   /*
   本程序在指定的文件夹以及其子文件夹里递归的寻找包含关键字的文件

    9 
    * 1,使用FileFilter接口来过滤文件，实现FileFilter里的boolean accept(File pathname)

    10 
    * 作为过滤规则

    11 
    * 2,使用了匿名内部类，在过滤时常用匿名内部类来产生一个包含boolean accept过滤规则类的对象，

    12 
    * 这样显得简洁一些，当然你也可以分成两个类来写，写一个类FileFiltertest来实现接口FileFilter

    13 
    * 中的boolean accept方法，然后在另一个过滤的时候这样来写：

    14 
    * File[] subFolders = folder.listFiles(new FileFiltertest);

    15 
    * 3,也另一个接口FilenameFilter也可以作为过滤的接口，方法和上面的一样

    16 
    * 4，注意递归文件夹的方法
   */
   

    17 
   

    18 
   
   public
    
   class
    SearchFile {

    19 
   

    20 
    
   static
    
   int
    countFiles 
   =
    
   0
   ,countFolders 
   =
    
   0
   ;

    21 
    

    22 
    
   public
    
   static
    
   void
    main(String[] args) {

    23 
    

    24 
    
   //
   默认的folder和keyword
   

    25 
   
    File folder 
   =
    
   new
    File(
   "
   C:\\windows
   "
   );

    26 
    String keyword 
   =
    
   "
   setup
   "
   ;

    27 
    

    28 
    
   //
   也可以参数传入指定的folder和keyword
   

    29 
   
    
   if
   (args 
   !=
    
   null
    
   &&
    args.length 
   ==
    
   2
   )

    30 
    {

    31 
    folder 
   =
    
   new
    File(args[
   0
   ]);

    32 
    keyword 
   =
    args[
   1
   ];

    33 
    }

    34 
    

    35 
    
   if
   (
   !
   folder.exists())

    36 
    {

    37 
    System.out.println(
   "
   文件(夹)不存在： 
   "
    
   +
    folder.getAbsolutePath());

    38 
    
   return
   ;

    39 
    }

    40 
    

    41 
    
   //
   调用searchFile方法返回File[]类型的result数组
   

    42 
   
    File[] result 
   =
    searchFile(folder,keyword);

    43 
    

    44 
    System.out.println(
   "
   在 
   "
    
   +
    folder 
   +
    
   "
    以及所有子文件里查找 
   "
    
   +
    keyword);

    45 
    

    46 
    System.out.println(
   "
   查找了 
   "
    
   +
    countFiles 
   +
    
   "
    个文件， 
   "
    
   +
    

    47 
    countFolders 
   +
    
   "
    个文件夹，共找到
   "
    
   +
    result.length 
   +
    
   "
    个符合条件的文件：
   "
    );

    48 
    

    49 
    
   for
   (
   int
    i 
   =
    
   0
   ;i 
   <
    result.length;i 
   ++
   )

    50 
    {

    51 
    File file 
   =
    result[i];

    52 
    System.out.println(
   "
    
   "
    
   +
    file.getAbsolutePath());

    53 
    }

    54 
    

    55 
    }

    56 
    

    57 
    
   //
   searchFile方法，
   

    58 
   
    
   public
    
   static
    File[] searchFile(File folder,
   final
    String keyword)

    59 
    {

    60 
    
   //
   用匿名内部类讲过滤和过滤的类的实现放在一起了
   

    61 
   
    File[] subFolders 
   =
    folder.listFiles(
   new
    FileFilter()

    62 
    

    63 
    
   //
   匿名内部内开始（在产生一个对象的时候定义这个类）
   

    64 
   
    {

    65 
    
   public
    
   boolean
    accept(File pathname)

    66 
    {

    67 
    
   if
   (pathname.isFile()) countFiles 
   ++
   ;

    68 
    
   else
    countFolders 
   ++
   ;

    69 
    

    70 
    
   /*
   这个过滤规则是将文件夹或者含关键字的文件放入File[] subFolders里。

    71 
    * 可见subFolders里既有满足条件的文件，也有一些文件夹(需要进一步递归去找)
   */
   

    72 
    
   if
   (pathname.isDirectory()
   ||
   (pathname.isFile() 
   &&
    

    73 
    pathname.getName().contains(keyword)))

    74 
    {

    75 
    
   return
    
   true
   ;

    76 
    }

    77 
    
   return
    
   false
   ;

    78 
    }

    79 
    }

    80 
    
   //
   匿名内部类结束
   

    81 
   
    );
   //
   过滤结束，得到了一个File[] subFolders，subFolders在上面已经解释过
   

    82 
   
    

    83 
    List resultList 
   =
    
   new
    ArrayList();
   //
   用一个resultList来存放最终的结果（满足条件的文件，即进一步递归的结果）
   

    84 
   
    

    85 
    
   for
   (
   int
    i 
   =
    
   0
   ;i 
   <
    subFolders.length;i 
   ++
   )

    86 
    {

    87 
    
   //
   如果是subFolders[i]是文件，直接放入结果集中
   

    88 
   
    
   if
   (subFolders[i].isFile())

    89 
    {

    90 
    resultList.add(subFolders[i]);

    91 
    }

    92 
    
   //
   如果subFolders[i]是文件夹，则在subFolders[i]下递归调用本方法。
   

    93 
   
    
   else
   {

    94 
    File[] subFolderResult 
   =
    searchFile(subFolders[i],keyword);

    95 
    
   for
   (
   int
    j 
   =
    
   0
   ;j 
   <
    subFolderResult.length;j 
   ++
   )

    96 
    {

    97 
    resultList.add(subFolderResult[j]);

    98 
    }

    99 
    }

   100 
    }

   101 
    

   102 
    File[] result 
   =
    
   new
    File[resultList.size()];

   103 
    resultList.toArray(result);
   //
   将list类型转化为数组类型放在result中
   

   104 
   
    

   105 
    
   return
    result;
   //
   放回这个数组
   

   106 
   
    }

   107 
   

   108 
   }