• scau Java综合性实验之Java源程序分析程序

    1. 编写一个Java应用程序，实现对某个目录中的所有Java源程序文件（包含该目录的子目录中的源程序文件）进行统计。统计内容包括：

    (1) 目录中每个源程序文件的总行数和空白行数，文件的字节数；

    (2) 目录中所有源程序文件合计总行数、合计空白行数、合计文件的字节数。

    2. 具体实现要求如下：

    (1) 程序运行首先显示如下所示的菜单：

    (2) 选择菜单中第1项时，要求输入一个目录名

    如果输入目录名称对应的目录不存在或不是目录，则输出：

    [目录名称] 不是合法的目录名称！

    例如：

    如果是合法存在的目录，则对该目录中的Java源程序文件进行分析，分析内容包括：

    细节部分：每个源程序文件的行数、其中空行数、字节数。

    合计部分：源程序文件个数、源程序文件行数、其中空行数、总的字节数。

    注意，分析时包括输入目录中的所有子目录。

    分析的结果的保存要求：

    在当前项目目录中建立一个名为result的目录，结果文件存放在该目录中。

    结果文件是一个文本文件，命名方式是用被分析的目录名作为主文件名，扩展名为目录名。

    例如：分析D:demo目录，结果文件名为“demo.txt”。

    结果文件中数据存放格式如下示例：

    其中，

    第1行：被分析目录的完整名称

    第2行：空行

    第3行：Files detail:

    第4行：被分析目录的短名称，前面有一个 + 号

    第5行：从本行开始依次输出被分析目录中的子目录和源程序文件

    如果是子目录，则该行是 + 号 和 子目录的短名称

    如果是源程序文件，则该行以 - 号开始，依次是：文件名、总行数、空白行数、字节数

    注意：一个目录中如果既有子目录也有源程序文件，则先依次排列子目录，再依次排列文件。并且要按照名称升序排序。同时，每深入一层子目录，要缩进4个空格。

    第X行：Total:

    第X+1行：目录中总文件个数

    第X+2行：目录中总的行数

    第X+3行：目录中总的空白行数

    第X+4行：目录中总字节数

    (3) 选择菜单中第2项时，

    如果result目录中还没有结果文件，则显示：还没有分析结果!

    如果result目录中已经有结果文件，则以下面格式显示文件列表：

    可以查看的结果文件有：

    输入文件编号后，显示输出结果文件的内容，如果输入0表示不查看任何结果。编号输入错误应该提示。

    这两天写综合性实验写的颇有感触……

    emm…代码中有详细的注释，本人也比较菜，没用啥高深的算法，应该一看就会…

    要是有啥不懂的可以私信问我呐

    Menu类

    1. package Project;
    2.  
    3. import java.io.*;
    4. import java.util.Scanner;
    5.  
    6. public class Menu {
    7.     private final Scanner Sc = new Scanner(System.in);
    8.  
    9.     //菜单
    10.     public void showMenu() {
    11.         System.out.println("----------MENU----------");
    12.         System.out.println("1.分析目录中的源程序文件");
    13.         System.out.println("2.查看分析结果");
    14.         System.out.println("0.退出程序");
    15.         System.out.println("------------------------");
    16.         System.out.print("请选择:");
    17.         chooseMenu();
    18.     }
    19.  
    20.     //选择菜单的选项
    21.     public void chooseMenu() {
    22.         int choice;
    23.         choice = Sc.nextInt();
    24.         switch (choice) {
    25.             case 1 -> {
    26.                 analyseFiles();
    27.                 break;
    28.             }
    29.             case 2 -> {
    30.                 checkResult();
    31.                 break;
    32.             }
    33.             case 0 -> {
    34.                 System.out.println("您已成功退出程序！");
    35.                 System.exit(0);
    36.             }
    37.             default -> System.out.println("您输入的选项有误！");
    38.         }
    39.     }
    40.  
    41.     //分析目录中的源程序文件
    42.     private void analyseFiles() {
    43.         System.out.println();
    44.         System.out.print("请输入目录名称:");
    45.         String FileName = Sc.next();
    46.         Directory.root = new File(FileName);
    47.         Directory.PathName = String.valueOf(new File(FileName));
    48.         if (!Directory.root.isDirectory()) {
    49.             System.out.println("错误：[" + Directory.root + "]不是目录名或不存在！\n");
    50.         } else {
    51.             Directory.outPut();
    52.             System.out.println("分析成功！");
    53.         }
    54.  
    55.     }
    56.  
    57.     private void checkResult() {
    58.         System.out.println();
    59.         File file = new File("Result");
    60.         File[] files = file.listFiles();
    61.         if (files == null) {
    62.             System.out.println("还没有分析结果！");
    63.         } else {
    64.             System.out.println("--------------------------------");
    65.             for (int i = 0; i < files.length; i++) {
    66.                 System.out.println(i + 1 + "." + files[i].getName());
    67.             }
    68.             System.out.println("--------------------------------");
    69.             System.out.println("请选择要查看的结果文件(0表示放弃)：");
    70.             int choice = Sc.nextInt();
    71.             if (choice == 0) {
    72.                 return;
    73.             }
    74.             if (choice > files.length) {
    75.                 System.out.print("您输入的选项有误！请重新输入:");
    76.                 checkResult();
    77.             }
    78.             System.out.println("查询结果如下：");
    79.             checkFile(files[choice - 1]);//选项是比文件类数组大1的
    80.             System.out.println();
    81.         }
    82.     }
    83.  
    84.     private void checkFile(File file) {
    85.         BufferedReader br = null;
    86.         try {
    87.             br = new BufferedReader(new FileReader(file));
    88.             while (true) {
    89.                 String data = br.readLine();
    90.                 if (data == null) {
    91.                     break;
    92.                 }
    93.                 System.out.println(data);
    94.             }
    95.         } catch (IOException e) {
    96.             e.printStackTrace();
    97.         } finally {
    98.             {
    99.                 if (br != null) {
    100.                     try {
    101.                         br.close();
    102.                     } catch (IOException e) {
    103.                         e.printStackTrace();
    104.                     }
    105.                 }
    106.             }
    107.         }
    108.     }
    109. }

    SourceFile类

    1. package Project;
    2.  
    3. import java.io.*;
    4.  
    5. public class SourceFile {
    6.     private File file;
    7.     private long cntOfLines;//单个源码文件的行数
    8.     private long cntOfBlank;//单个源码文件的空行数
    9.     private long bytes;//单个源码文件的字节数
    10.  
    11.     public SourceFile(File file) {
    12.         this.file = file;
    13.     }
    14.  
    15.     //统计行数
    16.     public long getCntOfLines() {
    17.         //只有第一次调用才进行分析统计，节约时间
    18.         if (cntOfLines == 0) {
    19.             getCntOfLinesAndBlank();
    20.         }
    21.         return cntOfLines;
    22.     }
    23.  
    24.     //统计空行数
    25.     public long getCntOfBlank() {
    26.         //同上
    27.         if (cntOfBlank == 0) {
    28.             getCntOfLinesAndBlank();
    29.         }
    30.         return cntOfBlank;
    31.     }
    32.  
    33.     //统计字节数
    34.     public long getBytes() {
    35.         bytes = file.length();
    36.         return bytes;
    37.     }
    38.  
    39.     //统计行数和空行数
    40.     public void getCntOfLinesAndBlank() {
    41.         BufferedReader br = null;
    42.         try {
    43.             br = new BufferedReader(new FileReader(file));
    44.             while (true) {
    45.                 String line = br.readLine();
    46.                 if (line == null) {
    47.                     break;
    48.                 }
    49.                 cntOfLines++;//每读一行，行数加一
    50.                 if ("".equals(line)) {
    51.                     cntOfBlank++;//读到空行，空行数加一
    52.                 }
    53.             }
    54.         } catch (IOException e) {
    55.             e.printStackTrace();
    56.         } finally {//关闭文件
    57.             if (br != null) {
    58.                 try {
    59.                     br.close();
    60.                 } catch (IOException e) {
    61.                     e.printStackTrace();
    62.                 }
    63.             }
    64.         }
    65.     }
    66. }

    Directory类

    1. package Project;
    2.  
    3. import java.io.BufferedWriter;
    4. import java.io.File;
    5. import java.io.FileWriter;
    6. import java.io.IOException;
    7. import java.util.ArrayList;
    8. import java.util.Arrays;
    9. import java.util.Comparator;
    10.  
    11. public class Directory {
    12.     static File root;//待分析的文件或文件夹
    13.     static String PathName;//存放root路径
    14.     /*static String dataPathName = "Result";//存储分析结果文件夹的路径
    15.     static String testDataPath = "testData";//存放文件或文件夹的文件夹路径
    16.     static File dataDir = new File(dataPathName);//存储分析结果文件夹的文件类
    17.     static File testDir = new File(testDataPath);//存放测试文件或文件夹的文件夹的文件类*/
    18.     static int level = 0;//用于记录递归的层数
    19.  
    20.     private static long AllOfLines;
    21.     private static long AllOfBlank;
    22.     private static long AllOfBytes;
    23.  
    24.     private static class GloBal {
    25.         public static ArrayList fileArrayList = new ArrayList<>();//存放待分析的.java文件
    26.         public static ArrayList outputData = new ArrayList<>();//存放分析结果的String
    27.     }
    28.  
    29.     /*
    30.         private static void saveFileList() {
    31.             if (root.isDirectory()) {
    32.                 File[] files = root.listFiles();
    33.                 int len = files.length;
    34.                 for (int i = 0; i < len; i++) {
    35.                     if (files[i].isDirectory()) {
    36.                         root = files[i];
    37.                         saveFileList();
    38.                     } else {
    39.                         if (files[i].getName().endsWith(".java")) {//如果以.java结尾
    40.                             GloBal.fileArrayList.add(files[i]);//放入ArrayList中
    41.                         }
    42.                     }
    43.                 }
    44.             }else if(root.isFile() && root.getName().endsWith(".java")){
    45.                 GloBal.fileArrayList.add(root);//放入ArrayList中
    46.             }
    47.         }
    48.     */
    49.     //开头格式
    50.     private static void firstShow() {
    51.         GloBal.outputData.add("[" + root.getAbsolutePath() + "]" + "  Result:");
    52.         GloBal.outputData.add("");
    53.         GloBal.outputData.add("Files detail:");
    54.     }
    55.  
    56.     private static void saveFileList() {
    57.         if (root.isDirectory()) {
    58.             StringBuilder tapOfDirectory = getTap();
    59.             GloBal.outputData.add(tapOfDirectory + "+" + root.getName());//目录
    60.  
    61.             File[] files = root.listFiles();//把root名下所有文件存进File[] files中
    62.             int len = files.length;//root下文件或文件夹的个数
    63.             //flag判断递归层数是否相同
    64.             int flag = 0;
    65.             for (int i = 0; i < len; i++) {//循环
    66.                 if (files[i].isDirectory()) {//如果是一个目录
    67.                     root = files[i];//更新root路径
    68.                     //递归层数相同时level只需要加一次
    69.                     if (flag == 0) {
    70.                         level++;
    71.                         flag = 1;
    72.                     }
    73.                     saveFileList();//递归 以存储.java文件
    74.                 } else {//如果不是一个目录（即是一个文件）
    75.                     if (files[i].getName().endsWith(".java")) {//如果以.java结尾
    76.                         //感觉好像没必要放进ArrayList
    77.                         //好吧好像有用，可以统计.java文件个数
    78.                         GloBal.fileArrayList.add(files[i]);//放入ArrayList中
    79.  
    80.                         SourceFile SF = new SourceFile(files[i]);//使用SourceFile类进行统计
    81.  
    82.                         //处理文件名 方面后面对齐
    83.                         StringBuilder newName = tidyFileName(files[i]);
    84.                         //处理Total,方便Blank对齐
    85.                         StringBuilder newTotal = tidyLines(files[i]);
    86.                         //处理Blank，方便bytes对齐
    87.                         StringBuilder newBlank = tidyBlank(files[i]);
    88.                         //字符数
    89.                         long bytes = SF.getBytes();
    90.  
    91.                         StringBuilder tapOfFiles = getTap();
    92.                         GloBal.outputData.add(tapOfFiles
    93.                                 + "    -" + newName
    94.                                 + "\tTotal: " + newTotal
    95.                                 + "Blank: " + newBlank
    96.                                 + bytes + " bytes");
    97.  
    98.                         /*GloBal.outputData.add("    -" + files[i].getName()
    99.                                 +"\t\tTotal: " + SF.getCntOfLines()
    100.                                 + ",  Blank: " + SF.getCntOfBlank()
    101.                                 + ",  " + SF.getBytes() + " bytes");*/
    102.  
    103.                         //统计
    104.                         AllOfLines += SF.getCntOfLines();
    105.                         AllOfBlank += SF.getCntOfBlank();
    106.                         AllOfBytes += SF.getBytes();
    107.                     }
    108.                 }
    109.             }
    110.         } else if (root.isFile() && root.getName().endsWith(".java")) {//如果是文件且为.java文件则直接存储
    111.             GloBal.fileArrayList.add(root);
    112.  
    113.             SourceFile SF = new SourceFile(root);
    114.             StringBuilder newName = tidyFileName(root);
    115.             StringBuilder newLines = tidyLines(root);
    116.             StringBuilder newBlank = tidyBlank(root);
    117.  
    118.             GloBal.outputData.add("    -" + newName
    119.                     + "\t Total:  " + newLines
    120.                     + "Blank: " + newBlank
    121.                     + SF.getBytes() + "  bytes");
    122.             //统计
    123.             AllOfLines += SF.getCntOfLines();
    124.             AllOfBlank += SF.getCntOfBlank();
    125.             AllOfBytes += SF.getBytes();
    126.         }
    127.     }
    128.  
    129.     //子目录比上一级缩进4格
    130.     private static StringBuilder getTap() {
    131.         StringBuilder tap = new StringBuilder();
    132.         for (int i = 1; i <= level * 4; i++) {
    133.             tap.append(" ");
    134.         }
    135.         return tap;
    136.     }
    137.  
    138.     private static void saveTotal() {
    139.         StringBuilder newCntOfFiles = tidyTotal(new StringBuilder(String.valueOf(getAllOfFiles())));
    140.         StringBuilder newCntOfLines = tidyTotal(new StringBuilder(String.valueOf(getAllOfLines())));
    141.         StringBuilder newCntOfBlank = tidyTotal(new StringBuilder(String.valueOf(getAllOfBlank())));
    142.         StringBuilder newCntOfBytes = tidyTotal(new StringBuilder(String.valueOf(getAllOfBytes())));
    143.         GloBal.outputData.add("Total:");
    144.         GloBal.outputData.add("\t\t" + newCntOfFiles + "\tJava Files");
    145.         GloBal.outputData.add("\t\t" + newCntOfLines + "\tlines in files");
    146.         GloBal.outputData.add("\t\t" + newCntOfBlank + "\tblank lines");
    147.         GloBal.outputData.add("\t\t" + newCntOfBytes + "\tbytes");
    148.     }
    149.  
    150.     private static StringBuilder tidyTotal(StringBuilder str) {
    151.         for (int i = str.length(); i < 8; i++) {
    152.             str.append(" ");
    153.         }
    154.         return str;
    155.     }
    156.  
    157.     private static StringBuilder tidyFileName(File file) {
    158.         //处理文件名 方面后面对齐
    159.         StringBuilder newName = new StringBuilder(file.getName());
    160.         int size = file.getName().length();
    161.         for (int j = size; j < 40; j++) {
    162.             newName.append(" ");
    163.         }
    164.         return newName;
    165.     }
    166.  
    167.     private static StringBuilder tidyLines(File file) {
    168.         SourceFile SF = new SourceFile(file);//使用SourceFile类进行统计
    169.         StringBuilder newLines = new StringBuilder(String.valueOf(SF.getCntOfLines()));
    170.         int len = newLines.length();
    171.         for (int j = len; j < 6; j++) {
    172.             if (j == len) {
    173.                 newLines.append(",");
    174.             }
    175.             newLines.append(" ");
    176.         }
    177.         return newLines;
    178.     }
    179.  
    180.     private static StringBuilder tidyBlank(File file) {
    181.         SourceFile SF = new SourceFile(file);//使用SourceFile类进行统计
    182.         StringBuilder newBlank = new StringBuilder(String.valueOf(SF.getCntOfBlank()));
    183.         int lengthOfBlank = newBlank.length();
    184.         for (int j = lengthOfBlank; j < 6; j++) {
    185.             if (j == lengthOfBlank) {
    186.                 newBlank.append(",");
    187.             }
    188.             newBlank.append(" ");
    189.         }
    190.         return newBlank;
    191.     }
    192.  
    193.     //对文件进行排序
    194.     //这个可能有问题，后续要注意调试
    195.     //如果一个目录里既有子目录又有文件，则先排子目录，再排文件
    196.     private static void sortFiles(File[] files) {
    197.         //使用匿名内部类构造比较器，对文件进行排序
    198.         Arrays.sort(files, new Comparator() {
    199.             @Override
    200.             public int compare(File o1, File o2) {
    201.                 if (o1.isFile() && o2.isFile()) {//都是文件
    202.                     return o1.getName().compareTo(o2.getName());
    203.                 } else if (o1.isDirectory() && o2.isDirectory()) {//都是目录
    204.                     return o1.getName().compareTo(o2.getName());
    205.                 } else if (o1.isDirectory() && o2.isFile()) {//一个目录一个文件
    206.                     return -1;
    207.                 } else if (o1.isFile() && o2.isDirectory()) {//一个文件一个目录
    208.                     return 1;
    209.                 } else {
    210.                     return 0;
    211.                 }
    212.             }
    213.         });
    214.     }
    215.  
    216.     //统计.java文件个数
    217.     public static int getAllOfFiles() {
    218.         return GloBal.fileArrayList.size();
    219.     }
    220.  
    221.     //统计所有.java文件中的字符个数
    222.     /*private static void CountOfCharOfFile() {
    223.         long SumOfChar = 0;
    224.         for (int i = 0; i < GloBal.fileArrayList.size(); i++) {
    225.             SumOfChar += GloBal.fileArrayList.get(i).length();
    226.         }
    227.     }*/
    228.  
    229.     //统计总行数
    230.     public static long getAllOfLines() {
    231.         return AllOfLines;
    232.     }
    233.  
    234.     //统计空行数
    235.     public static long getAllOfBlank() {
    236.         return AllOfBlank;
    237.     }
    238.  
    239.     //统计字符数
    240.     public static long getAllOfBytes() {
    241.         return AllOfBytes;
    242.     }
    243.  
    244.     /*
    245.      * 把分析结果保存到项目目录下的result文件夹
    246.      * */
    247.     public static void saveAnalyzeData() throws IOException {
    248.         root = new File(PathName);//原输入的目录名称，在saveFileList经过递归后root不再是一开始的root了
    249.         File resultFile = new File("Result");
    250.         if (!resultFile.exists()) {
    251.             resultFile.mkdir();
    252.         }
    253.         BufferedWriter AnalyzeDataIn = new BufferedWriter
    254.                 (new FileWriter(resultFile + "\\" + root.getName() + ".txt"));
    255.         for (int i = 0; i < GloBal.outputData.size(); i++) {
    256.             AnalyzeDataIn.write(GloBal.outputData.get(i));
    257.             AnalyzeDataIn.newLine();
    258.         }
    259.         AnalyzeDataIn.flush();
    260.     }
    261.  
    262.     /*
    263.      * 运行各方法以分析文件
    264.      * 保存分析数据
    265.      * */
    266.     public static void outPut() {
    267.         firstShow();
    268.         saveFileList();
    269.         saveTotal();
    270.         try {
    271.             saveAnalyzeData();
    272.         } catch (IOException e) {
    273.             e.printStackTrace();
    274.         }
    275.     }
    276. }

    Main类

    1. package Project;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         run();
    6.     }
    7.     public static void run(){
    8.         Menu menu = new Menu();
    9.         menu.showMenu();
    10.         run();
    11.     }
    12. }

  • 相关阅读:
    Matlab 对连续时间信号的运算
    CamVid数据集--学习笔记
    使用i18n Ayll在项目中也能显示中文
    领域驱动设计——领域的重构
    mysql的常见的外键约束
    儿童用台灯用白光好还是暖光好？推荐儿童使用的暖光台灯
    golang 琐碎知识
    [android毕业设计源码]精品基于Uniapp实现的美食APP[安卓毕业设计]
    移动宣传舞台车设计及运动仿真（lunwen+开题报告+初稿+cad图纸）
    【李航统计学习笔记】第二章：感知机
  • 原文地址：https://blog.csdn.net/zqihm/article/details/127953616