批量操作文件功能-课后程序(JAVA基础案例教程-黑马程序员编著-第七章-课后作业)

【实验7-1】  批量操作文件功能

任务介绍

1．任务描述

在日常工作中，经常会遇到批量操作系统文件的事情，通常情况下，只能手动重复的完成批量文件的操作，这样很是费时费力。本案例要求编写一个文件管理器，实现文件的批量操作。文件管理器具体功能要求如下：

1. 用户输入指令1，代表“指定关键字检索文件”，此时需要用户输入检索的目录和关键字，系统在用户指定的目录下检索出文件名中包含关键字的文件，并将其绝对路径展示出来。
2. 用户输入指令2，代表“指定后缀名检索文件”，此时需要用户输入检索的目录和后缀名（多个后缀名用逗号分隔），系统在用户指定的目录下检索出指定后缀名的文件，并将其绝对路径展示出来。
3. 用户输入指令3，代表“删除文件/目录”，此时需要用户输入需要删除掉的文件目录，程序执行后会将目录以及目录下的内容全部删除。
4. 用户输入指令4，代表“退出”，即退出该文件管理器程序。

2．运行结果

任务运行结果如图7-1所示。

图7-1 运行结果

源路径G:\itcast下的文件，如图7-2所示。

图7-2源目录

 

实现思路

（1）根据任务介绍和运行结果分析可知，首先需要创建一个文件管理器类。可以在类中使用while循环实现控制台中操作指令的多次输入，并使用switch语句根据控制台输入的操作指令来判断执行什么操作。

（2）执行指令1时，代表指定关键字检索文件，即在目录下查找包含关键字的文件。执行时先要从控制台获取目录和关键字，然后将其传到后台的方法中，后台可将传入的关键字利用过滤器将其制定成“规则”，通过递归的方式遍历文件夹，在每个子文件夹下调用过滤器，来获取符合规则的文件路径的集合，并将集合返回，最后打印出来；

（3）执行指令2时，代表指定后缀名检索文件，即在目录下查找名称结尾是指定后缀的文件。执行时可以先从控制台获取目录和后缀名，然后将后缀名拆分成数组，并将数组和目录传到后台方法中。后台可用过滤器将后缀名数组循环遍历，制定成“规则”，通过递归的方式遍历文件夹，在每个子文件夹下调用过滤器，来获取符合规则的文件路径的集合，并将集合返回，最后并打印出来；

（4）执行指令3时，执行代表根据将输入的目录删除对应的文件夹。执行是先从控制台获取文件夹地址，后台先判断File对象是否存在，再使用foreach循环遍历删除文件夹下的所有文件，最后删除该文件夹；

（5）执行指令4时，执行退出该程序的操作，该操作可以通过System.exit(0)来实现。

实现代码

（1）定义DocumentManager类，具体如文件7-1所示。

文件7-1 DocumentManager.java

1. package chapter070;
2. import java.io.File;
3. import java.util.ArrayList;
4. import java.util.Scanner;
5. public class DocumentManager {
6.     public static void main(String[] args) throws Exception {
7.         Scanner sc = new Scanner(System.in);
8.         System.out.println("--1:指定关键字检索文件  2:指定后缀名检索文件  "
9.                 + "3:删除文件/目录  4:退出--");
10.         while(true){
11.             System.out.print("请输入指令：");
12.             int command = sc.nextInt();
13.             switch (command) {
14.                 case 1:
15.                     searchByKeyWorld();//指定关键字检索文件
16.                     break;
17.                 case 2:
18.                     searchBySuffix();//指定后缀名检索文件
19.                     break;
20.                 case 3:
21.                     deleteDir();//删除文件/目录
22.                     break;
23.                 case 4:
24.                     exit();//退出
25.                     break;
26.                 default:
27.                     System.out.println("您输入的指令错误！");
28.                     break;
29.             }
30.         }
31.     }
32.     // *********1.指定关键字检索文件*********
33.     private static void searchByKeyWorld() {
34.         Scanner sc = new Scanner(System.in);
35.         System.out.print("请输入要检索的目录位置：");
36.         String path = sc.next();//从控制台获取路径
37.         File file = new File(path);
38.         //判断目录是否存在，是否是目录
39.         if (!file.exists() || !file.isDirectory()) {
40.             System.out.println(path + " (不是有效目录)");
41.             return;
42.         }
43.         System.out.print("请输入搜索关键字：");
44.         String key = sc.next();//获取关键字
45.         //在输入目录下获取所有包含关键字的文件路径
46.         ArrayList<String> list = FileUtils.listFiles(file,key);
47.         for (Object obj : list) {
48.             System.out.println(obj);//将路径打印到控制台
49.         }
50.     }
51.     // *********2.指定后缀名检索文件********//
52.     private static void searchBySuffix() {
53.         Scanner sc = new Scanner(System.in);
54.         System.out.print("请输入要检索的目录位置：");
55.         String path = sc.next();//从控制台获取路径
56.         File file = new File(path);
57.         //判断目录是否存在，是否是文件夹
58.         if (!file.exists() || !file.isDirectory()) {
59.             System.out.println(path + " (不是有效目录)");
60.             return;
61.         }
62.         System.out.print("请输入搜索后缀：");
63.         String suffix = sc.next();
64.         String[] suffixArray = suffix.split(",");//获取后缀字符串
65.         //在输入目录下获取所有指定后缀名的文件路径
66.         ArrayList<String> list = FileUtils.listFiles(file, suffixArray);
67.         for (Object obj : list) {
68.             System.out.println(obj);//将路径打印到控制台
69.         }
70.     }
72.     // *********3.删除文件/目录**********//
73.     private  static void deleteDir() {
74.         Scanner sc = new Scanner(System.in);
75.         System.out.print("请输入需要删除的源目录：");
76.         String delpath = sc.next();// 从控制台获取源路径
77.         File dir = new File(delpath); // 创建一个代表目录的File对象
78.         doDelete(dir);
79.     }
80.     private  static void doDelete(File dir){
81.         if (dir.exists()) { // 判断传入的File对象是否存在
82.             File[] files = dir.listFiles(); // 得到File数组
83.             for (File file : files) { // 遍历所有的子目录和文件
84.                 if (file.isDirectory()) {
85.                     doDelete(file); // 如果是目录，递归调用deleteDir()
86.                 } else {
87.                     // 如果是文件，直接删除
88.                     file.delete();
89.                 }
90.             }
91.             // 删除完一个目录里的所有文件后，就删除这个目录
92.             dir.delete();
93.         }
94.     }
95.     // *********4.退出**********//
96.     private static void exit() {
97.         System.out.println("您已退出系统，谢谢使用！");
98.         System.exit(0);
99.     }

在文件7-26中，第10~30行代码，通过while循环等待指令输入，并通过switch来判断执行什么动作。第33~50行执行了根据指定的关键字检索文件的动作，其中第39行代码用来判断了输入的目录是否有效。第46行代码用于调用后台方法，获取符合规则的列表。第52~70行代码执行指定后缀名检索文件，其中第64行代码将获得的后缀名字符串拆分成数组，并利用第66行代码传入后台，获取符合规则的列表。第72~93行代码的作用是将控制台输入的目标文件删除，其中第79~93行代码定义doDelete()方法，在该方法中使用foreach循环删除子目录与文件。72~78行代码定义deleteDir()方法，在该方法中调用doDelete()方法删除目录与文件。

（2）定义FileUtils类，具体如文件7-2所示。

文件7-2  FileUtils.java

1. package chapter070;
2. import java.io.File;
3. import java.io.FilenameFilter;
4. import java.util.ArrayList;
5. public class FileUtils {
6.     /**
7.      * 指定关键字检索文件
8.      * @param file File对象
9.      * @param key  关键字
10.      * @return 包含关键字的文件路径
11.      */
12.     public static ArrayList<String> listFiles(File file, final String key){
13.         FilenameFilter filter = new FilenameFilter() { // 创建过滤器对象
14.             // 实现accept()方法
15.             public boolean accept(File dir, String name) {
16.                 File currFile = new File(dir, name);
17.                 // 如果文件名包含关键字返回true，否则返回false
18.                 if (currFile.isFile() && name.contains(key)) {
19.                     return true;
20.                 }
21.                 return false;
22.             }
23.         };
24.         //递归方式获取规定的路径
25.         ArrayList<String> arraylist = fileDir(file, filter);
26.         return arraylist;
27.     }
28.     /**
29.      * 指定后缀名检索文件
30.      * @param file File对象
31.      * @param suffixArray 后缀名数组
32.      * @return 指定后缀名的文件路径
33.      */
34.     public static ArrayList<String> listFiles(File file,
35.         final String[] suffixArray) {
36.         FilenameFilter filter = new FilenameFilter() { // 创建过滤器对象
37.             // 实现accept()方法
38.             public boolean accept(File dir, String name) {
39.                 File currFile = new File(dir, name);
40.                 if (currFile.isFile()) {
41.                     for (String suffix : suffixArray) {
42.                         if (name.endsWith("." + suffix)) {
43.                             return true;
44.                         }
45.                     }
46.                 }
47.                 return false;
48.             }
49.         };
50.         //递归方式获取规定的路径
51.         ArrayList<String> arraylist = fileDir(file, filter);
52.         return arraylist;
53.     }
54.     /**
55.      * 递归方式获取规定的路径
56.      * @param dir File对象
57.      * @param filter 过滤器
58.      * @return 过滤器过滤后的文件路径
59.      */
60.     public static ArrayList<String> fileDir(File dir, FilenameFilter filter){
61.         ArrayList<String> arraylist = new ArrayList<String>();
62.         File[] lists = dir.listFiles(filter); // 获得过滤后的所有文件数组
63.         for (File list : lists) {
64.             //将文件的绝对路径放到集合中
65.             arraylist.add(list.getAbsolutePath());
66.         }
67.         File[] files = dir.listFiles(); // 获得当前目录下所有文件的数组
68.         for (File file : files) { // 遍历所有的子目录和文件
69.             if (file.isDirectory()) {
70.                 // 如果是目录，递归调用fileDir()
71.                 ArrayList<String> every = fileDir(file, filter);
72.                 arraylist.addAll(every);//将文件夹下的文件路径添加到集合中
73.             }
74.         }//此时的集合中有当前目录下的文件路径，和当前目录的子目录下的文件路径
75.         return arraylist;
76.     }
77. }

在文件7-27中，执行指令1时调用第12~27行的代码，其中第13~23行代码用于创建过滤器，第25行代码用于调用递归方法。执行指令2时，将调用第34~53行代码，其中第36~49行代码用于创建过滤器，其中第41~45行代码通过循环，将所有后缀名都配成了过滤规则。第51行代码调用了递归方法，此方法的代码是60~76行，方法中第62~66行代码获取当前目录下经过过滤后的文件数组，通过循环取其路径存入集合中。第68~74行代码将当前目录下内容循环，如果是文件夹则调用自身。