Java实现文件目录列表的自定义排序

用Java列出某个文件目录的文件列表是很容易实现的，只用调用File类中的list()方法即可。

String[]

list()            返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

但是此时文件的列表是按照字符串默认的排序方式进行排序的

[html]  view plain copy

1. package cn.uestc.fz;  
2.   
3. import java.io.File;  
4.   
5. public class Filelists {  
6.     public static void main(String[] args) {  
7.         File file = new File("E:\\MyDoc"); //目录路径  
8.         if(file.isDirectory()){ //判断file是否为目录  
9.             String[] fileNames = file.list();  
10.             for(int i=0;i<fileNames.length;i++){  
11.                 System.out.println(fileNames[i]);  
12.             }  
13.         }  
14.     }  
15.       
16. }  

运行结果：

[html]  view plain copy

1. 1.1.txt  
2. 1.2.txt  
3. 1.3.txt  
4. 1.4.txt  
5. 10.txt  
6. 11.txt  
7. 12.1.txt  
8. 2.1.txt  
9. 2.2.txt  
10. 3.txt  
11. 4.txt  
12. 5.txt  
13. 6.txt  
14. 7.txt  
15. 8.txt  
16. 9.txt  

显然，10号的文件排在了2号的前面，这并不是按整数的顺序排的，是按照字符的顺序排的。

那么我们怎么实现文件名按照整数序号来排序呢，首先我想到了java中的Comparable接口，用某个类继承String类再实现Comparable接口，但是list()方法返回的是String类型的数组，而String的定义是

public final class String

extends  Object implements  Serializable ,  Comparable < String >,  CharSequence

也就是说它不能被继承。

 

此时查文档发现了另外一个并不常用的接口，Comparator，它可以在不改变某个类代码的情况下，给它定义排序的规则。

[html]  view plain copy

1. package cn.uestc.fz;  
2.   
3. import java.io.File;  
4. import java.util.Arrays;  
5. import java.util.Comparator;  
6.   
7. public class Filelists1 {  
8.     public static void main(String[] args) {  
9.         File file = new File("E:\\MyDoc"); //目录路径  
10.         if(file.isDirectory()){ //判断file是否为目录  
11.             String[] fileNames = file.list();  
12.             Arrays.sort(fileNames,new StringComparator());  
13.             for(int i=0;i<fileNames.length;i++){  
14.                 System.out.println(fileNames[i]);  
15.         }  
16.         }  
17.     }  
18. }  
19.       
20. //此类实现Comparable接口  
21. class StringComparator implements Comparator<String>{  
22.     @Override  
23.     public int compare(String s1, String s2) {  
24.         if(StringComparator.returnDouble(s1)<StringComparator.returnDouble(s2))  
25.             return -1;  
26.         else if(StringComparator.returnDouble(s1)>StringComparator.returnDouble(s2))  
27.             return 1;  
28.         else  
29.             return 0;  
30.           
31.     }  
32.       
33.     public static double returnDouble(String str){  
34.         StringBuffer sb = new StringBuffer();  
35.         for(int i=0;i<str.length();i++){  
36.             if(Character.isDigit(str.charAt(i)))  
37.                 sb.append(str.charAt(i));  
38.             else if(str.charAt(i)=='.'&&i<str.length()-1&&Character.isDigit(str.charAt(i+1)))  
39.                 sb.append(str.charAt(i));  
40.             else break;  
41.         }  
42.         if(sb.toString().isEmpty())  
43.             return 0;  
44.         else  
45.             return Double.parseDouble(sb.toString());  
46.     }  
47.   
48.       

由类StringComparator实现Comparator接口就可以改变String类型的默认排序方式，其中compare是需要复写的方法，类似于Comparable接口中的compareTo方法。

returnDouble是写的一个静态方法，用来返回某个文件名字符串前面的数字编号，如"1.1.txt"返回的就是"1.1"，写的时候老是出现越界异常，后来终于改成功了，可能写得有点复杂了。

 

这样再调用Arrays类中的sort(T[] a, Comparator<? super T> c) 方法就可以对文件名排序了。

最后的结果符合我们的预期:

[html]  view plain copy

1. 1.1.txt  
2. 1.2.txt  
3. 1.3.txt  
4. 1.4.txt  
5. 2.1.txt  
6. 2.2.txt  
7. 3.txt  
8. 4.txt  
9. 5.txt  
10. 6.txt  
11. 7.txt  
12. 8.txt  
13. 9.txt  
14. 10.txt  
15. 11.txt  
16. 12.1.txt