Apache Commons IO入门教程(转)

2020年05月16日 阅读数:137
这篇文章主要向大家介绍Apache Commons IO入门教程(转),主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

 

Apache Commons IO是Apache基金会建立并维护的Java函数库。它提供了许多类使得开发者的常见任务变得简单,同时减小重复(boiler-plate)代码,这些代码可能遍及于每一个独立的项目中,你却不得不重复的编写。这些类由经验丰富的开发者维护,对各类问题的边界条件考虑周到,并持续修复相关bug。html

在下面的例子中,咱们会向你演示一些不一样功能的方法,这些功能都是在org.apache.commons.io包下。Apache Commons IO 是一个巨大工程,咱们不会深刻去剖析它的底层原理,可是会演示一些比较经常使用的例子,无论你是否是新手,相信这些例子都会对你有所帮助。java

1. Apache Commons IO 示例

咱们分别会用几段代码来演示下面的功能,每部分功能都表明Apache Commons IO所覆盖的一个单独领域,具体以下:web

  • 工具类
  • 输入
  • 输出
  • 过滤器
  • 比较器
  • 文件监控器
 

为了更方便读者进行理解,咱们会把建立的每一个类的输出进行单独展现。而且会把示例中功能演示所用到的到文件放到工程目录(ExampleFolder目录)中。apache

注意:为了能使用org.apache.commons.io中的功能,你首先须要下载jar包(请点击这里),而且将jar包添加到Eclipse工程的编译路径下,右键点工程文件夹 ->  Build Path -> Add external archives。windows

ApacheCommonsExampleMain.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ApacheCommonsExampleMain {
 
     public static void main(String[] args) {
         UtilityExample.runExample();
 
         FileMonitorExample.runExample();
 
         FiltersExample.runExample();
 
         InputExample.runExample();
 
         OutputExample.runExample();
 
         ComparatorExample.runExample();
     }
}
 
 

这个main方法会运行全部的示例,你能够将其余行的代码注释来执行你想要的示例。api

1.1 Utility Classes

 
org.apache.commons.io包中有不少工具类,里面多数类都是完成文件操做以及字符串比较的功能,下面列举了一下经常使用的工具类:  FilenameUtils 这个工具类是用来处理文件名(译者注:包含文件路径)的,他能够轻松解决不一样操做系统文件名称规范不一样的问题(好比windows和Unix)(在Unix系统以及Linux系统中文件分隔符是“/”,不支持”\“,windows中支持”\“以及”/“)。

 

  FileUtils提供文件操做(移动文件,读取文件,检查文件是否存在等等)的方法。   IOCase提供字符串操做以及比较的方法。
  FileSystemUtils:提供查看指定目录剩余空间的方法。
 
UtilityExample.java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.io.File;
import java.io.IOException;
 
import org.apache.commons.io.FileSystemUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.LineIterator;
import org.apache.commons.io.IOCase;
 
public final class UtilityExample {
 
     // We are using the file exampleTxt.txt in the folder ExampleFolder,
     // and we need to provide the full path to the Utility classes.
     private static final String EXAMPLE_TXT_PATH =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFolderexampleTxt.txt" ;
 
     private static final String PARENT_DIR =
             "C:UsersLilykosworkspaceApacheCommonsExample" ;
 
     public static void runExample() throws IOException {
         System.out.println( "Utility Classes example..." );
 
         // FilenameUtils
 
         System.out.println( "Full path of exampleTxt: " +
                 FilenameUtils.getFullPath(EXAMPLE_TXT_PATH));
 
         System.out.println( "Full name of exampleTxt: " +
                 FilenameUtils.getName(EXAMPLE_TXT_PATH));
 
         System.out.println( "Extension of exampleTxt: " +
                 FilenameUtils.getExtension(EXAMPLE_TXT_PATH));
 
         System.out.println( "Base name of exampleTxt: " +
                 FilenameUtils.getBaseName(EXAMPLE_TXT_PATH));
 
         // FileUtils
 
         // We can create a new File object using FileUtils.getFile(String)
         // and then use this object to get information from the file.
         File exampleFile = FileUtils.getFile(EXAMPLE_TXT_PATH);
         LineIterator iter = FileUtils.lineIterator(exampleFile);
 
         System.out.println( "Contents of exampleTxt..." );
         while (iter.hasNext()) {
             System.out.println( "t" + iter.next());
         }
         iter.close();
 
         // We can check if a file exists somewhere inside a certain directory.
         File parent = FileUtils.getFile(PARENT_DIR);
         System.out.println( "Parent directory contains exampleTxt file: " +
                 FileUtils.directoryContains(parent, exampleFile));
 
         // IOCase
 
         String str1 = "This is a new String." ;
         String str2 = "This is another new String, yes!" ;
 
         System.out.println( "Ends with string (case sensitive): " +
                 IOCase.SENSITIVE.checkEndsWith(str1, "string." ));
         System.out.println( "Ends with string (case insensitive): " +
                 IOCase.INSENSITIVE.checkEndsWith(str1, "string." ));
 
         System.out.println( "String equality: " +
                 IOCase.SENSITIVE.checkEquals(str1, str2));
 
         // FileSystemUtils
         System.out.println( "Free disk space (in KB): " + FileSystemUtils.freeSpaceKb( "C:" ));
         System.out.println( "Free disk space (in MB): " + FileSystemUtils.freeSpaceKb( "C:" ) / 1024 );
     }
}
输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Utility Classes example...
Full path of exampleTxt: C:UsersLilykosworkspaceApacheCommonsExampleExampleFolder
Full name of exampleTxt: exampleTxt.txt
Extension of exampleTxt: txt
Base name of exampleTxt: exampleTxt
Contents of exampleTxt...
     This is an example text file.
     We will use it for experimenting with Apache Commons IO.
Parent directory contains exampleTxt file: true
Ends with string ( case sensitive): false
Ends with string ( case insensitive): true
String equality: false
Free disk space (in KB): 32149292
Free disk space (in MB): 31395

1.2 文件监控器

org.apache.commons.io.monitor包下的类包含的方法能够获取文件的指定信息,不过更重要的是,它能够建立处理器(handler)来跟踪指定文件或目录的变化而且能够在文件或目录发生变化的时候进行一些操做。让咱们来看看下面的代码:app

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import java.io.File;
import java.io.IOException;
 
import org.apache.commons.io.FileDeleteStrategy;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;
import org.apache.commons.io.monitor.FileEntry;
 
public final class FileMonitorExample {
 
     private static final String EXAMPLE_PATH =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFolderexampleFileEntry.txt" ;
 
     private static final String PARENT_DIR =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFolder" ;
 
     private static final String NEW_DIR =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFoldernewDir" ;
 
     private static final String NEW_FILE =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFoldernewFile.txt" ;
 
     public static void runExample() {
         System.out.println( "File Monitor example..." );
 
         // FileEntry
 
         // We can monitor changes and get information about files
         // using the methods of this class.
         FileEntry entry = new FileEntry(FileUtils.getFile(EXAMPLE_PATH));
 
         System.out.println( "File monitored: " + entry.getFile());
         System.out.println( "File name: " + entry.getName());
         System.out.println( "Is the file a directory?: " + entry.isDirectory());
 
         // File Monitoring
 
         // Create a new observer for the folder and add a listener
         // that will handle the events in a specific directory and take action.
         File parentDir = FileUtils.getFile(PARENT_DIR);
 
         FileAlterationObserver observer = new FileAlterationObserver(parentDir);
         observer.addListener( new FileAlterationListenerAdaptor() {
 
                 @Override
                 public void onFileCreate(File file) {
                     System.out.println( "File created: " + file.getName());
                 }
 
                 @Override
                 public void onFileDelete(File file) {
                     System.out.println( "File deleted: " + file.getName());
                 }
 
                 @Override
                 public void onDirectoryCreate(File dir) {
                     System.out.println( "Directory created: " + dir.getName());
                 }
 
                 @Override
                 public void onDirectoryDelete(File dir) {
                     System.out.println( "Directory deleted: " + dir.getName());
                 }
         });
 
         // Add a monior that will check for events every x ms,
         // and attach all the different observers that we want.
         FileAlterationMonitor monitor = new FileAlterationMonitor( 500 , observer);
         try {
             monitor.start();
 
             // After we attached the monitor, we can create some files and directories
             // and see what happens!
             File newDir = new File(NEW_DIR);
             File newFile = new File(NEW_FILE);
 
             newDir.mkdirs();
             newFile.createNewFile();
 
             Thread.sleep( 1000 );
 
             FileDeleteStrategy.NORMAL. delete (newDir);
             FileDeleteStrategy.NORMAL. delete (newFile);
 
             Thread.sleep( 1000 );
 
             monitor.stop();
         } catch (IOException e) {
             e.printStackTrace();
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
}
输出
1
2
3
4
5
6
7
8
File Monitor example...
File monitored: C:UsersLilykosworkspaceApacheCommonsExampleExampleFolderexampleFileEntry.txt
File name: exampleFileEntry.txt
Is the file a directory?: false
Directory created: newDir
File created: newFile.txt
Directory deleted: newDir
File deleted: newFile.tx
让咱们来看看这里发生了什么,咱们使用org.apache.commons.io.monitor包下的类建立了一个处理器来监听一些特定的事件(在上面的例子中就是咱们对文件或目录所作的全部操做事件),为了得到这些信息,咱们须要作如下几步操做:
一、建立一个File对象,这个对象指向咱们须要监听变化的目录。
二、建立一个FileAlterationObserver对象,这个对象会观察这些变化。
三、经过调用addListener()方法,为observer对象添加一个 FileAlterationListenerAdaptor对象。你能够经过不少种方式来建立一个适配器,在咱们的例子中咱们使用内部类的方式进行建立而且只实现其中的一部分方法(只须要实现咱们例子中须要用的方法便可)。

四、建立一个FileAlterationMonitor 对象,将已经建立好的observer对象添加其中而且传入时间间隔参数(单位是毫秒)。less

五、调用start()方法便可开启监视器,若是你想中止监视器,调用stop()方法便可。

1.3 过滤器

过滤器能够以组合的方式使用而且它的用途很是多样。它能够轻松的区分不一样的文件而且找到知足咱们条件的文件。咱们能够组合不一样的过滤器来执行文件的逻辑比较而且精确的获取咱们所须要文件,而无需使用冗余的字符串比较来寻找咱们的文件。eclipse

FiltersExample.javaide

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.io.File;
 
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.AndFileFilter;
import org.apache.commons.io.filefilter.NameFileFilter;
import org.apache.commons.io.filefilter.NotFileFilter;
import org.apache.commons.io.filefilter.OrFileFilter;
import org.apache.commons.io.filefilter.PrefixFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
 
public final class FiltersExample {
 
     private static final String PARENT_DIR =
             "C:UsersLilykosworkspaceApacheCommonsExampleExampleFolder" ;
 
     public static void runExample() {
         System.out.println( "File Filter example..." );
 
         // NameFileFilter
         // Right now, in the parent directory we have 3 files:
         //      directory example
         //      file exampleEntry.txt
         //      file exampleTxt.txt
 
         // Get all the files in the specified directory
         // that are named "example".
         File dir = FileUtils.getFile(PARENT_DIR);
         String[] acceptedNames = { "example" , "exampleTxt.txt" };
         for (String file: dir.list( new NameFileFilter(acceptedNames, IOCase.INSENSITIVE))) {
             System.out.println( "File found, named: " + file);
         }
 
         //WildcardFileFilter
         // We can use wildcards in order to get less specific results
         //      ? used for 1 missing char
         //      * used for multiple missing chars
         for (String file: dir.list( new WildcardFileFilter( "*ample*" ))) {
             System.out.println( "Wildcard file found, named: " + file);
         }
 
         // PrefixFileFilter
         // We can also use the equivalent of startsWith
         // for filtering files.
         for (String file: dir.list( new PrefixFileFilter( "example" ))) {
             System.out.println( "Prefix file found, named: " + file);