利用正则表达式获取特定文件（如java class）并对其进行处理（如代码统计）

这是一个利用正则表达式获取特定文件（如java class）并对其进行处理（如代码统计）的程序。可以在特定的指定的文件目录下寻找指定的文件，在下面程序里主要是寻找java文件并进行数量统计和代码统计（代码行、空行、注释行）。至于删除那些class文件主要是因为我统计的是我下载的JDK的源码，里面的class文件不知道什么时候产生的，手动删除实在麻烦。在我的机器上的结果是：StatisticalJavaFiles:7070
                        CodeLine:894658
                        ComentLine:901352
                        WhiteLine :238595       

呵呵，Sun公司发布的Java源码有90万行，不算多。估计没公布的比公布的还多。而且统计出来的结果中注释的语句比代码行还多。这也充分说明了注释得重要性。

1. /*
2.  * StatisticalCodes.java 2008-10-15
3.  * This program was write for find out some kinds of 
4.  * file that we specify.
5.  */
6. import java.io.BufferedReader;
7. import java.io.File;
8. import java.io.FileNotFoundException;
9. import java.io.FileReader;
10. import java.io.IOException;
12. /**
13.  * @author Sancho_lai
14.  */
15. public class StatisticalCodes  {
16.     
17.     //codes line count
18.     private static long codeLines  = 0;
19.     //comment line count
20.     private static long commentLines = 0;
21.     //white line count
22.     private static long whiteLines   = 0;
23.     //number of java files was found
24.     private static long statisticalJavaFiles = 0; 
25.     
26.     //input a directory that you want,but it will cost a NullPointException when you input a 
27.     private static String path = "D://jdkSrc";
28.     
29.     public static void main(String[] args) {
30.         File file = new File(path);
31.         
32.         findSpecifiedDoc(file);
33.         
34.         System.out.println("StatisticalJavaFiles:" + statisticalJavaFiles);
35.         System.out.println("CodeLine:" + codeLines);
36.         System.out.println("ComentLine:" + commentLines);
37.         System.out.println("WhiteLine :" + whiteLines);
38.         
39.     }
40.     /**
41.      * find all the files that fit for the Regular Expression you specify
42.      * and then deal with it and count the lines and delete the class files
43.      * you can extend it you want to be
44.      */
45.     private static void findSpecifiedDoc(File file) {
46.         File[] fileArray = file.listFiles();
47.         for(File child:fileArray) {
48.             if(child.isDirectory()) { //when child was a directory recursively call  until get java file 
49.                 findSpecifiedDoc(child);
50.             }else if(child.getName().matches(".*//.java$")) { //when the  was a java file ,count the lines
51.                 parser(child);
52.                 statisticalJavaFiles++;
53.             }else if(child.getName().matches(".*//.class$")){ //when the  was a class file , delete it
54.                 deleteClassFile(child);
55.             }
56.         } 
57.     }
58.     /**
59.      * delete the class type file
60.      * @param child
61.      */
62.     private static void deleteClassFile(File child) {
63.         child.delete();
64.     }
65.     /**
66.      * parser the java file count the codeLines ...
67.      * using the regular expression for judging
68.      * @param child
69.      */
70.     private static void parser(File child) {
71.         BufferedReader br = null;
72.         boolean comment = false;
73.         String line = "";
74.         try {
75.             br = new BufferedReader(new FileReader(child));
76.             while((line = br.readLine()) != null) {
77.                 line = line.trim();
78.                 if(line.matches("^[//s&&[^//n]]*$")) { //
79.                     whiteLines ++;
80.                 } else if (line.startsWith("/*") && !line.endsWith("*/")) {//comment lines start with /* 
81.                     commentLines ++;
82.                     comment = true; 
83.                 } else if (line.startsWith("/*") && line.endsWith("*/")) {
84.                     commentLines ++;
85.                 } else if (true == comment) {
86.                     commentLines ++;
87.                     if(line.endsWith("*/")) {
88.                         comment = false;
89.                     }
90.                 } else if (line.startsWith("//")) {
91.                     commentLines ++;
92.                 } else { //it suppose that the java files just contain three kinds of lines
93.                     codeLines ++;
94.                 }
95.             }
96.         } catch (FileNotFoundException e) {
97.             e.printStackTrace();
98.         } catch (IOException e) {
99.             e.printStackTrace();
100.         } finally {
101.             if(br != null) {
102.             try {
103.                 br.close();
104.                 br = null;
105.             } catch (IOException e) {
106.                 e.printStackTrace();
107.             }
108.           }
109.         }
110.     }   
111. }