软工实践作业（五）

GitHub

作业链接

结对博客 031602240

具体分工

许郁杨：WordCount代码、文档编写；

温伊倩：爬虫、附加功能设计和实现、部分文档编写.

我们首先详细阅读了作业要求，明确了各部分功能、实现方式和细节，以及所需的附加功能。

确定好需求和设计细节后，我们开始准备实现各自负责的部分，学习和测试需要使用到的技术。接着便是逐步完成各个功能，进行性能分析和单元测试，并编写博客。

在爬虫和附加功能部分，我主要是作为“驾驶员”（Driver），而队友主要作为“领航员”（Navigator）；

在WordCount部分，我主要是作为“领航员”（Navigator），而队友主要作为“驾驶员”（Driver）。

这样分工使得两人工作量较为均等，并且各自都能完成较为擅长的部分，保证了最后的质量。

PSP表格

PSP2.1 Personal Software Process Stages 预估耗时（分钟） 实际耗时（分钟）
Planning 计划 45 57
· Estimate · 估计这个任务需要多少时间 45 57
Development 开发 890 1015
· Analysis · 需求分析 (包括学习新技术) 200 214
· Design Spec · 生成设计文档 30 32
· Design Review · 设计复审 20 9
· Coding Standard · 代码规范（为目前的开发制定合适的规范） 10 5
· Design · 具体设计 30 34
· Coding · 具体编码 400 518
· Code Review · 代码复审 50 41
· Test · 测试（自我测试，修改代码，提交修改） 150 162
Reporting 报告 70 47
· Test Report · 测试报告 20 12
· Size Measurement · 计算工作量 20 11
· Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划 30 24
合计 1005 1119

代码规范

代码规范我们用的是实验室的代码规范：阿里巴巴的码出高效，并加上了一些补充。

解题思路与设计说明

爬虫使用

  • 介绍

爬虫是用java的一款HTML解析器——Jsoup来实现的。

首先用Jsoup.connect(String url)抓取url，得到网站的HTML文件文档，根据代码发现各论文页面的地址放置于ptitle类a元素的href属性中，使用Element类得到论文页面的超链接后，再循环得到各论文页面的文档，使用Element类找到papertitle和abstract，将其文本存于字符串中输出到文件中。

  • 流程图

  • 主要代码
  1.   //从URL加载Document
  2.             Document doc = Jsoup.connect(URL)
  3.                     // 取消获取相应内容大小限制
  4.                     .maxBodySize(0)
  5.                     //设置超时时间
  6.                     .timeout(600000)
  7.                     .get();
  8.             //ptitle类
  9.             Elements paper = doc.select("[class=ptitle]");
  10.             //ptitle类中带有href属性的a元素
  11.             Elements links = paper.select("a[href]");
  12.             //论文计数
  13.             long count = 0;
  14.             for(Element link : links) {
  15.                 //论文页url
  16.                 String url = link.absUrl("href");
  17.                 Document paperDoc = Jsoup.connect(url)
  18.                         .maxBodySize(0)
  19.                         .timeout(600000)
  20.                         .get();
  21.                 //获取论文标题
  22.                 Elements paperTitle = paperDoc.select("[id=papertitle]");
  23.                 String title = paperTitle.text();
  24.                 //获取论文简介
  25.                 Elements paperAbstract = paperDoc.select("[id=abstract]");
  26.                 String abstracts = paperAbstract.text();

代码组织与内部实现设计（类图）

算法关键

实现方法

这次基本要求里相对上次新增加的功能主要有以下几点：

  • 可传入多参数；
  • 可指定输入输出文件；
  • 词频统计权重开关；
  • 可指定词频统计输出个数；
  • 可统计词组词频，并可指定词组长度；
  • 可切换单词词频和词组词频；

其中实现的关键点在于多参数和词组词频统计。

对于多参数，我的实现方式是使用Apache的commons-cli包，并增设JavaBean "WordCounterInfo"。

通过commons-cli中的PosixParser解析原始命令行数据，然后把解析得到的数据存入Bean。

其中，Bean所包含的参数有：

  1. private String inputFile = "input.txt";
  2. private String outputFile = "output.txt";
  3. private int weightFactor = 1;
  4. private int phraseLength = -1;
  5. private int wordFrequencyOutNum = 10;

对于词组词频统计，我的实现方式通过自动机扫描文本，判断得到单词，并记录下该单词的首尾下标，存入队列。然后判断队列长度，每当长度满足要求时，分别取出头尾两个单词的首下标、尾下标，这样就能定位出一整个词组。同时，在自动机判断过程中，每当在单词与单词的间隔中出现不属于分隔符的字母符号时，就清空队列，避免出现不合法的词组。

流程图

附加题

设计的创意独到之处

1.从网站爬取了论文作者、pdf链接的额外信息.[内容txt文件](https://files.cnblogs.com/files/qvq-qvq/result.txt.zip)
2.分析了论文列表中第一作者与第二作者之间的合作关系，并根据关系生成了关系图谱。

实现思路

1.实现方法如同爬虫使用。
2.由爬取的论文作者中提取第一作者与第二作者，用Java将之写入到Excel表格中,再使用NodeXL生成关系图表,对生成图进行筛选，可以得到合作数较多的作者。

实现成果展示

1.爬取信息图



2.全部作者关系图



筛选掉近发表过一次的作者

细节图（单节点说明此作者的度>=2,但队友都被滤掉了）：



身为第一第二作者且和人合作次数的作者

关键代码

这里贴出多参数解析和词组词频统计两个关键部分的代码，并做更详尽的分析解释。

对于多参数解析，我首先添加各项参数及其对应解释，如对于参数i，其意义为"input"，后跟数据——输入文件的文件名，具体描述为"input file path."。

然后创建Posix形式的解析器，并解析命令行。接着逐项处理参数，对于i、o、w三个必有参数，直接取值并存入Bean中；对于其他可选参数，逐项判断。

  1.     /**
  2.      * 解析命令行
  3.      *
  4.      * @param args 命令行参数
  5.      * @param wordCounterInfo 计数器的Bean
  6.      */
  7.     public static void parseCommadLine(String[] args, WordCounterInfo wordCounterInfo) {
  8.         Options options = new Options();
  9.         options.addOption("i", "input", true, "input file path.");
  10.         options.addOption("o", "output", true, "result file path.");
  11.         options.addOption("w", "weight", true, "set weight factor.");
  12.         options.addOption("m", "length", true, "phrase length.");
  13.         options.addOption("n", "number", true, "word frequency output number.");
  14.         options.addOption("h", "help", false, "print options' information");
  16.         CommandLineParser parser = new PosixParser();
  17.         try {
  18.             CommandLine commandLine = parser.parse(options, args);
  19.             if (commandLine.hasOption("h")) {
  20.                 HelpFormatter helpFormatter = new HelpFormatter();
  21.                 helpFormatter.printHelp("Options", options);
  22.             } else {
  23.                 wordCounterInfo.setInputFile(commandLine.getOptionValue("i"));
  24.                 wordCounterInfo.setOutputFile(commandLine.getOptionValue("o"));
  25.                 wordCounterInfo.setWeightFactor(Integer.parseInt(commandLine.getOptionValue("w")));
  26.                 if (commandLine.hasOption("m")) {
  27.                     wordCounterInfo.setPhraseLength(Integer.parseInt(commandLine.getOptionValue("m")));
  28.                 }
  29.                 if (commandLine.hasOption("n")) {
  30.                     wordCounterInfo.setWordFrequencyOutNum(Integer.parseInt(commandLine.getOptionValue("n")));
  31.                 }
  32.             }
  33.         } catch (ParseException e) {
  34.             System.out.println("Arguments format wrong.");
  35.             e.printStackTrace();
  36.         }
  37.     }

对于词组词频统计，基本逻辑与之前处理单词词频时相近。首先读入文本，然后判断是否为Title或Abstract，对这两个部分的文本区分处理。

通过自动机扫描单词，并记录下单词的首尾下标。每扫描出一个单词，就去构造词组，将新得到的单词压入队列尾部。自动机扫描过程中，如果出现一个合法单词后跟着一个非法单词的情况，就清空队列（此时那个合法单词不能在后续过程中组成合法词组）。如果队列长度满足要求，就记录下词组的首尾下标，并推出头元素。然后根据下标取出词组，存入Map。如果有权重要求，就对Title部分的词组增加权重值。最后对得到的Map排序，就得到了所需的词频排序列表。

  1.     /**
  2.      * 读取并计算Title和Abstract词组词频.
  3.      *
  4.      * @param fileName     文件名
  5.      * @param weightFactor 权重参数
  6.      * @param phraseLength 词组长度
  7.      * @return 各词组词频
  8.      */
  9.     public static HashMap<String, Long> countPhraseFrequency(String fileName, int weightFactor, int phraseLength) {
  10.         InputStreamReader inputStreamReader = null;
  11.         BufferedReader bufferedReader = null;
  12.         String in = "";
  13.         char temp;
  14.         int state = 0;
  15.         int startSubscript = 0;
  16.         int endSubscript = 0;
  17.         HashMap<String, Long> phraseMap = new HashMap<String, Long>(100 * 1024 * 1024);
  19.         //读入文件
  20.         try {
  21.             inputStreamReader = new InputStreamReader(new FileInputStream(fileName));
  22.         } catch (FileNotFoundException e) {
  23.             System.out.println("PhraseFrequencyCounter找不到此文件");
  24.             e.printStackTrace();
  25.         }
  26.         if (inputStreamReader != null) {
  27.             bufferedReader = new BufferedReader(inputStreamReader);
  28.         }
  29.         //计算单词词频
  30.         try {
  31.             while ((in = bufferedReader.readLine()) != null) {
  32.                 if (in.contains("Title: ")) {
  33.                     wordsDeque.clear();
  34.                     int length = in.length();
  35.                     state = 0;
  36.                     for (int i = 7; i < length; i++) {
  37.                         temp = in.charAt(i);
  38.                         //大写字母转为小写字母
  39.                         if ((temp >= 65) && (temp <= 90)) {
  40.                             temp += 32;
  41.                         }
  42.                         //自动机状态转移
  43.                         switch (state) {
  44.                             case 0: {
  45.                                 if ((temp >= 97) && (temp <= 122)) {
  46.                                     startSubscript = i;
  47.                                     state = 1;
  48.                                 }
  49.                                 break;
  50.                             }
  51.                             case 1: {
  52.                                 if ((temp >= 97) && (temp <= 122)) {
  53.                                     state = 2;
  54.                                 } else {
  55.                                     wordsDeque.clear();
  56.                                     state = 0;
  57.                                 }
  58.                                 break;
  59.                             }
  60.                             case 2: {
  61.                                 if ((temp >= 97) && (temp <= 122)) {
  62.                                     state = 3;
  63.                                 } else {
  64.                                     wordsDeque.clear();
  65.                                     state = 0;
  66.                                 }
  67.                                 break;
  68.                             }
  69.                             case 3: {
  70.                                 if ((temp >= 97) && (temp <= 122)) {
  71.                                     endSubscript = i;
  72.                                     state = 4;
  73.                                 } else {
  74.                                     wordsDeque.clear();
  75.                                     state = 0;
  76.                                 }
  77.                                 break;
  78.                             }
  79.                             case 4: {
  80.                                 if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  81.                                     endSubscript = i;
  82.                                 } else {
  83.                                     if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  84.                                         StringBuilder phrase = new StringBuilder();
  85.                                         int start = phraseInfo.getStartSubscript();
  86.                                         int end = phraseInfo.getEndSubscript();
  87.                                         char tempc;
  88.                                         for (int j = start; j <= end; j++) {
  89.                                             tempc = in.charAt(j);
  90.                                             if ((tempc >= 65) && (tempc <= 90)) {
  91.                                                 tempc += 32;
  92.                                             }
  93.                                             phrase.append(tempc);
  94.                                         }
  95.                                         if (weightFactor == 1) {
  96.                                             if (phraseMap.containsKey(phrase.toString())) {
  97.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 10L);
  98.                                             } else {
  99.                                                 phraseMap.put(phrase.toString(), 10L);
  100.                                             }
  101.                                         } else {
  102.                                             if (phraseMap.containsKey(phrase.toString())) {
  103.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  104.                                             } else {
  105.                                                 phraseMap.put(phrase.toString(), 1L);
  106.                                             }
  107.                                         }
  108.                                     }
  109.                                     state = 0;
  110.                                 }
  111.                                 break;
  112.                             }
  113.                         }
  114.                     }
  115.                     if (state == 4) {
  116.                         if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  117.                             StringBuilder phrase = new StringBuilder();
  118.                             int start = phraseInfo.getStartSubscript();
  119.                             int end = phraseInfo.getEndSubscript();
  120.                             char tempc;
  121.                             for (int j = start; j <= end; j++) {
  122.                                 tempc = in.charAt(j);
  123.                                 if ((tempc >= 65) && (tempc <= 90)) {
  124.                                     tempc += 32;
  125.                                 }
  126.                                 phrase.append(tempc);
  127.                             }
  128.                             if (weightFactor == 1) {
  129.                                 if (phraseMap.containsKey(phrase.toString())) {
  130.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 10L);
  131.                                 } else {
  132.                                     phraseMap.put(phrase.toString(), 10L);
  133.                                 }
  134.                             } else {
  135.                                 if (phraseMap.containsKey(phrase.toString())) {
  136.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  137.                                 } else {
  138.                                     phraseMap.put(phrase.toString(), 1L);
  139.                                 }
  140.                             }
  141.                         }
  142.                     }
  143.                 } else {
  144.                     if (in.contains("Abstract: ")) {
  145.                         wordsDeque.clear();
  146.                         int length = in.length();
  147.                         state = 0;
  148.                         for (int i = 10; i < length; i++) {
  149.                             temp = in.charAt(i);
  150.                             //大写字母转为小写字母
  151.                             if ((temp >= 65) && (temp <= 90)) {
  152.                                 temp += 32;
  153.                             }
  154.                             //自动机状态转移
  155.                             switch (state) {
  156.                                 case 0: {
  157.                                     if ((temp >= 97) && (temp <= 122)) {
  158.                                         startSubscript = i;
  159.                                         state = 1;
  160.                                     }
  161.                                     break;
  162.                                 }
  163.                                 case 1: {
  164.                                     if ((temp >= 97) && (temp <= 122)) {
  165.                                         state = 2;
  166.                                     } else {
  167.                                         wordsDeque.clear();
  168.                                         state = 0;
  169.                                     }
  170.                                     break;
  171.                                 }
  172.                                 case 2: {
  173.                                     if ((temp >= 97) && (temp <= 122)) {
  174.                                         state = 3;
  175.                                     } else {
  176.                                         wordsDeque.clear();
  177.                                         state = 0;
  178.                                     }
  179.                                     break;
  180.                                 }
  181.                                 case 3: {
  182.                                     if ((temp >= 97) && (temp <= 122)) {
  183.                                         endSubscript = i;
  184.                                         state = 4;
  185.                                     } else {
  186.                                         wordsDeque.clear();
  187.                                         state = 0;
  188.                                     }
  189.                                     break;
  190.                                 }
  191.                                 case 4: {
  192.                                     if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  193.                                         endSubscript = i;
  194.                                     } else {
  195.                                         if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  196.                                             StringBuilder phrase = new StringBuilder();
  197.                                             int start = phraseInfo.getStartSubscript();
  198.                                             int end = phraseInfo.getEndSubscript();
  199.                                             char tempc;
  200.                                             for (int j = start; j <= end; j++) {
  201.                                                 tempc = in.charAt(j);
  202.                                                 if ((tempc >= 65) && (tempc <= 90)) {
  203.                                                     tempc += 32;
  204.                                                 }
  205.                                                 phrase.append(tempc);
  206.                                             }
  207.                                             if (phraseMap.containsKey(phrase.toString())) {
  208.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  209.                                             } else {
  210.                                                 phraseMap.put(phrase.toString(), 1L);
  211.                                             }
  212.                                         }
  213.                                         state = 0;
  214.                                     }
  215.                                     break;
  216.                                 }
  217.                             }
  218.                         }
  219.                         if (state == 4) {
  220.                             if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  221.                                 StringBuilder phrase = new StringBuilder();
  222.                                 int start = phraseInfo.getStartSubscript();
  223.                                 int end = phraseInfo.getEndSubscript();
  224.                                 char tempc;
  225.                                 for (int j = start; j <= end; j++) {
  226.                                     tempc = in.charAt(j);
  227.                                     if ((tempc >= 65) && (tempc <= 90)) {
  228.                                         tempc += 32;
  229.                                     }
  230.                                     phrase.append(tempc);
  231.                                 }
  232.                                 if (phraseMap.containsKey(phrase.toString())) {
  233.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  234.                                 } else {
  235.                                     phraseMap.put(phrase.toString(), 1L);
  236.                                 }
  237.                             }
  238.                         }
  239.                     }
  240.                 }
  241.             }
  242.         } catch (IOException e) {
  243.             e.printStackTrace();
  244.         } finally {
  245.             try {
  246.                 inputStreamReader.close();
  247.             } catch (IOException e) {
  248.                 e.printStackTrace();
  249.             }
  250.         }
  251.         return phraseMap;
  252.     }
  254.     /**
  255.      * 构造词组
  256.      *
  257.      * @param startSubscript 单词首下标
  258.      * @param endSubscript 单词尾下标
  259.      * @param phraseLength 词组长度
  260.      * @return 当前是否构造出合法词组
  261.      */
  262.     private static boolean constructPhrase(int startSubscript, int endSubscript, int phraseLength) {
  263.         WordInfo wordInfo = new WordInfo();
  264.         wordInfo.setStartSubscript(startSubscript);
  265.         wordInfo.setEndSubscript(endSubscript);
  267.         wordsDeque.addLast(wordInfo);
  268.         if (wordsDeque.size() == phraseLength) {
  269.             phraseInfo.setStartSubscript(wordsDeque.getFirst().getStartSubscript());
  270.             phraseInfo.setEndSubscript(wordsDeque.getLast().getEndSubscript());
  271.             wordsDeque.removeFirst();
  272.             return true;
  273.         }
  274.         return false;
  275.     }

性能分析

下面是命令行参数为"-i result.txt -o output.txt -w 1 -n 20"的性能分析情况。









下面是命令行参数为"-i result.txt -o output.txt -w 1 -n 20 -m 3"的性能分析情况。









可以看出消耗最高的为单词和词组的词频统计部分。

  1.     /**
  2.      * 读取并计算Title和Abstract词频.
  3.      *
  4.      * @param fileName     文件名
  5.      * @param weightFactor 权重参数
  6.      * @return 各单词词频
  7.      */
  8.     public static HashMap<String, Long> countWordsFrequency(String fileName, int weightFactor) {
  9.         InputStreamReader inputStreamReader = null;
  10.         BufferedReader bufferedReader = null;
  11.         String in = "";
  12.         char temp;
  13.         int state = 0;
  14.         StringBuilder word = new StringBuilder();
  15.         HashMap<String, Long> wordMap = new HashMap<String, Long>(100 * 1024 * 1024);
  17.         //读入文件
  18.         try {
  19.             inputStreamReader = new InputStreamReader(new FileInputStream(fileName));
  20.         } catch (FileNotFoundException e) {
  21.             System.out.println("WordsFrequencyCounter找不到此文件");
  22.             e.printStackTrace();
  23.         }
  24.         if (inputStreamReader != null) {
  25.             bufferedReader = new BufferedReader(inputStreamReader);
  26.         }
  27.         //计算单词词频
  28.         try {
  29.             while ((in = bufferedReader.readLine()) != null) {
  30.                 if (in.contains("Title: ")) {
  31.                     word.setLength(0);
  32.                     int length = in.length();
  33.                     state = 0;
  34.                     for (int i = 7; i < length; i++) {
  35.                         temp = in.charAt(i);
  36.                         //大写字母转为小写字母
  37.                         if ((temp >= 65) && (temp <= 90)) {
  38.                             temp += 32;
  39.                         }
  40.                         //自动机状态转移
  41.                         switch (state) {
  42.                             case 0: {
  43.                                 if ((temp >= 97) && (temp <= 122)) {
  44.                                     word.append(temp);
  45.                                     state = 1;
  46.                                 }
  47.                                 break;
  48.                             }
  49.                             case 1: {
  50.                                 if ((temp >= 97) && (temp <= 122)) {
  51.                                     word.append(temp);
  52.                                     state = 2;
  53.                                 } else {
  54.                                     word.setLength(0);
  55.                                     state = 0;
  56.                                 }
  57.                                 break;
  58.                             }
  59.                             case 2: {
  60.                                 if ((temp >= 97) && (temp <= 122)) {
  61.                                     word.append(temp);
  62.                                     state = 3;
  63.                                 } else {
  64.                                     word.setLength(0);
  65.                                     state = 0;
  66.                                 }
  67.                                 break;
  68.                             }
  69.                             case 3: {
  70.                                 if ((temp >= 97) && (temp <= 122)) {
  71.                                     word.append(temp);
  72.                                     state = 4;
  73.                                 } else {
  74.                                     word.setLength(0);
  75.                                     state = 0;
  76.                                 }
  77.                                 break;
  78.                             }
  79.                             case 4: {
  80.                                 if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  81.                                     word.append(temp);
  82.                                 } else {
  83.                                     if (weightFactor == 1) {
  84.                                         if (wordMap.containsKey(word.toString())) {
  85.                                             wordMap.put(word.toString(), wordMap.get(word.toString()) + 10L);
  86.                                         } else {
  87.                                             wordMap.put(word.toString(), 10L);
  88.                                         }
  89.                                     } else {
  90.                                         if (wordMap.containsKey(word.toString())) {
  91.                                             wordMap.put(word.toString(), wordMap.get(word.toString()) + 1L);
  92.                                         } else {
  93.                                             wordMap.put(word.toString(), 1L);
  94.                                         }
  95.                                     }
  96.                                     word.setLength(0);
  97.                                     state = 0;
  98.                                 }
  99.                                 break;
  100.                             }
  101.                         }
  102.                     }
  103.                     if (state == 4) {
  104.                         if (weightFactor == 1) {
  105.                             if (wordMap.containsKey(word.toString())) {
  106.                                 wordMap.put(word.toString(), wordMap.get(word.toString()) + 10L);
  107.                             } else {
  108.                                 wordMap.put(word.toString(), 10L);
  109.                             }
  110.                         } else {
  111.                             if (wordMap.containsKey(word.toString())) {
  112.                                 wordMap.put(word.toString(), wordMap.get(word.toString()) + 1L);
  113.                             } else {
  114.                                 wordMap.put(word.toString(), 1L);
  115.                             }
  116.                         }
  117.                     }
  118.                 } else {
  119.                     if (in.contains("Abstract: ")) {
  120.                         word.setLength(0);
  121.                         int length = in.length();
  122.                         state = 0;
  123.                         for (int i = 10; i < length; i++) {
  124.                             temp = in.charAt(i);
  125.                             //大写字母转为小写字母
  126.                             if ((temp >= 65) && (temp <= 90)) {
  127.                                 temp += 32;
  128.                             }
  129.                             //自动机状态转移
  130.                             switch (state) {
  131.                                 case 0: {
  132.                                     if ((temp >= 97) && (temp <= 122)) {
  133.                                         word.append(temp);
  134.                                         state = 1;
  135.                                     }
  136.                                     break;
  137.                                 }
  138.                                 case 1: {
  139.                                     if ((temp >= 97) && (temp <= 122)) {
  140.                                         word.append(temp);
  141.                                         state = 2;
  142.                                     } else {
  143.                                         word.setLength(0);
  144.                                         state = 0;
  145.                                     }
  146.                                     break;
  147.                                 }
  148.                                 case 2: {
  149.                                     if ((temp >= 97) && (temp <= 122)) {
  150.                                         word.append(temp);
  151.                                         state = 3;
  152.                                     } else {
  153.                                         word.setLength(0);
  154.                                         state = 0;
  155.                                     }
  156.                                     break;
  157.                                 }
  158.                                 case 3: {
  159.                                     if ((temp >= 97) && (temp <= 122)) {
  160.                                         word.append(temp);
  161.                                         state = 4;
  162.                                     } else {
  163.                                         word.setLength(0);
  164.                                         state = 0;
  165.                                     }
  166.                                     break;
  167.                                 }
  168.                                 case 4: {
  169.                                     if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  170.                                         word.append(temp);
  171.                                     } else {
  172.                                         if (wordMap.containsKey(word.toString())) {
  173.                                             wordMap.put(word.toString(), wordMap.get(word.toString()) + 1L);
  174.                                         } else {
  175.                                             wordMap.put(word.toString(), 1L);
  176.                                         }
  177.                                         word.setLength(0);
  178.                                         state = 0;
  179.                                     }
  180.                                     break;
  181.                                 }
  182.                             }
  183.                         }
  184.                         if (state == 4) {
  185.                             if (wordMap.containsKey(word.toString())) {
  186.                                 wordMap.put(word.toString(), wordMap.get(word.toString()) + 1L);
  187.                             } else {
  188.                                 wordMap.put(word.toString(), 1L);
  189.                             }
  190.                         }
  191.                     }
  192.                 }
  193.             }
  194.         } catch (IOException e) {
  195.             e.printStackTrace();
  196.         } finally {
  197.             try {
  198.                 inputStreamReader.close();
  199.             } catch (IOException e) {
  200.                 e.printStackTrace();
  201.             }
  202.         }
  203.         return wordMap;
  204.     }
  206.     /**
  207.      * 读取并计算Title和Abstract词组词频.
  208.      *
  209.      * @param fileName     文件名
  210.      * @param weightFactor 权重参数
  211.      * @param phraseLength 词组长度
  212.      * @return 各词组词频
  213.      */
  214.     public static HashMap<String, Long> countPhraseFrequency(String fileName, int weightFactor, int phraseLength) {
  215.         InputStreamReader inputStreamReader = null;
  216.         BufferedReader bufferedReader = null;
  217.         String in = "";
  218.         char temp;
  219.         int state = 0;
  220.         int startSubscript = 0;
  221.         int endSubscript = 0;
  222.         HashMap<String, Long> phraseMap = new HashMap<String, Long>(100 * 1024 * 1024);
  224.         //读入文件
  225.         try {
  226.             inputStreamReader = new InputStreamReader(new FileInputStream(fileName));
  227.         } catch (FileNotFoundException e) {
  228.             System.out.println("PhraseFrequencyCounter找不到此文件");
  229.             e.printStackTrace();
  230.         }
  231.         if (inputStreamReader != null) {
  232.             bufferedReader = new BufferedReader(inputStreamReader);
  233.         }
  234.         //计算单词词频
  235.         try {
  236.             while ((in = bufferedReader.readLine()) != null) {
  237.                 if (in.contains("Title: ")) {
  238.                     wordsDeque.clear();
  239.                     int length = in.length();
  240.                     state = 0;
  241.                     for (int i = 7; i < length; i++) {
  242.                         temp = in.charAt(i);
  243.                         //大写字母转为小写字母
  244.                         if ((temp >= 65) && (temp <= 90)) {
  245.                             temp += 32;
  246.                         }
  247.                         //自动机状态转移
  248.                         switch (state) {
  249.                             case 0: {
  250.                                 if ((temp >= 97) && (temp <= 122)) {
  251.                                     startSubscript = i;
  252.                                     state = 1;
  253.                                 }
  254.                                 break;
  255.                             }
  256.                             case 1: {
  257.                                 if ((temp >= 97) && (temp <= 122)) {
  258.                                     state = 2;
  259.                                 } else {
  260.                                     wordsDeque.clear();
  261.                                     state = 0;
  262.                                 }
  263.                                 break;
  264.                             }
  265.                             case 2: {
  266.                                 if ((temp >= 97) && (temp <= 122)) {
  267.                                     state = 3;
  268.                                 } else {
  269.                                     wordsDeque.clear();
  270.                                     state = 0;
  271.                                 }
  272.                                 break;
  273.                             }
  274.                             case 3: {
  275.                                 if ((temp >= 97) && (temp <= 122)) {
  276.                                     endSubscript = i;
  277.                                     state = 4;
  278.                                 } else {
  279.                                     wordsDeque.clear();
  280.                                     state = 0;
  281.                                 }
  282.                                 break;
  283.                             }
  284.                             case 4: {
  285.                                 if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  286.                                     endSubscript = i;
  287.                                 } else {
  288.                                     if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  289.                                         StringBuilder phrase = new StringBuilder();
  290.                                         int start = phraseInfo.getStartSubscript();
  291.                                         int end = phraseInfo.getEndSubscript();
  292.                                         char tempc;
  293.                                         for (int j = start; j <= end; j++) {
  294.                                             tempc = in.charAt(j);
  295.                                             if ((tempc >= 65) && (tempc <= 90)) {
  296.                                                 tempc += 32;
  297.                                             }
  298.                                             phrase.append(tempc);
  299.                                         }
  300.                                         if (weightFactor == 1) {
  301.                                             if (phraseMap.containsKey(phrase.toString())) {
  302.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 10L);
  303.                                             } else {
  304.                                                 phraseMap.put(phrase.toString(), 10L);
  305.                                             }
  306.                                         } else {
  307.                                             if (phraseMap.containsKey(phrase.toString())) {
  308.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  309.                                             } else {
  310.                                                 phraseMap.put(phrase.toString(), 1L);
  311.                                             }
  312.                                         }
  313.                                     }
  314.                                     state = 0;
  315.                                 }
  316.                                 break;
  317.                             }
  318.                         }
  319.                     }
  320.                     if (state == 4) {
  321.                         if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  322.                             StringBuilder phrase = new StringBuilder();
  323.                             int start = phraseInfo.getStartSubscript();
  324.                             int end = phraseInfo.getEndSubscript();
  325.                             char tempc;
  326.                             for (int j = start; j <= end; j++) {
  327.                                 tempc = in.charAt(j);
  328.                                 if ((tempc >= 65) && (tempc <= 90)) {
  329.                                     tempc += 32;
  330.                                 }
  331.                                 phrase.append(tempc);
  332.                             }
  333.                             if (weightFactor == 1) {
  334.                                 if (phraseMap.containsKey(phrase.toString())) {
  335.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 10L);
  336.                                 } else {
  337.                                     phraseMap.put(phrase.toString(), 10L);
  338.                                 }
  339.                             } else {
  340.                                 if (phraseMap.containsKey(phrase.toString())) {
  341.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  342.                                 } else {
  343.                                     phraseMap.put(phrase.toString(), 1L);
  344.                                 }
  345.                             }
  346.                         }
  347.                     }
  348.                 } else {
  349.                     if (in.contains("Abstract: ")) {
  350.                         wordsDeque.clear();
  351.                         int length = in.length();
  352.                         state = 0;
  353.                         for (int i = 10; i < length; i++) {
  354.                             temp = in.charAt(i);
  355.                             //大写字母转为小写字母
  356.                             if ((temp >= 65) && (temp <= 90)) {
  357.                                 temp += 32;
  358.                             }
  359.                             //自动机状态转移
  360.                             switch (state) {
  361.                                 case 0: {
  362.                                     if ((temp >= 97) && (temp <= 122)) {
  363.                                         startSubscript = i;
  364.                                         state = 1;
  365.                                     }
  366.                                     break;
  367.                                 }
  368.                                 case 1: {
  369.                                     if ((temp >= 97) && (temp <= 122)) {
  370.                                         state = 2;
  371.                                     } else {
  372.                                         wordsDeque.clear();
  373.                                         state = 0;
  374.                                     }
  375.                                     break;
  376.                                 }
  377.                                 case 2: {
  378.                                     if ((temp >= 97) && (temp <= 122)) {
  379.                                         state = 3;
  380.                                     } else {
  381.                                         wordsDeque.clear();
  382.                                         state = 0;
  383.                                     }
  384.                                     break;
  385.                                 }
  386.                                 case 3: {
  387.                                     if ((temp >= 97) && (temp <= 122)) {
  388.                                         endSubscript = i;
  389.                                         state = 4;
  390.                                     } else {
  391.                                         wordsDeque.clear();
  392.                                         state = 0;
  393.                                     }
  394.                                     break;
  395.                                 }
  396.                                 case 4: {
  397.                                     if (((temp >= 97) && (temp <= 122)) || ((temp >= '0') && (temp <= '9'))) {
  398.                                         endSubscript = i;
  399.                                     } else {
  400.                                         if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  401.                                             StringBuilder phrase = new StringBuilder();
  402.                                             int start = phraseInfo.getStartSubscript();
  403.                                             int end = phraseInfo.getEndSubscript();
  404.                                             char tempc;
  405.                                             for (int j = start; j <= end; j++) {
  406.                                                 tempc = in.charAt(j);
  407.                                                 if ((tempc >= 65) && (tempc <= 90)) {
  408.                                                     tempc += 32;
  409.                                                 }
  410.                                                 phrase.append(tempc);
  411.                                             }
  412.                                             if (phraseMap.containsKey(phrase.toString())) {
  413.                                                 phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  414.                                             } else {
  415.                                                 phraseMap.put(phrase.toString(), 1L);
  416.                                             }
  417.                                         }
  418.                                         state = 0;
  419.                                     }
  420.                                     break;
  421.                                 }
  422.                             }
  423.                         }
  424.                         if (state == 4) {
  425.                             if (constructPhrase(startSubscript, endSubscript, phraseLength)) {
  426.                                 StringBuilder phrase = new StringBuilder();
  427.                                 int start = phraseInfo.getStartSubscript();
  428.                                 int end = phraseInfo.getEndSubscript();
  429.                                 char tempc;
  430.                                 for (int j = start; j <= end; j++) {
  431.                                     tempc = in.charAt(j);
  432.                                     if ((tempc >= 65) && (tempc <= 90)) {
  433.                                         tempc += 32;
  434.                                     }
  435.                                     phrase.append(tempc);
  436.                                 }
  437.                                 if (phraseMap.containsKey(phrase.toString())) {
  438.                                     phraseMap.put(phrase.toString(), phraseMap.get(phrase.toString()) + 1L);
  439.                                 } else {
  440.                                     phraseMap.put(phrase.toString(), 1L);
  441.                                 }
  442.                             }
  443.                         }
  444.                     }
  445.                 }
  446.             }
  447.         } catch (IOException e) {
  448.             e.printStackTrace();
  449.         } finally {
  450.             try {
  451.                 inputStreamReader.close();
  452.             } catch (IOException e) {
  453.                 e.printStackTrace();
  454.             }
  455.         }
  456.         return phraseMap;
  457.     }

对于词组词频统计部分，我们一开始的想法是通过双重循环，对每个单词都去判断是否能以其为首组成词组。维护一个词组的字符串，当符合长度时便存入Map。这种做法虽然简单，但加上中间操作后的时间消耗比较大。所以经过试验，对其进行了改进，改为记录首尾下标，这样减少时间消耗，也能保存下单词间的分隔符。

单元测试

单元测试框架用的是JUnit4。

我总共设计了十二个单元测试，其中Main一个，三个字词计数部分各三个，单词词频计数部分一个，词组词频计数部分一个。

单元测试 测试项 被测试代码
CharCounterTest 分别测试普通字符、无标题无摘要和空格 CharCounter.java
WordCounterTest 分别测试普通单词、无标题无摘要和大小写单词 WordCounter.java
LineCounterTest 分别测试普通行、无标题无摘要和混合行 LineCounter.java
WordFrequencyCounterTest 测试混合单词 WordFrequencyCounter.java
PhraseFrequencyCounterTest 测试混合词组 PhraseFrequencyCounter.java
MainTest 测试空白文件 Main.java

部分测试代码

  1. import com.eventide.wordCount.dataprocess.service.WordCounter;
  2. import org.junit.Test;
  4. import static org.junit.Assert.assertEquals;
  6. public class WordCounterTest {
  7.     @Test
  8.     //测试正常单词
  9.     public void wordCounterTest1() {
  10.         long wordNum = WordCounter.countWord("normalWordTest.txt");
  11.         assertEquals(3, wordNum);
  12.     }
  14.     @Test
  15.     //测试无标题无摘要单词
  16.     public void wordCounterTest2() {
  17.         long wordNum = WordCounter.countWord("noTitleAbstractWordTest.txt");
  18.         assertEquals(0, wordNum);
  19.     }
  21.     @Test
  22.     //测试单词大小写
  23.     public void wordCounterTest3() {
  24.         long wordNum = WordCounter.countWord("upLowWordTest.txt");
  25.         assertEquals(4, wordNum);
  26.     }
  27. }

GitHub签入记录



遇到的困难

对于词组词频统计部分，我们总共尝试了三种方法。

一种是上文提到的，通过双重循环，对每个单词都去判断是否能以其为首组成词组。维护一个词组的字符串，当符合长度时便存入Map。这种做法虽然简单，但加上中间操作后的时间消耗比较大。

第二种是维护一个队列，每当有合法单词出现时就压入队列中。如果队列长度符合要求，就取出队列中保存的单词，拼接成词组，压入Map。这种方法虽然简单快捷，但在看到群里说到，不同分隔符算不同词组时就凉了。。如果要记入分隔符就需要将分隔符一起存下来。虽然可以将合法单词和其后的分隔符一起保存，但这种方法在实现上存在一些困难，在拼接成词组时还要对单词进行二次处理，因此我们觉得并不是合适的处理方式。

经过试验，我们使用了记录首尾下标的方式。创建一个JavaBean存下每个合法单词的首尾下标，通过下标组成队列，进而拼装出词组。这样做效率不错，处理过程也不复杂，因此我们认为是较为合适的方法。

我们还遇到了一个重大困难，就是国庆假期前两个人接连感冒发烧（都怪优秀的舍友），一直到现在也还没完全好。。我想解决方法，应该只有穿越时空解决掉舍友了吧。（肥宅怎么可能去锻炼身体.jpg

评价队友

值得学习的地方：

我的队友思维缜密,写的文档逻辑清晰条理分明；coding能力强，代码写的认真规范；认真负责，执行能力强，对时间的把控能力很好，所以不仅能按时完成任务，而且完成度很高。

需要改进的地方：

没有，吹爆我队友٩̋(ˊ•͈ ꇴ •͈ˋ)و

学习进度条

  代码行数（新增/累积）/行 学习时间（新增/累积）/h 重要成长
目标
第四周 100 7
第五周 200 12

参考链接

Java 容器源码分析之 Deque 与 ArrayDeque

commons-cli使用介绍

软工实践第五次作业-WordCount进阶需求的更多相关文章

  1. 《软件工程实践》第五次作业-WordCount进阶需求 （结对第二次）

    在文章开头给出结对同学的博客链接.本作业博客的链接.你所Fork的同名仓库的Github项目地址 本作业博客链接 github pair c 031602136魏璐炜博客 031602139徐明盛博客 ...

  2. 《软工实践》第零次作业 - 一些QA

    <软工实践>第零次作业 - 一些QA Q&A (1)回想一下你初入大学时对计算机专业的畅想 当初你是如何做出选择计算机专业的决定的? 你认为过去两年中接触到的课程是否符合你对计算机 ...

  3. 福州大学2020年春软工实践W班第一次作业

    作业描述 这个作业属于哪个课程 福州大学2020年春软工实践W班 这个作业要求在哪里 寒假作业(1/2) 这个作业的目标 建立博客.回顾,我的初心.当下和未来.学习路线 作业正文 福州大学2020年春 ...

  4. 结队第二次作业——WordCount进阶需求

    结队第二次作业--WordCount进阶需求 博客地址 051601135 岳冠宇 博客地址 051604103 陈思孝 博客地址 Github地址 具体分工 队友实现了爬虫功能,我实现了wordco ...

  5. 软工实践 - 第三十次作业 Beta答辩总结

    福大软工 · 第十二次作业 - Beta答辩总结 组长本次博客作业链接 项目宣传视频链接 本组成员 1 . 队长:白晨曦 031602101 2 . 队员:蔡子阳 031602102 3 . 队员:陈 ...

  6. 结对第2次作业——WordCount进阶需求

    作业题目链接 队友链接 Fork的同名仓库的Github项目地址 具体分工 玮哥负责命令参数判断.单词权重统计,我只负责词组词频统计(emmmm). PSP表格 预估耗时(分钟) 实际耗时(分钟) P ...

  7. 软工实践 - 第二十一次作业 BETA 版冲刺前准备

    软工 · BETA 版冲刺前准备(团队) 过去存在的问题 组员之间缺乏沟通,前后端缺乏沟通协作 组员积极性不高 基础知识不够扎实 手动整合代码效率过低 我们已经做了哪些调整/改进 通过会议加强组员之间 ...

  8. 2015级软工实践k班第一次作业-准备

    第一次作业-准备······ 几篇文章阅读下来发现一个事实,还是要有明确的目标,清楚自己需要做什么最为重要.然后根据目标确定需要为之所做的准备工作,考研也好,工作也罢,都是服务于自己的目标. 问题答应 ...

  9. 软工实践 - 第十一次作业 Alpha 冲刺 （3/10）

    队名:起床一起肝活队 组长博客:https://www.cnblogs.com/dawnduck/p/9972061.html 作业博客:班级博客本次作业的链接 组员情况 组员1(队长):白晨曦 过去 ...

随机推荐

  1. 转载 - CNN感受野(receptive-fields)RF

    本文翻译自A guide to receptive field arithmetic for Convolutional Neural Networks(可能需要FQ才能访问),方便自己学习和参考.若 ...

  2. c# webbrowser控件内核版本强制修改

    int BrowserVer, RegVal; // get the installed IE version using (WebBrowser Wb = new WebBrowser()) Bro ...

  3. weblogic实时监控开发

    参考api文档 https://docs.oracle.com/cd/E13222_01/wls/docs90/wlsmbeanref/core/index.html https://docs.ora ...

  4. Windows10 + Visual Studio 2017 + CMake +OpenCV编译、开发环境配置及测试

    由于最近需要使用OpenCV,本人需要在自己的PC上使用OpenCV,因此最近一直在研究如何使用Visual Studio编译OpenCV源代码并搭建开发环境,折腾了很长时间,查阅了很多相关资料,终于 ...

  5. Spring的Aspect切面类不能拦截Controller中的方法

    根本原因在于<aop:aspectj-autoproxy />这句话是在spring的配置文件内,还是在springmvc的配置文件内.如果是在spring的配置文件内,则@Control ...

  6. Springboot分模块开发详解(1)：建立父工程

    基础服务,见下: base是父工程,base-entity是实体层,base-dao是DAO层,base-service是业务层,base-controller是WEB控制器层,base-web是页面 ...

  7. 配置vCenter Server Appliance 6.7

    =============================================== 2019/4/14_第1次修改                       ccb_warlock == ...

  8. Account的简单架构

    前几天,有园友私下问我,博客中的AccountDemo后端架构为什么是那样的,是不是分层太多太冗余,故这里简单介绍下.先看解决方案工程截图: 每个工程的含义,见https://www.cnblogs. ...

  9. mysql当查询某字段结果为空并赋值

    1 代码 1.1 当当前字段为空,查询结果返回“none”,并且统计出现频率 select case when 字段 is null then 'none' else 字段 end as 字段, co ...

  10. GBDT、XGBOOST、LightGBM调参数

    总的认识: LightGBM  > XGBOOST  > GBDT 都是调参数比较麻烦. GBDT分类的最佳调参数的讲解: Gradient Boosting Machine(GBM)调参 ...