WordCount程序(Java)

 

 

Github项目地址:https://github.com/softwareCQT/web_camp/tree/master/wordCount

一、题目描述

  • 实现一个简单而完整的软件工具(源程序特征统计程序)。

  • 进行单元测试、回归测试、效能测试,在实现上述程序的过程中使用相关的工具。

  • 进行个人软件过程(PSP)的实践,逐步记录自己在每个软件工程环节花费的时间。


二、WC 项目要求

  • wc.exe 是一个常见的工具,它能统计文本文件的字符数、单词数和行数。这个项目要求写一个命令行程序,模仿已有wc.exe 的功能,并加以扩充,给出某程序设计语言源文件的字符数、单词数和行数。

  • 实现一个统计程序,它能正确统计程序文件中的字符数、单词数、行数,以及还具备其他扩展功能,并能够快速地处理多个文件。

  • 具体功能要求:程序处理用户需求的模式为:wc.exe [parameter] [file_name]


三、核心代码

  • 文件处理(包括处理通配符*?和-s递归)

    /**
    * @author chenqiting
    */
    public class FileUtil {

       /***
        * 判断文件是否合法 且 处理通配符并返回文件列表
        * @return List
        */
       public static List<File> accessRegx(String fileName){
           if (fileName.contains(CommandConstants.UNIVERSAL_CHAR_ONE)
                   || fileName.contains(CommandConstants.UNIVERSAL_CHAR_TWO)) {
             //判断是否存在通配符,统一换掉参数
               fileName = fileName.
                       replace(CommandConstants.UNIVERSAL_CHAR_TWO, CommandConstants.UNIVERSAL_CHAR_ONE);
               //如果是绝对路径,获取绝对路径的前半段,即获取到*号之前的路径
               int index = fileName.indexOf("*");
               //标志文件是否在文件后缀加的通配符
               boolean flag = (index == fileName.length() - 1);
               String parentDirectory;
               String childFileName;
               //如果是文件类型通配符,父路径需要重新处理
               if (flag) {
                   index = fileName.lastIndexOf("\\");
                   index = index == -1 ? 0 : index;
              }
               parentDirectory = fileName.substring(0, index);
               childFileName = fileName.substring(index);
               //系统路径匹配器
               PathMatcher pathMatcher;
               File file;
               //空字符串表示需要当前路径匹配
               if ("".equals(parentDirectory)){
                   file = new File(".");
                   String string = file.getAbsolutePath().replace(".", "").replace("\\", "\\\\");

                   file = new File(string);
                   pathMatcher = FileSystems.getDefault().
                           getPathMatcher("regex:" + string + "\\\\" + childFileName);
              }else {
                   parentDirectory = parentDirectory.replace("\\", "\\\\");
                   file = new File(parentDirectory);
                   //在parentDirectory目录下进行遍历
                   pathMatcher = FileSystems.getDefault().
                           getPathMatcher("glob:" + parentDirectory + childFileName);
              }
               return stackForFile(file, pathMatcher);
          }else {
               File file = new File(fileName);
               //判断文件是否存在
               if (file.exists()){
                   if (file.isDirectory()){
                       System.out.println(file.getName() + "不是文件,请重新输入");
                  }
              }else {
                   System.out.println("找不到该文件");
              }
               ArrayList<File> arrayList = new ArrayList<>(1);
               arrayList.add(file);
               return arrayList;
          }
      }

       /***
        * 处理当前目录下的所有符合的文件
        * @return 文件的集合
        */
       public static List<File> getBlowFile(String fileName){
           String newFileName = fileName.
                   replace(CommandConstants.UNIVERSAL_CHAR_TWO, CommandConstants.UNIVERSAL_CHAR_ONE);
           //路径匹配器
           PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + "**/" + newFileName);
           return stackForFile(new File("."), pathMatcher);
      }

       /***
        * 把当前文件夹下的文件放进栈
        * @param file
        * @param stringDeque
        */
       private static void addToStack(File file, Queue<File> stringDeque) {
           File[] string = file.listFiles();
           if (!Objects.isNull(string)) {
               Collections.addAll(stringDeque, string);
          }
      }

       /***
        * 递归匹配查找函数
        * @param parent 父目录
        * @param pathMatcher 匹配器
        * @return 文件
        */
       private static List<File> stackForFile(File parent, PathMatcher pathMatcher){
           //文件不存在
           if (!parent.exists()) {
               return null;
          }
           ArrayDeque<File> stringDeque = new ArrayDeque<>();
           addToStack(parent, stringDeque);
           //创建结果集合
           List<File> strings = new ArrayList<>();
           //用栈去处理文件
           while (!stringDeque.isEmpty()) {
               File newFile = stringDeque.pollLast();

               if (newFile.isDirectory()) {
                   addToStack(newFile, stringDeque);
              }else {
                   if (pathMatcher.matches(newFile.toPath())){
                       strings.add(newFile);
                  }
              }
          }
           return strings;
      }
  • 获取文件流中的数据,用BufferedReader读取流,然后转换流为List

    /***
    * 打开文件流并执行命令操作
    * @param files 文件
    * @param commandString 命令字符串
    * @throws NullPointerException 空指针防止有未知命令出现
    */
    private static void invoke(List<File> files, List<String> commandString) throws NullPointerException{
       //判空处理
       if (Objects.isNull(files) || files.isEmpty()) {
           System.out.println("文件参数使用错误或目录下没有匹配文件");
           return;
      }
       //对文件进行命令操作
       files.forEach(file -> {
           try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))){
               System.out.println("文件名称:" + file.getPath());
               List<String> stringList = bufferedReader.lines().collect(Collectors.toList());
               for (String string : commandString) {
                   BaseCommand baseCommand =  CommandFactory.getValue(string);
                   baseCommand.fileLineList(stringList).invoke();

              }
          } catch (IOException e) {
               System.out.println("文件错误");
          }
      });
    }
  • -c 命令处理

    /**
    * @author chenqiting
    */
    public class AllBaseCommand extends BaseCommand<AllBaseCommand> {

       @Override
       public void invoke() throws IOException {
           //分别统计注释行、代码行、空行
           int descriptionLine = 0;
           int codeLine = 0;
           int nullLine = 0;
           //标注多行注释
           boolean flag = false;
           //用来引用处理过的string
           String stringBuffer;
           for (String string : fileLineList){
               //去掉所有空白字符
               stringBuffer = string.replaceAll("\\s+", "");
               //先判断flag是否为真,优先处理
               if (flag){
                   if (string.endsWith("*/")){
                       flag = false;
                  }
                   descriptionLine++;
                   continue;
              }
               //空行
               if ("".equals(string)){
                   nullLine++;
              } else if (stringBuffer.startsWith("/*") && stringBuffer.endsWith("*/")){
                   //同行注释同行结束,直接相加
                   descriptionLine++;
              } else if (stringBuffer.startsWith("/*") && !stringBuffer.endsWith("*/")){
                   flag = true;
                   descriptionLine++;
              } else if (stringBuffer.matches("^\\S(//)")){
                   //单字符后存在的注释情况//
                   descriptionLine++;
              } else {
                   //其余全为代码行
                   codeLine++;
              }
          }
           System.out.println("空行:" + nullLine);
           System.out.println("注释行:" + descriptionLine);
           System.out.println("代码行:" + codeLine);
      }
    }
  • -l命令处理

    /**
    * @author chenqiting
    */
    public class AllBaseCommand extends BaseCommand<AllBaseCommand> {

       @Override
       public void invoke() throws IOException {
           //分别统计注释行、代码行、空行
           int descriptionLine = 0;
           int codeLine = 0;
           int nullLine = 0;
           //标注多行注释
           boolean flag = false;
           //用来引用处理过的string
           String stringBuffer;
           for (String string : fileLineList){
               //去掉所有空白字符
               stringBuffer = string.replaceAll("\\s+", "");
               //先判断flag是否为真,优先处理
               if (flag){
                   if (string.endsWith("*/")){
                       flag = false;
                  }
                   descriptionLine++;
                   continue;
              }
               //空行
               if ("".equals(string)){
                   nullLine++;
              } else if (stringBuffer.startsWith("/*") && stringBuffer.endsWith("*/")){
                   //同行注释同行结束,直接相加
                   descriptionLine++;
              } else if (stringBuffer.startsWith("/*") && !stringBuffer.endsWith("*/")){
                   flag = true;
                   descriptionLine++;
              } else if (stringBuffer.matches("^\\S(//)")){
                   //单字符后存在的注释情况//
                   descriptionLine++;
              } else {
                   //其余全为代码行
                   codeLine++;
              }
          }
           System.out.println("空行:" + nullLine);
           System.out.println("注释行:" + descriptionLine);
           System.out.println("代码行:" + codeLine);
      }
    }
  • -l命令处理

    /**
    * @author chenqiting
    */
    public class LineBaseCommand extends BaseCommand<LineBaseCommand> {
       @Override
       public void invoke() throws IOException {
           System.out.println("文件行数:" + fileLineList.size());
      }
    }
  • -a命令处理

     @Override
       public void invoke() throws IOException {
           //分别统计注释行、代码行、空行
           int descriptionLine = 0;
           int codeLine = 0;
           int nullLine = 0;
           //标注多行注释
           boolean flag = false;
           //用来引用处理过的string
           String stringBuffer;
           for (String string : fileLineList){
               //去掉所有空白字符
               stringBuffer = string.replaceAll("\\s+", "");
               //先判断flag是否为真,优先处理
               if (flag){
                   if (string.endsWith("*/")){
                       flag = false;
                  }
                   descriptionLine++;
                   continue;
              }
               //空行
               if ("".equals(string)){
                   nullLine++;
              } else if (stringBuffer.startsWith("/*") && stringBuffer.endsWith("*/")){
                   //同行注释同行结束,直接相加
                   descriptionLine++;
              } else if (stringBuffer.startsWith("/*") && !stringBuffer.endsWith("*/")){
                   flag = true;
                   descriptionLine++;
              } else if (stringBuffer.matches("^\\S(//)")){
                   //单字符后存在的注释情况//
                   descriptionLine++;
              } else {
                   //其余全为代码行
                   codeLine++;
              }
          }
           System.out.println("空行:" + nullLine);
           System.out.println("注释行:" + descriptionLine);
           System.out.println("代码行:" + codeLine);
      }
    }
  • 主函数调用,工厂方法

    public static void main(String[] args){
       //获取参数
       List<String> commandString = util.ArgsUtil.getCommand(args);
       String fileName = util.ArgsUtil.getFileName(args);

       try {
           //验证参数是否存在问题
           if (!commandString.isEmpty() && Objects.nonNull(fileName)) {
               //判断是否存在-s递归
               boolean flag = commandString.contains(CommandConstants.COUNT_SOME_FILE);
               List<File> files;
               //递归则获取文件目录
               if (flag) {
                   //递归获取当前路径
                    files = FileUtil.getBlowFile(fileName);
                   // 因为-s命令比其他命令优先级高,且作用不同,所以要提前剔除
                   commandString.remove(CommandConstants.COUNT_SOME_FILE);
              } else {
                   //TODO 处理通配符的问题
                    files = FileUtil.accessRegx(fileName);
              }
               invoke(files, commandString);
          } else if (commandString.size() == 1 && commandString.get(0).equals(CommandConstants.COUNT_HELP) ){
               //需要对参数进行判断,然后实现CountHelp
               CommandFactory.getValue(CommandConstants.COUNT_HELP).invoke();
          } else {
               //参数错误
               CommandFactory.getValue(CommandConstants.COUNT_ERROR).invoke();
          }
      } catch (NullPointerException e) {
           //对未知参数进行捕获
           System.out.println("命令出现未知参数");
      } catch (Exception e){
           System.out.println("系统错误");
      }
    }

    四、项目测试

    java并没有不可以直接实现exe程序,需要使用工具转换,且与wc.exe文件相协同的文件目录下必须存在jre

     

  WordCount程序(Java)_第1张图片WordCount程序(Java)_第2张图片WordCount程序(Java)_第3张图片

WordCount程序(Java)_第4张图片


五、PSP表格

PSP2.1 Personal Software Process Stages 预估耗时(分钟) 实际耗时(分钟)
Planning 计划 10 15
· Estimate · 估计这个任务需要多少时间 250 300
Development 开发 300 350
· Analysis · 需求分析 (包括学习新技术) 10 10
· Design Spec · 生成设计文档 10 10
· Design Review · 设计复审 (和同事审核设计文档) 10 10
· Coding Standard · 代码规范 (为目前的开发制定合适的规范) 5 5
· Design · 具体设计 30 25
· Coding · 具体编码 150 250
· Code Review · 代码复审 10 15
· Test · 测试(自我测试,修改代码,提交修改) 10 30
Reporting 报告 15 20
· Test Report · 测试报告 10 30
· Size Measurement · 计算工作量 15 20
· Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划 15 30
合计   850 1020

六、总结

学习了一下Java对正则表达式的PatternAPI的支持,以及正则表达式的内容。整体来说Java可以用BufferedReader流直接通过Stream流来转换成集合存储每一行,导致文件内容可重用,而不用持续地进行IO。编码过程中也在思考设计模式可以在里面充当什么角色,所以根据命令的不同,我使用了工厂模式,程序可扩展性算中等。

你可能感兴趣的:(WordCount程序(Java))