復習IO操作，突然想寫一個小工具，統計一下電腦里面的Java代碼量還有注釋率，最開始隨手寫了一個遞歸算法，遍歷文件夾，比較簡單，而且代碼層次清晰，相對易於理解，代碼如下：（完整代碼貼在最后面，前面是功能實現代碼）
-
public static void visitFile(File file) {
-
if (file !=
null) {
-
// 如果是文件夾
-
if (file.isDirectory()) {
-
// 統計文件夾下面的所有文件路徑
-
File[] fls = file.listFiles();
-
// 如果父文件夾有內容
-
if (fls !=
null) {
-
// 那么遍歷子文件
-
for (
int i =
0; i < fls.length; i++) {
-
// 繼續判斷文件是文件夾還是文件，嵌套循環
-
visitFile(fls[i]);
-
}
-
}
-
}
else
// 如果是文件
-
{
-
// 判斷文件名是不是.java類型
-
String fname = file.getName();
-
if (fname.endsWith(
".java")) {
-
Sysotem.out.println(
"java文件："+fname);
-
}
-
}
-
}
-
-
}
但是寫成小工具后，在使用中我發現了它遍歷速度還是比較慢的問題，遞歸算法本身運行效率低，占用空間也非常大，每一次調用都要出現方法壓棧彈棧，系統開銷大。所以我想把它改成非遞歸算法，我有兩個想法：1.打開父文件夾（父親）之后，遍歷子文件夾（兒子），如果是目錄就列出子文件夾的子文件夾（兒子的兒子），記錄下來，但是不繼續打開；如果遇到的是我需要的文件，那么就加入文件集合中，重復。代碼如下：
-
File fl =
this.file;
//根文件（父親）
-
ArrayList<File> flist =
new ArrayList<File>();
//文件夾目錄列表1
-
ArrayList<File> flist2 =
new ArrayList<File>();
//文件夾目錄列表2
-
ArrayList<File> tmp =
null, next =
null;
//集合應用變量，tmp記錄子文件夾的目錄列表（兒子），next記錄子文件夾的子文件夾列表（兒子的兒子）
-
flist.add(fl);
//列表1記錄根文件
-
// 廣度遍歷層數控制
-
int loop =
0;
//控制循環層數
-
while (loop++ <
3) {
// 此處只循環了三層
-
tmp = tmp == flist ? flist2 : flist;
//此處比較繞，實現功能是tmp和next兩個引用變量互換地址
-
next = next == flist2 ? flist : flist2;
-
for (
int i =
0; i < tmp.size(); i++) {
//遍歷子文件夾
-
fl = tmp.get(i);
-
if (fl !=
null) {
-
if (fl.isDirectory()) {
//如果遇到目錄
-
File[] fls = fl.listFiles();
-
if (fls !=
null) {
-
next.addAll(Arrays.asList(fls));
//將子文件夾的子文件夾目錄列表一次全部加入next列表
-
}
-
}
else {
-
if (fl.getName().endsWith(type)) {
-
papList.add(fl);
//如果是需要的文件，就加入papList列表
-
}
-
}
-
}
-
}
-
tmp.clear();
//清空子文件夾列表，因為已經遍歷子文件夾結束，后面需要一個空的列表繼續裝東西
-
}
2.第二種思路是打開父文件夾后，遍歷子文件夾，然后遇到目錄就繼續打開，直到沒有目錄才返回上一層，這個思路和遞歸遍歷算法一樣，看遞歸的算法更好理解，代碼如下：
-
// 非遞歸深度遍歷算法
-
void quickFind() throws IOException {
-
// 使用棧，進行深度遍歷
-
Stack<java.io.File> stk =
new Stack<File>();
-
stk.push(
this.file);
//父文件壓棧
-
File f;
-
while (!stk.empty()) {
//當棧不為空，就一直循環壓棧出棧過程。
-
f = stk.pop();
//彈出棧頂元素
-
if (f.isDirectory()) {
//如果棧頂是目錄
-
File[] fs = f.listFiles();
//打開棧頂子目錄
-
if (fs !=
null)
-
for (
int i =
0; i < fs.length; i++) {
-
stk.push(fs[i]);
//將棧頂子目錄依次壓棧
-
}
-
}
else {
-
if (f.getName().endsWith(type)) {
-
// 記錄所需文件的信息，加入集合
-
papList.add(f);
-
}
-
}
-
}
-
}
上面的兩種非遞歸算法，速度上相差無幾，相對於遞歸算法比較難於理解，但是速度真的快一點，而且占用內存比較小，如果使用遞歸，當遞歸層數比較多的時候對系統資源消耗巨大，甚至會造成jvm崩潰，非遞歸算法沒有這個隱患，深度遍歷和廣度遍歷在遍歷很多文件時，深度遍歷稍微占優勢，速度會快一點，但是數據有浮動。后面我又復習到多線程，我就想把多線程加進去，會不會更快。然后我就建立了一個線程池：
-
// 創建線程池，一共THREAD_COUNT個線程可以使用
-
ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
//新建固定線程數的線程池
-
-
for (File file : next) {
-
pool.submit(
new FileThread(file, type));
//提交對象到線程池,FileThread類是我自定義的內部類，重寫了Runnable接口中的run方法。
-
}
-
pool.shutdown();
//結束
-
// 必須等到所有線程結束才可以讓主線程退出，不然就一直阻塞
-
while (!pool.isTerminated())
-
;
線程池的好處是統一管理線程，不用一直開辟新的線程，開辟線程很消耗系統資源，線程池里面的線程可以循環使用，程序結束了再釋放，適用於頻繁切換任務的情況，在Tcp/ip網絡編程中常見。加入多線程我也有兩種想法，1.我先想到多線程就是幾個兄弟一起干活，速度肯定快，所以我每遍歷一個文件夾就開辟一個新的線程，代碼如下：
-
void judge(File f) {
-
-
if (f !=
null) {
-
if (f.isDirectory()) {
-
// 如果是目錄
-
File[] fs = f.listFiles();
-
if (fs !=
null)
-
FileOP.BigFileList.addAll(Arrays.asList(fs));
-
// 一起加到BigFileList中，前面有一個for循環遍歷BigFileList，遍歷一次開辟一個新線程
-
}
else {
-
if (f.getName().endsWith(type)) {
-
FileOP.papList.add(f);
-
// 我們要的文件記錄下來
-
}
-
}
-
}
-
}
所以我又想，怎么才能發揮多線程的優勢呢，首先肯定要把一個任務分成多個任務，這也有兩個思路：1.先用遞歸深度遍歷算法遍歷文件夾，當遇到比較大的文件夾，比如說包含1000個子文件夾就記錄下來，然后跳過繼續遍歷其他的文件夾，此時主線程有一個while循環一直在檢查有沒有新的大文件夾出現，如果有就開一個新線程去遍歷大文件夾，代碼如下：
-
void findAll(File f) {
-
if (f !=
null) {
-
-
if (f.isDirectory()) {
-
// 如果是目錄
-
File[] fs = f.listFiles();
-
if (fs ==
null) {
-
return;
-
}
-
-
*
if (fs.length > FileOP.THREAD_COUNT *
100) {
//
-
* 當文件夾的目錄數量大於線程數的百倍，記錄下來，待會用多線程慢慢數 FileOP.BigFileList.add(f);
-
*
// 這記錄的都是后面要用多線程來數一數的 } else
-
{
-
for (
int i =
0; i < fs.length; i++) {
-
findAll(fs[i]);
-
// 如果文件數少，就遞歸一下
-
}
-
}
-
}
else {
-
// 需要的文件放進pap集合
-
if (f.getName().endsWith(type)) {
-
FileOP.papList.add(f);
-
}
-
}
-
}
-
}
-
package com.ycs;
-
-
import java.io.File;
-
import java.io.FileInputStream;
-
import java.io.IOException;
-
import java.io.InputStream;
-
import java.math.BigDecimal;
-
import java.util.ArrayList;
-
import java.util.Arrays;
-
import java.util.Stack;
-
import java.util.concurrent.ExecutorService;
-
import java.util.concurrent.Executors;
-
-
public
class FileList {
-
// 控制線程數，最優選擇是處理器線程數*3，本機處理器是4線程
-
private
final
static
int THREAD_COUNT =
12;
-
// 線程共享數據，保存所有的type文件
-
private ArrayList<File> papList =
new ArrayList<File>();
-
// 保存文件附加信息
-
private ArrayList<String> contenList =
new ArrayList<String>();
-
// 當前文件或者目錄
-
private File file;
-
-
// 所需的文件類型
-
private String type;
-
-
public FileList() {
-
super();
-
// TODO Auto-generated constructor stub
-
}
-
-
public FileList(String f, String type) {
-
super();
-
this.file =
new File(f);
-
this.type = type;
-
}
-
-
public ArrayList<String> getContenList() {
-
return contenList;
-
}
-
-
// 內部類繼承runnable接口，實現多線程
-
class FileThread implements Runnable {
-
private File file;
-
private String type;
-
-
public FileThread(File file, String type) {
-
super();
-
this.file = file;
-
this.type = type;
-
}
-
-
public FileThread() {
-
super();
-
// TODO Auto-generated cosnstructor stub
-
}
-
-
@Override
-
public void run() {
-
try {
-
quickFind();
-
}
catch (IOException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
-
}
-
-
// 非遞歸深度遍歷算法
-
void quickFind() throws IOException {
-
// 使用棧，進行深度遍歷
-
Stack<java.io.File> stk =
new Stack<File>();
-
stk.push(
this.file);
-
File f;
-
while (!stk.empty()) {
-
f = stk.pop();
-
if (f.isDirectory()) {
-
File[] fs = f.listFiles();
-
if (fs !=
null)
-
for (
int i =
0; i < fs.length; i++) {
-
stk.push(fs[i]);
-
}
-
}
else {
-
if (f.getName().endsWith(type)) {
-
// 記錄所需文件的信息
-
papList.add(f);
-
}
-
}
-
}
-
}
-
}
-
-
public ArrayList<File> getPapList() {
-
// 外部接口，傳遞遍歷結果
-
return papList;
-
}
-
-
// 深度遍歷算法加調用線程池
-
void File() {
-
File fl =
this.file;
-
ArrayList<File> flist =
new ArrayList<File>();
-
ArrayList<File> flist2 =
new ArrayList<File>();
-
ArrayList<File> tmp =
null, next =
null;
-
flist.add(fl);
-
// 廣度遍歷層數控制
-
int loop =
0;
-
while (loop++ <
3) {
// 最優循環層數是3層，多次實驗得出
-
tmp = tmp == flist ? flist2 : flist;
-
next = next == flist2 ? flist : flist2;
-
for (
int i =
0; i < tmp.size(); i++) {
-
fl = tmp.get(i);
-
if (fl !=
null) {
-
if (fl.isDirectory()) {
-
File[] fls = fl.listFiles();
-
if (fls !=
null) {
-
next.addAll(Arrays.asList(fls));
-
}
-
}
else {
-
if (fl.getName().endsWith(type)) {
-
papList.add(fl);
-
}
-
}
-
}
-
}
-
tmp.clear();
-
}
-
-
// 創建線程池，一共THREAD_COUNT個線程可以使用
-
ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
-
-
for (File file : next) {
-
pool.submit(
new FileThread(file, type));
-
}
-
pool.shutdown();
-
// 必須等到所有線程結束才可以讓主線程退出，不然就一直阻塞
-
while (!pool.isTerminated())
-
;
-
}
-
-
void info(File file) throws IOException {
-
InputStream inputStream =
new FileInputStream(file);
-
byte[] chs =
new
byte[(
int) file.length()];
-
inputStream.read(chs);
-
inputStream.close();
-
String javaCode =
new String(chs);
-
String[] lines = javaCode.split(
"\n");
-
int find = lines.length;
// 實際代碼行數
-
int counts = find;
// 加上注釋的行數
-
int zhushi =
0;
-
for (
int i =
0; i < lines.length; i++) {
-
lines[i] = lines[i].trim();
-
if (lines[i].length() ==
0) {
-
counts--;
-
find--;
-
}
else
if (lines[i].startsWith(
"//")) {
-
// System.out.println("單行注釋："+lines[i]);
-
find--;
-
zhushi++;
-
}
else
if (lines[i].indexOf(
"/*") != -
1) {
-
find--;
-
zhushi++;
-
while (lines[i].indexOf(
"*/") == -
1) {
-
// System.out.println(lines[i]);
-
find--;
-
zhushi++;
-
i++;
-
}
-
}
-
}
-
-
double zc = ((
double) zhushi / counts) *
100;
-
BigDecimal b =
new BigDecimal(zc);
-
double zcc = b.setScale(
2, BigDecimal.ROUND_HALF_UP).doubleValue();
-
String s = file.getName() +
"代碼行數:" + find +
"\t注釋行數：" + zhushi +
"\t 注釋率：" + zcc +
"%";
-
-
contenList.add(s);
-
}
-
}
最后貼上程序運行圖：
嗯，貼不了。。。
完整代碼就是上面那個，創建一個對象，給構造函數傳入文件路徑（String）和文件類型(String)就可以了。
小白之作，輕噴輕噴
原文地址：https://blog.csdn.net/qq_24833939/article/details/79222444