软件工程 week 02

时间：2018-09-22 14:09:54 阅读：144 评论：0 收藏：0 [点我收藏+]

一、地址链接

　　1、作业地址：https://edu.cnblogs.com/campus/nenu/2016CS/homework/2110

　　2、git仓库地址：https://git.coding.net/kefei101/wf.git

二、需求分析

　　通过对题目要求的分析，我共看到了以下需求：

　　！判断输入格式，共有6种输入格式，分别进入4种不同的处理方法，得到不同的排序输出。其中(3)(4)可算作一种，(5)(6)可算作一种。

　　　　（1）wf -c 文件名进入直接读取txt方法，并顺序输出词频；　

　　　　（2）wf -f 文件路径进入读取文件夹的方法，再读取按照字典排序最靠前的txt文件，并按照字典排序输出单词词频；

　　　　（3）wf -c 文件名 -n 数量进入直接读取txt方法，并按照词频和字典排序输出；

　　（4）wf -n 数量 -c 文件名进入直接读取txt方法，并按照词频和字典排序输出；

　　（5）wf -f 文件路径 -n 数量进入读取文件夹的方法，再读取按照字典排序最靠前的txt文件，并按照词频和字典排序输出；

　　　　（6）wf -n 数量 -f 文件路径进入读取文件夹的方法，再读取按照字典排序最靠前的txt文件，并按照词频和字典排序输出.

三、功能设计

　　1、根据用户输入的参数格式，读取指向的文件或文件路径，统计得到txt文本文件的单词词频结果。

　　2、此处实现附加功能：在小程序中，可以任意输入多次，永久判断；输入格式中的首位单词 wf 即是保存该小程序的文件夹名，若将其放入不同的文件夹，只需将 wf 变为文件夹名即可。

　　注：为了避免中文乱码问题，我将注释及程序提示都改成英文显示。

四、设计实现

　　我共设计6个类，如图：

技术分享图片

　　Test类：主类，负责接收输入格式的参数启动程序；

　　Jagger类：负责根据输入格式的参数不同，分别进入不同的处理方法；

　　ReadTxt类：负责读取txt文本文件，以及读取文件路径；

　　SortMap类：负责根据需求的跟能不同，进入不同的排序方法；

　　Compare类：实现Comparator接口，实现功能(3)--(6)的排序方式（先按照词频排序，再按照字典排序）；

　　MyMap类：是SortMap类中功能三所需要用到的类，用自定义Map类实现list与Map转换的简单性。

　　5个类的相互关系为：

　　技术分享图片

　　比较重要的函数有：

　　　　Jagger类：JaggerFormat()：判断输入格式，主要是逻辑

　　　　ReadTxt类：txtToString()：读取txt文件，一行一行读取处理

　　　　　　directoryToTxt()：读取文件路径，选择按字典排序最靠前的txt文件，进而调用txtToString()读取txt文件内容

　　　　SortMap类：orderPrint()：顺序输出txt文件单词词频

　　　　　　sortMap(Map map)：按字典顺序输出txt文件单词词频

　　　　　　sortMap(Map map,int num)：先按词频排序，再按字典顺序排序

　　　　Compare类：compare()：实现Comparator接口，重写Compare方法，指定排序方法

　　函数间的逻辑关系：JaggerFormat()----[directoryToTxt()]----txtToString()----orderPrint()/sortMap(Map map)/[sortMap(Map map,int num)----compare()]

五、测试运行

　　1、输入正确的格式，即可运行功能一二三

　　2、测试测试txt

六、代码展示

　　1、主方法main()测试：

 1 import java.io.IOException;
 2 import java.util.*;
 3 
 4 /**
 5  * Class main
 6  * Author: houst
 7  * Date: 2018/9/17
 8  * Time: 15:50
 9  */
10 public class Test {
11 
12     /**
13      * Main Method
14      * @param args args
15      * @throws IOException
16      */
17     public static void main(String args[]) throws IOException {
18 
19         while (true) {
20             Scanner scanner = new Scanner(System.in);
21             String  order= scanner.nextLine();//Input format
22             //Judging the input format,entering different processing methods.
23             Jagger jagger = new Jagger();
24             jagger.JaggerFormat(order);
25 
26         }
27 
28     }
29 
30 }

Test

　　2、Jagger 类中 JaggerFormat()方法：判断输入格式

  1 import java.io.File;
  2 import java.util.ArrayList;
  3 import java.util.LinkedHashMap;
  4 import java.util.StringTokenizer;
  5 
  6 /**
  7  * Jagger Class
  8  * Author: houst
  9  * Date: 2018/9/20
 10  * Time: 20:15
 11  * Judging input
 12  */
 13 public class Jagger {
 14 
 15 
 16     /**
 17      * Judging the input format, entering different processing methods.
 18      * @param order order
 19      */
 20     public void JaggerFormat(String order){
 21 
 22         //Use stringTokenizer split input format string,deposit in list.
 23         StringTokenizer stringTokenizer = new StringTokenizer(order, " \n");
 24         ArrayList<String> list = new ArrayList<String>();
 25         while (stringTokenizer.hasMoreElements()) {
 26             list.add(stringTokenizer.nextToken());
 27         }
 28 
 29         //Judging whether the first word in the input format is the same as the item name.
 30         String project = System.getProperty("user.dir");
 31         project = project.substring(project.lastIndexOf(‘\\‘) + 1, project.length());
 32         if (!list.get(0).equals(project)) {
 33             System.out.println("Input format error, please input again!");
 34         } else {
 35 
 36             LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
 37             SortMap sortMap = new SortMap();
 38 
 39             //Function one or two
 40             if (list.size() == 3) {
 41 
 42                 String fileName = list.get(2);
 43                 File file = new File(fileName);//File name or folder name
 44                 String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);//Suffix name
 45 
 46                 //Function one: number of non repeated words in statistical documents
 47                 // Judging input format  -c  File name.txt
 48                 if (list.get(1).equals("-c") && suffix.equals("txt")) {
 49                     //Determine whether text files exist.
 50                     if (file.isFile() && file.exists()) {
 51                         //Read text file (.txt), statistics all word frequency, sequential output.
 52                         ReadTxt readTxt = new ReadTxt();
 53                         map = readTxt.txtToString(file);//Read txt and return to LinkedHashMap type.
 54                         sortMap.orderPrint(map);//order output
 55                     } else{
 56                         System.out.println("There is no such file!");
 57                     }
 58 
 59                     //Function two: Specify the file directory, count the number of words
 60                     //        that are not duplicated in the most advanced text file in the dictionary order.
 61                     // Judging input format   -f  file path
 62                 } else if (list.get(1).equals("-f") && !fileName.contains(".")) {
 63                     //Determine whether a folder exists.
 64                     if (file.isDirectory() && file.exists()) {
 65                         //Read the most prioritized text file (.txt) sorted by dictionary in the folder
 66                         // and count all word frequencies.
 67                         ReadTxt readTxt = new ReadTxt();
 68                         map = readTxt.directoryToTxt(file);
 69                         if(!map.isEmpty()){
 70                             sortMap.sortMap(map);//Word frequency sorting
 71                         }
 72                     } else System.out.println("No folder exists!");
 73                 } else {
 74                     System.out.println("Input format error, please input again!");
 75                 }
 76 
 77              //Function three or four
 78             } else if (list.size() == 5) {
 79 
 80                 String fileName = null;//File name or folder name
 81                 String num = null;//input n
 82                 String type = null;//input  -c or -f symbol
 83 
 84 
 85                 //Judging input format type：（-c file name.txt -n number） 或 （-f folder name -n number）
 86                 if ((list.get(1).equals("-c") && list.get(3).equals("-n")) || (list.get(1).equals("-f") && list.get(3).equals("-n") )) {
 87                     type = list.get(1);
 88                     fileName = list.get(2);
 89                     num = list.get(4);
 90                     //Judging input format type：（-n number -c file name.txt） 或 （ -n number -f folder name）
 91                 } else if ( (list.get(1).equals("-n")) && (list.get(3).equals("-c"))|| list.get(1).equals("-n") && (list.get(3).equals("-f") )) {
 92                     type = list.get(3);
 93                     fileName = list.get(4);
 94                     num = list.get(2);
 95                 }
 96 
 97                 int no = Integer.parseInt(num);//input num = no
 98 
 99                 String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);//get suffix name
100 
101                 File file = new File(fileName);
102                 //Function three: the most frequent occurrences of the first N words in statistical documents.
103                 //Judging input format   -c  file name.txt -n number
104                 if (type.equals("-c") && suffix.equals("txt") && num.matches("^[0-9]*$")) {
105                     //Judging whether text files exist.
106                     if (file.isFile() && file.exists()) {
107                         //Read txt and count the top n high-frequency words.
108                         ReadTxt readTxt = new ReadTxt();
109                         map = readTxt.txtToString(file);//Read txt and return to LinkedHashMap type.
110                         sortMap.sortMap(map,no);//Word frequency sorting with numbers.
111                     } else System.out.println("不存在此文件！");
112                     //Function 3: Specify the file catalog, count the first N words in the text file
113                     //      with the highest number of non-repetitions in the dictionary order.
114                     //  Judging input format  -f  File path  -n number
115                 } else if (type.equals("-f") && !fileName.contains(".") && num.matches("^[0-9]*$")) {
116                     //Judging whether a folder exists.
117                     if (file.isDirectory() && file.exists()) {
118                         //Read the file name in the folder sorted by dictionary first file (. txt),
119                         // and statistics the first n high-frequency words, sorting output
120                         ReadTxt readTxt = new ReadTxt();
121                         map = readTxt.directoryToTxt(file);//read folder
122                         if(!map.isEmpty()){
123                             sortMap.sortMap(map,no);//word frequency sorting with numbers
124                         }
125                     } else System.out.println("No folder exists!");
126                 } else {
127                     System.out.println("Input format error, please input again!");
128                 }
129 
130             }
131         }
132     }
133 }

JaggerFormat

　　3、ReadTxt类中 txtToString()：读取txt文件，一行一行读取处理

 1  /**
 2      * Read (.Txt) files with behavior units
 3      * @param file file
 4      * @return return
 5      * Return type：LinkedHashMap
 6      */
 7     public LinkedHashMap<String,Integer> txtToString(File file) {
 8 
 9         BufferedReader reader = null;
10         LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
11 
12         try {
13 
14             String string = null;
15             reader = new BufferedReader(new FileReader(file));
16 
17             //Read txt files from line to line
18             while ((string = reader.readLine()) != null) {
19 
20                 //Convert non alphanumeric symbols into spaces, case sensitive,
21                 // and intercept words by spaces.
22                 string = string.replaceAll("[^a-zA-Z0-9]", " ");
23                 string = string.toLowerCase();
24                 StringTokenizer stringTokenizer = new StringTokenizer(string, " ");
25 
26                 //Then use the LinkedHashMap to store words and word frequency.
27                 while (stringTokenizer.hasMoreTokens()) {
28 
29                     String word = stringTokenizer.nextToken();
30                     //Intercept the first letter of a word. Does a regular expression determine whether it is a number
31                     String first = word.substring(0, 1);
32                     if (!first.matches("[0-9]{1,}")) {
33                         //Statistical word frequency
34                         if (!map.containsKey(word)) {
35                             map.put(word, new Integer(1));
36                         } else {
37                             int newNum = map.get(word).intValue() + 1;
38                             map.put(word, new Integer(newNum));
39                         }
40                     }
41                 }
42             }
43             if(map.isEmpty()){
44                 System.out.println("The content of the text file (.txt) is empty.");
45             }
46         } catch (IOException e) {
47             e.printStackTrace();
48         }
49         return map;
50     }

txtToString

　　4、ReadTxt类中 directoryToTxt()：读取文件路径，选择按字典排序最靠前的txt文件，进而调用txtToString()读取txt文件内容

 1  /**
 2      * Find the most advanced text file in the folder according to the dictionary order (.txt).
 3      * @param file file
 4      * @return return
 5      */
 6     public LinkedHashMap<String,Integer> directoryToTxt(File file){
 7 
 8         ArrayList<String> list = new ArrayList<String>();
 9 //        //方法一  file.list()
10 //        String[] fileList = file.list();
11 //        for(int i=0;i<fileList.length;i++){
12 //            String fileName = file.getPath()+"\\"+fileList[i];
13 //            System.out.println("111"+fileName);
14 //            File mFile = new File(fileName);
15 //            String suffix = fileList[i].substring(fileList[i].lastIndexOf(".") + 1);
16 //            System.out.println("222"+suffix);
17 //            if(!mFile.isDirectory()&&suffix.equals("txt")){
18 //                System.out.println("333"+mFile.getPath());
19 //                list.add(mFile.getPath());
20 //            }
21 //        }
22         //方法二  file.listFiles()
23         //list folder
24         File[] fileList = file.listFiles();
25         for(int i=0;i<fileList.length;i++){
26             String fileName = fileList[i].getName();
27             String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);
28             //Is it a  .txt file to add txt files to list?
29             if(!fileList[i].isDirectory()&&suffix.equals("txt")){
30                 list.add(fileList[i].getAbsolutePath());
31             }
32         }
33         LinkedHashMap<String,Integer> map = new LinkedHashMap<String,Integer>();
34         if(!list.isEmpty()){
35             Collections.sort(list);
36             File finallyFile = new File(list.get(0));
37             map = txtToString(finallyFile);
38             return map;
39         }
40         else {
41             System.out.println("There is no txt file in this folder!");
42             return map;
43         }
44 
45     }

directoryToTxt

　　5、SortMap类中 orderPrint() : 顺序输出txt文件单词词频

 1 /**
 2      * Function one :output
 3      * txt file order
 4      * @param map map
 5      */
 6     public void orderPrint(HashMap map){
 7 
 8         //HashMap type data is converted to collection type, and map iterator is obtained.
 9         Iterator iterator = map.entrySet().iterator();
10         System.out.println("total    " + map.size());
11         System.out.println();
12         while(iterator.hasNext()){
13             //Instantiate the Map.Entry object, and then output the word frequency.
14             Map.Entry word = (Map.Entry) iterator.next();
15             System.out.printf("%-12s",word.getKey());
16             System.out.printf("%5d\n",word.getValue());
17 
18 
19         }
20         System.out.println();
21     }

orderPrint

　　6、SortMap类中 sortMap(Map map)：按字典顺序输出txt文件单词词频

 1  /**
 2      * Function two : output
 3      * txt files are sorted in dictionaries.
 4      * @param map map
 5      */
 6     public void sortMap(Map map){
 7 
 8         //Remove the words from map and put them in list.
 9         Collection<String> keys = map.keySet();
10         List<String> list = new ArrayList<String>(keys);
11         Collections.sort(list);
12 
13         //sort out output frequency by dictionaries
14         System.out.println("total " + list.size() + " words");
15         for(int i=0;i<list.size();i++){
16             System.out.printf("%-12s",list.get(i));
17             System.out.printf("%5d\n",map.get(list.get(i)));
18         }
19         System.out.println();
20     }

sortMap(Map map)

　　7、SortMap类中 sortMap(Map map,int num)：先按词频排序，再按字典顺序排序

 1     /**
 2      * Function three
 3      * txt file sorting
 4      * @param map map
 5      * @param num num
 6      */
 7     public void sortMap(Map map,int num){
 8 
 9         List<MyMap<String,Integer>> list = new ArrayList<MyMap<String,Integer>>();
10         //HashMap type data is converted to collection type, and map iterator is obtained.
11         Iterator iterator = map.keySet().iterator();
12         while (iterator.hasNext()){
13             //The words in the Map iterator are stored in list by using MyMap class.
14             MyMap<String,Integer> word = new MyMap<String,Integer>();
15             String key = (String) iterator.next();
16             word.setKey(key);
17             word.setValue((Integer) map.get(key));
18             list.add(word);
19         }
20         //sort
21         Collections.sort(list,new Compare());
22         //Output word frequency
23         System.out.println("Total words is " + list.size());
24         System.out.println("------------------");
25         //Output the specified top n word frequency.
26         for(int i=0;i<num;i++){
27             MyMap<String,Integer> word = list.get(i);
28             System.out.printf("%-12s",word.getKey());
29             System.out.printf("%5d\n",word.getValue());
30         }
31         System.out.println();
32     }

sortMap(Map map,int num)

　　8、Compare类中 compare()：实现Comparator接口，重写Compare方法，指定排序方法

 1  /**
 2      * override First compare word frequency, the same word frequency, and then follow the dictionary order.
 3      * @param o1 01
 4      * @param o2 02
 5      * @return return
 6      */
 7     public int compare(MyMap<String, Integer> o1, MyMap<String, Integer> o2) {
 8         if(o1.getValue().equals(o2.getValue())){
 9             return o1.getKey().compareTo(o2.getKey());
10         }else{
11             return o2.getValue()-o1.getValue();
12         }
13     }

compare

七、PSP

sp2.1	任务内容	计划共完成需要时间（h）	实际完成需要的时间(h)
Planing	计划	36	58
Estimate	估计这个任务需要多少时间，并规划大致工作步骤	36	58
Development	开发	31	51
Analysis	需求分	5	8
Design Spec	生成设计文档	0	0
Design Review	设计复审(和同事审核设计文档)	0	0
Coding Standard	代码规范()为目前的开发制定合适的规范	0	0
Design	具体设计	5	8
Coding	具体编码	15	20
Code Review	代码复审	2	5
Test	测试(自我测试，修改代码，提交修改)	4	10
Reporting	报告	5	7
Test Report	测试报告	3	5
Size Measurement Postmortem & Process Improvement Plan	计算工作量,事后总结，并提出过程改进计划	2	2

八、总结

　　这次项目说实在，说简单也不简单，说难也不难，原本以为一两天就可以搞定，实际上花了整整4天时间做这个小程序。其实做这个项目我并没有完整按照构造之法的软件开发步骤去做。但在看到这个作业的时候，我会先看有什么要求，想了很多怎么分类，怎么构造方法，怎么让它们联系起来。所以我是在前期花了快8个小时的构思。接着我便开始上手敲代码，先从本类开始，判断输入格式。根据输入格式的不同，我先写直接处理txt文件的方法，把第一个功能实现，慢慢的再把第二个功能实现，一步步做下去。期间因为看着作业的布置，有些细节的地方没有注意到，导致到后面代码是改了又改，写了又写，深刻体会到程序员的痛苦（一旦用户的需求改变，就会内心奔腾吧）。

　　通过做这次作业，我其实感触挺大的。在之前，我一直认为，啊，我待在工作室里做了几个小项目，挺厉害的，这次作业那么简单，我肯定一两天就写完了。但其实我在做作业写代码的时间要比其他人多得多。不得不说，在实力上，我受到了一定的打击。其实我不比别人好多少，甚至别人会比我更加努力，更加厉害。

　　在做这个作业的时候，我其实是想实现更多的功能的，以此证明自己，也就想着慢慢写，每天写一点，总能写完，一定要细心，把作业完美的展现出来。这种想法是不对的。看我在截至时间最后一秒交作业就知道了，效率会很低下，没有紧凑感，又怎么能锻炼自己写代码的能力呢？现在这种小程序还好说，不会有什么损失。如果是以后到了公司，让你写个app,写个系统啥的，你也能保证最后交给甲方的是最完美的？所以，我要改变我的看法了，写代码这种事，是不能拖拉的。我们应该在有限的时间内写出高效代码。

　　最后，我想说，虽然做作业拖拉了，但总体还是比较完美的，自己花了4天写完的统计词频小程序，也让我感受到投入做一件事，努力让它变得完美，专注，钻研，这种感觉很好。同时，也让我意识到自己的实力水平远比想象中的低。我也是时候好好提升自学、写代码的能力了，勿好高骛远，踏踏实实走好每一步，加油！

软件工程 week 02

原文：https://www.cnblogs.com/houst388/p/9689054.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)