统计指定目录下Java源代码的总行数

遍历指定文件夹并统计代码行数，和Java关键字频率，降序输出所有结果。

默认统计.java文件，可以自定义统计其他源码。

打算将它整合到自己做的桌面小程序中。

部分输出如下：

代码总行数：11341
E:\java\以往习作\KingTetris.java--->行数：419
F:\EclipseProject\Test\src\king\countcode\CountCodeLine.java--->行数：340
F:\EclipseProject\记事本\src\king\notepad\view\NotepadFrame.java--->行数：332
F:\EclipseProject\五子棋\src\guyuanguanli.java--->行数：298
F:\EclipseProject\记事本\src\king\notepad\service\TextService.java--->行数：277
F:\EclipseProject\简易绘图板\src\King\Test.java--->行数：267

---------Java代码关键字统计：----------
关键字：new           出现次数：873
关键字：int           出现次数：668
关键字：public        出现次数：608
关键字：private       出现次数：520
关键字：null          出现次数：511
关键字：void          出现次数：413
关键字：static        出现次数：299
关键字：return        出现次数：293
关键字：if            出现次数：282
关键字：this          出现次数：232
关键字：class         出现次数：201
关键字：for           出现次数：161
关键字：true          出现次数：146
关键字：else          出现次数：92
关键字：final         出现次数：88
关键字：false         出现次数：79
关键字：case          出现次数：78
关键字：catch         出现次数：68
关键字：while         出现次数：67
关键字：try           出现次数：63
关键字：boolean       出现次数：60
关键字：extends       出现次数：56
关键字：implements    出现次数：55
关键字：throws        出现次数：45
关键字：break         出现次数：41
关键字：char          出现次数：40
关键字：super         出现次数：34
关键字：byte          出现次数：32
关键字：switch        出现次数：22
关键字：double        出现次数：17
关键字：abstract      出现次数：16
关键字：do            出现次数：15
关键字：protected     出现次数：13
关键字：synchronized  出现次数：9
关键字：long          出现次数：9
关键字：finally       出现次数：8
关键字：throw         出现次数：8
关键字：instanceof    出现次数：7
关键字：default       出现次数：6
关键字：float         出现次数：2
关键字：continue      出现次数：2
关键字：package       出现次数：2
关键字：transient     出现次数：2
关键字：import        出现次数：2
关键字：interface     出现次数：2
关键字：native        出现次数：2
关键字：volatile      出现次数：2
关键字：short         出现次数：2
关键字：strictfp      出现次数：1
关键字：enum          出现次数：1
关键字：const         出现次数：1
关键字：goto          出现次数：1
关键字：assert        出现次数：1

源码：

package king.countcode;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 统计指定目录下Java文件的总行数、关键字频率
 *
 */
public class CountCodeLine {
    private int count = 0;
    // 所有需要遍历的文件
    private List<File> allFile = new LinkedList<File>();
    // 所有遍历结果
    private Map<String, Integer> allResult = new HashMap<String, Integer>();
    // 排序后的所有遍历结果
    private List<Map.Entry<String, Integer>> allSortedResult = new LinkedList<Map.Entry<String, Integer>>();
    // 需要检查的文件后缀，默认添加.java
    private List<String> allSuffix = new LinkedList<String>();  
    private static final String JAVA_SUFFIX = ".java"; 
    
    //提取单词的正则表达式
    private Pattern p = Pattern.compile("(?<=\\W)\\w+(?=\\W)"); 
    
    //用于计数
    private Keywords countKeyword = new Keywords(); 
    
    public CountCodeLine(){
        addSuffix(JAVA_SUFFIX);
    }
    
    public static void main(String[] args) {
        CountCodeLine count = new CountCodeLine();
        
        // 添加需要检查的文件或文件夹
        count.addPath("E:\\java");
        count.addPath("F:\\EclipseProject");
        
//        // 遍历C盘之外所有硬盘
//        // 由于文件太多，全部遍历需要很久才能出结果，一般不建议
//        File[] roots = File.listRoots();
//        for(int i = 0; i < roots.length; i++){
//            // C盘某些文件夹无权限进入，会报错，故剔除
//            if (!roots[i].getAbsolutePath().toLowerCase().startsWith("c:")){
//                count.addPath(roots[i].getAbsolutePath());
//            }
//        }
        
        // 检查并返回统计 总行数
        System.out.println("代码总行数：" + count.execute());
        
        // 输出降序排列的总结果
        for(Map.Entry<String, Integer> entry : count.getAllSortedResult()){
            System.out.println(entry.getKey() + "--->行数：" + entry.getValue());
        }
        
        //输出所有Java文件中的关键字频率统计
        // 如果想统计单个文件，请在上方addPath()仅输入单个文件的绝对地址
        System.out.println();
        System.out.println("---------Java代码关键字统计：----------");
        System.out.println(count.getUsedKeywordFrequency());
        
    }
  
    
    /*
     * 添加需要检查的文件或文件夹
     */
    public void addPath(String path){
        allFile.add(new File(path));
    }
    
    /*
     * 添加需要检查的后缀名
     * 如果要用来统计其他后缀名的文件，请先clear()
     */
    public void addSuffix(String suffix){
        suffix = suffix.toLowerCase(); //全转小写
        if (!suffix.startsWith(".")) suffix = "." + suffix;
        allSuffix.add(suffix);
    }
    
    /*
     * 开始遍历
     */
    public int execute(){
        for(File file : allFile){
            checkFile(file);
        }
        // 排序所有结果
        sortAllResult(); 
        return getCount();
    }
    
    /*
     * 获取当前count值
     */
    public int getCount(){
        return count;
    }
    
    /*
     * 返回详细的结果
     * 文件名-代码行数映射的Set<Map.Entry<String, Integer>>
     */
    public Set<Map.Entry<String, Integer>> getAllResult(){
        return allResult.entrySet();
    }
    
    /**
     * 返回所有排序后的结果
     */
    public List<Map.Entry<String, Integer>> getAllSortedResult(){
        return new LinkedList<Map.Entry<String, Integer>>(allSortedResult);
    }
    
    /**
     * 返回关键字频率的统计结果
     * @return
     */
    public String getUsedKeywordFrequency(){
        return countKeyword.getUsedKeywordFrequency();
    }
    /*
     * 清空所有内容，以便开始全新的查找
     */
    public void clear(){
        count = 0;
        allFile.clear();
        allResult.clear();
        allSortedResult.clear();
        allSuffix.clear();        
    }
    
    /*
     * 遍历文件夹
     */
    private void checkFile(File file){
        if (file.isDirectory()){
            File[] files = file.listFiles();
            for(File f : files){
                checkFile(f);
            }
        } else if (checkSuffix(file)){
            countLine(file);
        }
//        // 下面是循环方法，当递归溢出时，可改用循环
//        Stack<File> stack = new Stack<File>();
//        stack.push(file);
//        while(!stack.isEmpty()){
//            File tmp = stack.pop();           
//            if (tmp.isDirectory()){
//                File[] files = tmp.listFiles();
//                for (File f : files){
//                    stack.push(f);
//                }
//            } else if (checkSuffix(tmp)){
//                countLine(tmp);
//            }
//        }
    }
    
    
    /**
     * 检查后缀名
     */
    private boolean checkSuffix(File file){
        String fileName = file.getName().toLowerCase();
        for(String suffix : allSuffix){
            if (fileName.endsWith(suffix)) return true;
        }
        return false;
    }

    /*
     * 统计Java文件的行数
     */
    private void countLine(File file){
        try (BufferedReader input = new BufferedReader(new FileReader(file))){
            String str = null;
            int tmpCount = 0;
            while ((str = input.readLine()) != null){
                // 检查这一行里的每一个单词
                Matcher m = p.matcher(str);
                while(m.find()){
                    // 判断是否Java关键字
                    countKeyword.checkWord(m.group());
                }
                tmpCount++;
            }
            count += tmpCount;
            allResult.put(file.getAbsolutePath(), tmpCount); //保存到集合中
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 排序所有统计结果
     * 降序
     */
    private void sortAllResult(){
        allSortedResult.addAll(allResult.entrySet());
        Collections.sort(allSortedResult, new Comparator<Map.Entry<String, Integer>>(){
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2){
                int value1 = o1.getValue();
                int value2 = o2.getValue();
                if (value1 == value2) return 0;
                return value1 > value2 ? -1 : 1;
            }
        });
    }
}

//关键字集合，用于计数
class Keywords {
    // 所有关键字
    private Map<String, Integer> keywords = new HashMap<String, Integer>();   
    
    
    //构造器
    public Keywords(){
        reset();
    }
    
    //复位清零
    public void reset(){
        for(Keyword k : Keyword.values()){ //从枚举类获取关键字
            keywords.put(k.getKeyword(), 0);
        }
    }
    
    //检测一个单词是否关键字，如果是，就让对应的关键字频数加1
    public void checkWord(String word){
        if (keywords.keySet().contains(word)){
            keywords.put(word, keywords.get(word) + 1);
        }
    }
    
    //返回统计结果
    public String getUsedKeywordFrequency(){
        StringBuilder result = new StringBuilder();
        StringBuilder tmp = new StringBuilder();
        //按频数即value值排序
        //就算用TreeMap也只能对key排序，下面用自己写的比较器排序
        //继承Comparator接口改改名compare方法后，TreeSet会认为compare结果为0的两个元素是同一个元素，故不用TreeSet
        List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(keywords.entrySet());
        Collections.sort(list, new MyMapEntryComparator());
        for(Map.Entry<String, Integer> entry : list){
            if (entry.getValue() != 0){
                tmp.setLength(0);
                tmp.append("关键字：").append(entry.getKey()).append("出现次数：").append(entry.getValue());
                result.append(typeset(tmp)).append("\n");
            }
        }
        return result.toString();
    }
    
    /**
     * 将字符串排版再返回，如下输出不整齐
     * 关键字：null    出现次数：1
     * 关键字：implements  出现次数：1
     * 控制“关键字”和“出现次数”之间的空格，
     * 将来可能改变输出的汉字，故下面用正则式考虑更广泛的情况
     * @param StringBuilder
     * @return String
     */
    private String typeset(StringBuilder sb){
        StringBuilder result = new StringBuilder();
        int blank = 15; //不同组汉字之间的空白
        int index = 0, length = 0, differ;
        //找出右边不是紧邻汉字的汉字，向后数十五个空
        Pattern p = Pattern.compile("(?<![一-龥])[一-龥]+(?![一-龥])");
        Matcher m = p.matcher(sb);  
        while(m.find()){ //find()后移一位
            result.append(sb.substring(index, m.start()));
            if((differ = blank -(m.start() - index - length)) > 0 && m.start() != 0){
                while(differ-- > 0){
                    result.append(" ");
                }
            }           
            index = m.start();
            length = m.group().length();
        }
        //如果后面中文，则把剩下的全接上去
        result.append(sb.substring(index));
        return result.toString();
    }
    
    //比较用的Comparator，只在这时用到，故写成内部类
    private class MyMapEntryComparator implements Comparator<Map.Entry<String, Integer>>{
        @Override
        public int compare(Map.Entry<String, Integer> m1, Map.Entry<String, Integer> m2){
            return -(m1.getValue() - m2.getValue());
        }
    } 

}

//所有关键字，枚举类，仅用于存储
enum Keyword{
 ABSTRACT("abstract"), ASSERT("assert"), BOOLEAN("boolean"), BREAK("break")
     , BYTE("byte"), CASE("case"), CATCH("catch"), CHAR("char"), CLASS("class")
     , CONST("const"), CONTINUE("continue"), DEFAULT("default"), DO("do"), DOUBLE("double")
     , ELSE("else"), ENUM("enum"), EXTENDS("extends"), FALSE("false"), FINAL("final")
     , FINALLY("finally"), FLOAT("float"), FOR("for"), GOTO("goto"), IF("if")
     , IMPLEMENTS("implements"), IMPORT("import"), INSTANCEOF("instanceof"), INT("int")
     , INTERFACE("interface"), LONG("long"), NATIVE("native"), NEW("new"), NULL("null")
     , PACKAGE("package"), PRIVATE("private"), PROTECTED("protected"), PUBLIC("public")
     , RETURN("return"), SHORT("short"), STATIC("static"), STRICTFP("strictfp")
     , SUPER("super"), SWITCH("switch"), SYNCHRONIZED("synchronized"), THIS("this")
     , THROW("throw"), THROWS("throws"), TRANSIENT("transient"), TRY("try"), TRUE("true")
     , VOID("void"), VOLATILE("volatile"), WHILE("while");
 
 private String keyword;

 //构造器
 private Keyword(String keyword){
     this.keyword = keyword;
 }
 
 //获取keyword
 public String getKeyword() {
     return keyword;
 }

}