一、地址链接
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()测试：
import java.io.IOException;
import java.util.*; /**
* Class main
* Author: houst
* Date: 2018/9/17
* Time: 15:50
*/
public class Test { /**
* Main Method
* @param args args
* @throws IOException
*/
public static void main(String args[]) throws IOException { while (true) {
Scanner scanner = new Scanner(System.in);
String order= scanner.nextLine();//Input format
//Judging the input format,entering different processing methods.
Jagger jagger = new Jagger();
jagger.JaggerFormat(order); } } }
Test
2、Jagger 类中 JaggerFormat()方法：判断输入格式
import java.io.File;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.StringTokenizer; /**
* Jagger Class
* Author: houst
* Date: 2018/9/20
* Time: 20:15
* Judging input
*/
public class Jagger { /**
* Judging the input format, entering different processing methods.
* @param order order
*/
public void JaggerFormat(String order){ //Use stringTokenizer split input format string,deposit in list.
StringTokenizer stringTokenizer = new StringTokenizer(order, " \n");
ArrayList<String> list = new ArrayList<String>();
while (stringTokenizer.hasMoreElements()) {
list.add(stringTokenizer.nextToken());
} //Judging whether the first word in the input format is the same as the item name.
String project = System.getProperty("user.dir");
project = project.substring(project.lastIndexOf('\\') + 1, project.length());
if (!list.get(0).equals(project)) {
System.out.println("Input format error, please input again!");
} else { LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
SortMap sortMap = new SortMap(); //Function one or two
if (list.size() == 3) { String fileName = list.get(2);
File file = new File(fileName);//File name or folder name
String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);//Suffix name //Function one: number of non repeated words in statistical documents
// Judging input format -c File name.txt
if (list.get(1).equals("-c") && suffix.equals("txt")) {
//Determine whether text files exist.
if (file.isFile() && file.exists()) {
//Read text file (.txt), statistics all word frequency, sequential output.
ReadTxt readTxt = new ReadTxt();
map = readTxt.txtToString(file);//Read txt and return to LinkedHashMap type.
sortMap.orderPrint(map);//order output
} else{
System.out.println("There is no such file!");
} //Function two: Specify the file directory, count the number of words
// that are not duplicated in the most advanced text file in the dictionary order.
// Judging input format -f file path
} else if (list.get(1).equals("-f") && !fileName.contains(".")) {
//Determine whether a folder exists.
if (file.isDirectory() && file.exists()) {
//Read the most prioritized text file (.txt) sorted by dictionary in the folder
// and count all word frequencies.
ReadTxt readTxt = new ReadTxt();
map = readTxt.directoryToTxt(file);
if(!map.isEmpty()){
sortMap.sortMap(map);//Word frequency sorting
}
} else System.out.println("No folder exists!");
} else {
System.out.println("Input format error, please input again!");
} //Function three or four
} else if (list.size() == 5) { String fileName = null;//File name or folder name
String num = null;//input n
String type = null;//input -c or -f symbol //Judging input format type：（-c file name.txt -n number） 或 （-f folder name -n number）
if ((list.get(1).equals("-c") && list.get(3).equals("-n")) || (list.get(1).equals("-f") && list.get(3).equals("-n") )) {
type = list.get(1);
fileName = list.get(2);
num = list.get(4);
//Judging input format type：（-n number -c file name.txt） 或 （ -n number -f folder name）
} else if ( (list.get(1).equals("-n")) && (list.get(3).equals("-c"))|| list.get(1).equals("-n") && (list.get(3).equals("-f") )) {
type = list.get(3);
fileName = list.get(4);
num = list.get(2);
} int no = Integer.parseInt(num);//input num = no String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);//get suffix name File file = new File(fileName);
//Function three: the most frequent occurrences of the first N words in statistical documents.
//Judging input format -c file name.txt -n number
if (type.equals("-c") && suffix.equals("txt") && num.matches("^[0-9]*$")) {
//Judging whether text files exist.
if (file.isFile() && file.exists()) {
//Read txt and count the top n high-frequency words.
ReadTxt readTxt = new ReadTxt();
map = readTxt.txtToString(file);//Read txt and return to LinkedHashMap type.
sortMap.sortMap(map,no);//Word frequency sorting with numbers.
} else System.out.println("不存在此文件！");
//Function 3: Specify the file catalog, count the first N words in the text file
// with the highest number of non-repetitions in the dictionary order.
// Judging input format -f File path -n number
} else if (type.equals("-f") && !fileName.contains(".") && num.matches("^[0-9]*$")) {
//Judging whether a folder exists.
if (file.isDirectory() && file.exists()) {
//Read the file name in the folder sorted by dictionary first file (. txt),
// and statistics the first n high-frequency words, sorting output
ReadTxt readTxt = new ReadTxt();
map = readTxt.directoryToTxt(file);//read folder
if(!map.isEmpty()){
sortMap.sortMap(map,no);//word frequency sorting with numbers
}
} else System.out.println("No folder exists!");
} else {
System.out.println("Input format error, please input again!");
} }
}
}
}
JaggerFormat
这个方法逻辑需要很清晰，每一步怎么走，会有什么结果，想了很久，也是在这里比较多bug，调试的时间大概是4小时。
3、ReadTxt类中 txtToString()：读取txt文件，一行一行读取处理
/**
* Read (.Txt) files with behavior units
* @param file file
* @return return
* Return type：LinkedHashMap
*/
public LinkedHashMap<String,Integer> txtToString(File file) { BufferedReader reader = null;
LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>(); try { String string = null;
reader = new BufferedReader(new FileReader(file)); //Read txt files from line to line
while ((string = reader.readLine()) != null) { //Convert non alphanumeric symbols into spaces, case sensitive,
// and intercept words by spaces.
string = string.replaceAll("[^a-zA-Z0-9]", " ");
string = string.toLowerCase();
StringTokenizer stringTokenizer = new StringTokenizer(string, " "); //Then use the LinkedHashMap to store words and word frequency.
while (stringTokenizer.hasMoreTokens()) { String word = stringTokenizer.nextToken();
//Intercept the first letter of a word. Does a regular expression determine whether it is a number
String first = word.substring(0, 1);
if (!first.matches("[0-9]{1,}")) {
//Statistical word frequency
if (!map.containsKey(word)) {
map.put(word, new Integer(1));
} else {
int newNum = map.get(word).intValue() + 1;
map.put(word, new Integer(newNum));
}
}
}
}
if(map.isEmpty()){
System.out.println("The content of the text file (.txt) is empty.");
}
} catch (IOException e) {
e.printStackTrace();
}
return map;
}
txtToString
功能一的难点，也是后续功能二、功能三、功能四的重中之重，在这里大概花了2小时。
4、ReadTxt类中 directoryToTxt()：读取文件路径，选择按字典排序最靠前的txt文件，进而调用txtToString()读取txt文件内容
/**
* Find the most advanced text file in the folder according to the dictionary order (.txt).
* @param file file
* @return return
*/
public LinkedHashMap<String,Integer> directoryToTxt(File file){ ArrayList<String> list = new ArrayList<String>();
// //方法一 file.list()
// String[] fileList = file.list();
// for(int i=0;i<fileList.length;i++){
// String fileName = file.getPath()+"\\"+fileList[i];
// System.out.println("111"+fileName);
// File mFile = new File(fileName);
// String suffix = fileList[i].substring(fileList[i].lastIndexOf(".") + 1);
// System.out.println("222"+suffix);
// if(!mFile.isDirectory()&&suffix.equals("txt")){
// System.out.println("333"+mFile.getPath());
// list.add(mFile.getPath());
// }
// }
//方法二 file.listFiles()
//list folder
File[] fileList = file.listFiles();
for(int i=0;i<fileList.length;i++){
String fileName = fileList[i].getName();
String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);
//Is it a .txt file to add txt files to list?
if(!fileList[i].isDirectory()&&suffix.equals("txt")){
list.add(fileList[i].getAbsolutePath());
}
}
LinkedHashMap<String,Integer> map = new LinkedHashMap<String,Integer>();
if(!list.isEmpty()){
Collections.sort(list);
File finallyFile = new File(list.get(0));
map = txtToString(finallyFile);
return map;
}
else {
System.out.println("There is no txt file in this folder!");
return map;
} }
directoryToTxt
功能二功能四的难点，要先读取文件路径，再进行后续操作，在这里大概花了1小时。
5、SortMap类中 orderPrint() : 顺序输出txt文件单词词频
/**
* Function one :output
* txt file order
* @param map map
*/
public void orderPrint(HashMap map){ //HashMap type data is converted to collection type, and map iterator is obtained.
Iterator iterator = map.entrySet().iterator();
System.out.println("total " + map.size());
System.out.println();
while(iterator.hasNext()){
//Instantiate the Map.Entry object, and then output the word frequency.
Map.Entry word = (Map.Entry) iterator.next();
System.out.printf("%-12s",word.getKey());
System.out.printf("%5d\n",word.getValue()); }
System.out.println();
}
orderPrint
6、SortMap类中 sortMap(Map map)：按字典顺序输出txt文件单词词频
/**
* Function two : output
* txt files are sorted in dictionaries.
* @param map map
*/
public void sortMap(Map map){ //Remove the words from map and put them in list.
Collection<String> keys = map.keySet();
List<String> list = new ArrayList<String>(keys);
Collections.sort(list); //sort out output frequency by dictionaries
System.out.println("total " + list.size() + " words");
for(int i=0;i<list.size();i++){
System.out.printf("%-12s",list.get(i));
System.out.printf("%5d\n",map.get(list.get(i)));
}
System.out.println();
}
sortMap(Map map)
7、SortMap类中 sortMap(Map map,int num)：先按词频排序，再按字典顺序排序
/**
* Function three
* txt file sorting
* @param map map
* @param num num
*/
public void sortMap(Map map,int num){ List<MyMap<String,Integer>> list = new ArrayList<MyMap<String,Integer>>();
//HashMap type data is converted to collection type, and map iterator is obtained.
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()){
//The words in the Map iterator are stored in list by using MyMap class.
MyMap<String,Integer> word = new MyMap<String,Integer>();
String key = (String) iterator.next();
word.setKey(key);
word.setValue((Integer) map.get(key));
list.add(word);
}
//sort
Collections.sort(list,new Compare());
//Output word frequency
System.out.println("Total words is " + list.size());
System.out.println("------------------");
//Output the specified top n word frequency.
for(int i=0;i<num;i++){
MyMap<String,Integer> word = list.get(i);
System.out.printf("%-12s",word.getKey());
System.out.printf("%5d\n",word.getValue());
}
System.out.println();
}
sortMap(Map map,int num)
这三类排序方法对应功能一、功能二、功能三四的排序方法，难点在sortMap(Map map,int num) 。共花了最多时间，一直再改改改，大概15个小时，因为是几天的时间。
8、Compare类中 compare()：实现Comparator接口，重写Compare方法，指定排序方法
/**
* override First compare word frequency, the same word frequency, and then follow the dictionary order.
* @param o1 01
* @param o2 02
* @return return
*/
public int compare(MyMap<String, Integer> o1, MyMap<String, Integer> o2) {
if(o1.getValue().equals(o2.getValue())){
return o1.getKey().compareTo(o2.getKey());
}else{
return o2.getValue()-o1.getValue();
}
}
compare
找资料，基本上我需要用什么就去查什么，学会百度关键词也是很重要的，这也是历届学长学姐教我的。在找资料的过程中，去搜寻别人写过的博客，看他们的代码，有涉及到的函数都要去搜索，看看它们的原理是什么，看懂以后，再自己敲一遍，印象深刻+。这也是我为什么写作业这么慢的一个原因吧......
七、PSP
| sp2.1 | 任务内容 | 计划共完成需要时间（min） | 实际完成需要的时间(min) |
| Planing | 计划 | 2160 | 4080 |
| Estimate | 估计这个任务需要多少时间，并规划大致工作步骤 | 2160 | 3480 |
| Development | 开发 | 1860 | 3660 |
| Analysis | 需求分析 | 300 | 480 |
| Design Spec | 生成设计文档 | 0 | 0 |
| Design Review | 设计复审(和同事审核设计文档) | 0 | 0 |
| Coding Standard | 代码规范()为目前的开发制定合适的规范 | 0 | 0 |
| Design | 具体设计 | 300 | 480 |
| Coding | 具体编码 | 900 | 1200 |
| Code Review | 代码复审 | 120 | 300 |
| Test | 测试(自我测试，修改代码，提交修改) | 240 | 1200 |
| Reporting | 报告 | 300 | 420 |
| Test Report | 测试报告 | 180 | 300 |
Size Measurement Postmortem & Process Improvement Plan | 计算工作量,事后总结，并提出过程改进计划 | 120 | 120 |
| 功能模块 | 具体阶段 | 预计时间(min) | 实际时间(min) |
| 功能一 | 具体设计 具体编码 测试完善 | 30 120 150 | 80 150 400 |
| 功能二 | 具体设计 具体编码 测试完善 | 120 200 300 | 180 450 500 |
| 功能三 | 具体设计 具体编码 测试完善 | 150 200 290 | 220 600 600 |
以上只是我大概估计，因为是好几天才做出来的，难免有些不准确，但通过上面两个表格对比，能够看出，我的写代码能力真的是...... 效率太低下啦！这样子的人，有哪个公司敢要呀？即使是期间夹杂着自学，理解函数的时间，也不应该花这么多时间做作业呀。再次证明，缺实践！！！
八、总结
这次项目说实在，说简单也不简单，说难也不难，原本以为一两天就可以搞定，实际上花了整整4天时间做这个小程序。其实做这个项目我并没有完整按照构造之法的软件开发步骤去做。但在看到这个作业的时候，我会先看有什么要求，想了很多怎么分类，怎么构造方法，怎么让它们联系起来。所以我是在前期花了快8个小时的构思。接着我便开始上手敲代码，先从本类开始，判断输入格式。根据输入格式的不同，我先写直接处理txt文件的方法，把第一个功能实现，慢慢的再把第二个功能实现，一步步做下去。期间因为看着作业的布置，有些细节的地方没有注意到，导致到后面代码是改了又改，写了又写，深刻体会到程序员的痛苦（一旦用户的需求改变，就会内心奔腾吧）。
通过做这次作业，我其实感触挺大的。在之前，我一直认为，啊，我待在工作室里做了几个小项目，挺厉害的，这次作业那么简单，我肯定一两天就写完了。但其实我在做作业写代码的时间要比其他人多得多。不得不说，在实力上，我受到了一定的打击。其实我不比别人好多少，甚至别人会比我更加努力，更加厉害。
在做这个作业的时候，我其实是想实现更多的功能的，以此证明自己，也就想着慢慢写，每天写一点，总能写完，一定要细心，把作业完美的展现出来。这种想法是不对的。看我在截至时间最后一秒交作业就知道了，效率会很低下，没有紧凑感，又怎么能锻炼自己写代码的能力呢？现在这种小程序还好说，不会有什么损失。如果是以后到了公司，让你写个app,写个系统啥的，你也能保证最后交给甲方的是最完美的？所以，我要改变我的看法了，写代码这种事，是不能拖拉的。我们应该在有限的时间内写出高效代码。
最后，我想说，虽然做作业拖拉了，但总体还是比较完美的，自己花了4天写完的统计词频小程序，也让我感受到投入做一件事，努力让它变得完美，专注，钻研，这种感觉很好。同时，也让我意识到自己的实力水平远比想象中的低。我也是时候好好提升自学、写代码的能力了，勿好高骛远，踏踏实实走好每一步，加油！