import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Test {
   
static int allNum;//统计行数的 变量
public static void main(String[] args) throws IOException {
  
  int countt = getFilesLineCount(new File("F:/workspace1/com.itcast"));
  System.out.println("总行数：" + countt);
  
  
  
}

/**
  * 统计一个文件夹下所有文件（.java)的总行数（包含子孙文件夹）
  *
  * @param dir
  * @return
  */
public static int getFilesLineCount(File dir) {
  
  
  if(dir.isFile())//判断是否是文件
  {
   allNum = allNum+getLineCount(dir);
  }
  else
  {
   for( File file:dir.listFiles())//遍历此目录的所有子目录
   {
    if (file.isFile())
    {   
     String s = file.getName();
     if( s.endsWith(".java"))
     {
      allNum += getLineCount(file);
     }
    }
    else
    {
     getFilesLineCount(file);//递归调用
    }
   }
  }
  return allNum;
}

/**
  * 统计指定文件的行数
  * @param file
  * @return
  * @throws IOException
  */
public static int getLineCount(File file)  {
  
  BufferedReader br = null;
        int num = 0;  
  String s = null;
  
  try {
   br=new BufferedReader(new FileReader(file));
   while( (s = br.readLine())!=null)
   {
    num++;
   }
   br.close();
  } catch (Exception e) {
   e.printStackTrace();
   
  }
  return num;
}
}
/*
* 上面用了递归的调用
* 但我觉得递归虽好，但是会产生内存溢出的问题：但递归的调用很多次的时候，总有很多数据停留在内存里
* 达到一定程度就会出现内存溢出
* 那请问，如果不用递归，如何实现我程序中的功能呢？
* */

可以考虑用队列来解决这个问题，把每一次需要递归的统计的文件夹，当成一个任务，然后把这个任务存进LinkedList中，通过先进先出的方式，来达到递归的目的。
下面我用列队实现了一下

package cn.itcast.h_linecount;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;

public class LineCounter2 {

        public static void main(String[] args) {
                // 初始时向任务队列中添加一个任务
                // File dir = new File("E:/Test");
                File dir = new File("C:/my_project");
                taskQueue.add(dir);

                // 执行队表中的所有任务
                executeDirFilesLineCountTasks();

                // 显示最终结果
                System.out.println("总行数：" + count);
        }

        // 任务队列
        private static LinkedList<File> taskQueue = new LinkedList<File>();

        // 统计结果
        private static int count = 0;

        /**
         * 执行任务：统计一个文件夹下所有文件的总行数，并且把所有的子文件夹作为新任务添加到任务队列中
         *
         */
        public static void executeDirFilesLineCountTasks() {
                // 循环办理任务队表所有的的任务
                while (taskQueue.size() > 0) {
                        // 1，从任务队列中取出一个任务
                        File dir = taskQueue.removeFirst();

                        // 2，办理这个任务
                        // >> a, 取出这个文件夹中所有子文件与子文件夹
                        for (File file : dir.listFiles()) {
                                // >> b, 如果是文件，就统计
                                if (file.isFile()) {
                                        if (file.getName().endsWith(".java")) {
                                                count += getFileLineCount(file);
                                        }
                                }
                                // >> c, 如果是文件夹，就作为一个新任务添加到任务队列中
                                else {
                                        taskQueue.addLast(file);
                                }
                        }
                }
        }

        /**
         * 统计指定文件的行数
         *
         * @param file
         * @return
         */
        public static int getFileLineCount(File file) {
                BufferedReader reader = null;
                try {
                        // 打开文件
                        reader = new BufferedReader(new FileReader(file));

                        // 读一行就加1，直到读完全部行
                        int count = 0;
                        while (reader.readLine() != null) {
                                count++;
                        }

                        // 返回结果
                        return count;

                } catch (Exception e) {
                        throw new RuntimeException(e);
                } finally {
                        if (reader != null) {
                                try {
                                        reader.close();
                                } catch (IOException e) {
                                        throw new RuntimeException(e);
                                }
                        }
                }
        }
}
希望可以帮到你

我用的是设置标志位的办法。有文件夹设为0，while循环

1. package javaEnhance;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.File;
   
5. 
   
6. import java.io.FileReader;
   
7. import java.io.IOException;
   
8. import java.util.ArrayList;
   
9. import java.util.List;
   
10. 
    
11. public class Test {
    
12. static List arr =new ArrayList();
    
13. static int allNum;//统计行数的 变量
    
14. public static void main(String[] args) throws IOException {
    
15. add("E:\\新建文件夹");
    
16. int countt = getFilesLineCount(arr);
    
17. System.out.println("总行数：" + countt);
    
18. }
    
19. public static void add(String name){
    
20. arr.add(name);
    
21. }
    
22. 
    
23. /**
    
24. * 统计一个文件夹下所有文件（.java)的总行数（包含子孙文件夹）
    
25. *
    
26. * @param dir
    
27. * @return
    
28. */
    
29. //传递的是一个集合
    
30. public static int getFilesLineCount(List a) {
    
31. int flag = 0; //设置标志位
    
32. while(flag==0){
    
33. for(int i = 0;i<a.size();i++){
    
34. flag = 1;//标志位变为1;
    
35. System.out.println((String)a.get(i));
    
36. File dir = new File((String)a.get(i));
    
37. if(dir.isFile())//判断是否是文件
    
38. {
    
39. allNum = allNum+getLineCount(dir);
    
40. }
    
41. else
    
42. {
    
43. for( File file:dir.listFiles())//遍历此目录的所有子目录
    
44. {
    
45. if(file.isDirectory()){
    
46. flag = 0;//当有文件夹时候变0，当所有的都是文件时将会跳出循环
    
47. arr.add( file.getAbsolutePath());//把文件路径传递给dir
    
48. }
    
49. if (file.isFile())
    
50. {
    
51. String s = file.getName();
    
52. if( s.endsWith(".java"))
    
53. {
    
54. allNum += getLineCount(file);
    
55. }
    
56. }
    
57. }
    
58. }
    
59. }
    
60. }
    
61. return allNum;
    
62. }
    
63. 
    
64. /**
    
65. * 统计指定文件的行数
    
66. * @param file
    
67. * @return
    
68. * @throws IOException
    
69. */
    
70. public static int getLineCount(File file) {
    
71. 
    
72. BufferedReader br = null;
    
73. int num = 0;
    
74. String s = null;
    
75. 
    
76. try {
    
77. br=new BufferedReader(new FileReader(file));
    
78. while( (s = br.readLine())!=null)
    
79. {
    
80. num++;
    
81. }
    
82. br.close();
    
83. } catch (Exception e) {
    
84. e.printStackTrace();
    
85. }
    
86. return num;
    
87. }
    
88. }
    
89. 
    

复制代码