WC项目反思与总结

Posted 2021-01-07 lu0526

1. 项目需求说明

WordCount的需求可以概括为：对程序设计语言源文件统计字符数、单词数、行数，统计结果以指定格式输出到默认文件中，以及其他扩展功能，并能够快速地处理多个文件。
可执行程序命名为：wc.exe，该程序处理用户需求的模式为：
wc.exe [parameter] [input_file_name]
存储统计结果的文件默认为result.txt，放在与wc.exe相同的目录下。

1. 1 基本功能：

wc.exe -c file.c //返回文件 file.c 的字符数wc.exe -w file.c //返回文件 file.c 的单词总数wc.exe -l file.c //返回文件 file.c 的总行数wc.exe -o outputFile.txt //将结果输出到指定文件outputFile.txt
注意：
空格，水平制表符，换行符，均算字符。
由空格或逗号分割开的都视为单词，且不做单词的有效性校验，例如：thi#,that视为用逗号隔开的2个单词。
-c, -w, -l参数可以共用同一个输入文件，形如：wc.exe –w –c file.c 。
-o 必须与文件名同时使用，且输出文件必须紧跟在-o参数后面，不允许单独使用-o参数。

举例：

wc.exe –c file.c，则输出结果保存在result.txt中，内容格式如下（注意大小写）：
file.c, 字符数: 50

wc.exe –w file.c，则输出结果保存在result.txt中，内容格式如下（注意大小写）：
file.c, 单词数: 30

wc.exe –l file.c，则输出结果保存在result.txt中，内容格式如下（注意大小写）：
file.c, 行数: 10

wc.exe –l –c file.c，则统计file.c中的字符数和行数，输出结果保存在result.txt中，内容格式如下：
file.c, 字符数: 50
file.c, 行数: 10

2. 编码过程

• Gitee项目

• PSP表格

PSP2.1	PSP阶段	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	10	1
· Estimate	· 估计这个任务需要多少时间	10	1
Development	开发	720	635
· Analysis	· 需求分析 (包括学习新技术)	10	5
· Design Spec	· 生成设计文档	30	40
· Design Review	· 设计复审 (和同事审核设计文档)	10	0
· Coding	· 代码规范 (为目前的开发制定合适的规范)	10	0
· Code Review	· 具体设计	10	5
· Test	· 具体编码	610	540
Reporting	· 代码复审	10	5
· Test Report	报告	30	40
· Size Measurement	· 测试报告	30	10
· Postmortem & Process	· 计算工作量	10	0
Improvement Plan	· 事后总结, 并提出过程改进计划	10	5
	合计	770	656

2. 1 解题思路

刚拿到题目时，我先看了题目需求，并列出主要要实现的功能：
1. 读取文件内容
2. 计算字符数
3. 计算单词数
4. 计算行数
5. 向文件写入内容
经过主要的功能分析后，我决定用我比较熟悉的java语言来完成这个题目。

其次，我分析了用java语言完成该题目主要需要运用的知识是：文件的IO流部分的知识。
于是我复习了我自己学习java IO字符流模块的知识和笔记，相关笔记如下：

/*
------------|   Reader    抽象类    输入字符流的基类
-----------------------|   FileReader    读取文件的输入字符流

FileReader的步骤：

    1. 找到目标文件
    2. 建立数据输入字符流通道
    3. 读取数据

*/

package cn.itcast.charstream;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class Demo1 {
       public static void main(String[] args) throws IOException {
             read1();
             read2();
       }
       public static void read1() throws IOException {
             File file = new File("E:/作业/Java/文件/b.txt");
             FileReader fileReader = new FileReader(file);
             int content = 0;
             while((content = fileReader.read()) != -1){//每次读一个字符
                    System.out.print((char)content);
             }
             fileReader.close();
       }
       public static void read2() throws IOException {
             File file = new File("E:/作业/Java/文件/b.txt");
             FileReader fileReader = new FileReader(file);
             //建立缓冲字符数组
             char[] buf = new char[1024];
             int length = 0;
             while((length = fileReader.read(buf)) != -1)
             {
                    System.out.println(new String(buf, 0, length));
             }
       }
}

/*
--------------|    Write    抽象类    输出字符流的基类
--------------------------|    FileWriter    向文件数据输出数据的输出字符流

FileWriter 的使用步骤：

    1. 找到目标文件
    2. 建立字符输出流通道
    3. 输出数据
    4. 关闭文件




注意：

    1. filewriter底层维护了一个1024的字符数组，写的数据先存在该数组中，当调用flush或close方法或填满了数组才会保存到硬盘上。
    2. new FileWriter(file);    如果目标文件不存在，会自动创建。
    3. new FileWriter(file);默认先清空数据。如果要直接添加数据，使用FileWriter（File，true）。

*/

package cn.itcast.charstream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Demo2 {
       public static void main(String[] args) throws IOException {
             write();
       }
       public static void write() throws IOException {
             File file = new File("E:/作业/Java/文件/b.txt");
             FileWriter fileWriter = new FileWriter(file);
             String data = "今天很开心";
             fileWriter.write(data);
             fileWriter.close();
       }
}

然后，我又思考发现，在计算单词数的时候，可以通过正则表达式来截取字符串的方式计算单词数量，
所有我又复习了正则表达式的相关用法，相关示例如下：

    范围词

            [abc]                        出现的只能是abc其中的一个
            [^abc]                      出现的只能是除了abc 的一个任意字符
            [a-z1-9&$]                    出现的只能是两头字母包括在内的字符（即：a~z  或1~9 或&或$）

2. 2 程序设计实现过程

在实际编码中，我使用了四个类，其类名和相关用途如下：
BaseCount：解析用户输入的命令行、调用JudgeOption类
相关方法：
wordCountMain（）

BaseFunc：实现计算字符数、单词书、行数这三个方法
相关方法：
count_charsNum(String path)
count_wordsNum(String path)
count_linesNum(String path)

JudgeOption：判断用户输入参数，调用BaseFunc中对应的相关方法
相关方法：
judge(String arg, String readPath, String writePath)

WriteCount：把计算后的结果写出到指定文件
相关方法：
writeCount(String str, String path)
initFile(String path)：如果写出的文件存在，将文件内容清空

2. 3 代码说明

public class BaseFunc {
    public static int count_charsNum(String path){
        int count = 0;
        try {
            FileReader fileReader = new FileReader(path);
            char[] buf = new char[1024];
            int length = 0;
            while( (length = fileReader.read(buf)) != -1){
                count += length;
            }
            fileReader.close();
        } catch (FileNotFoundException e) {
            System.out.println("");
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return count;
    }
    
    public static int count_wordsNum(String path) {
        int count = 0;
        
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
              while(br.read()!=-1) 
              {
               String s = br.readLine();
               
               for(int i=0; i<s.split("[^a-zA-Z]").length; i++){
                   
                   if( !s.split("[^a-zA-Z]")[i].isEmpty()){
                       count ++;
                   }
               }
               
               
              }
              br.close(); 
        }  catch (Exception e) {
            System.out.println(e);
        }
        
        
        return count;
        
    }
    public static int count_linesNum(String path) {
        int count = 0;
        
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
            while(br.read()!=-1) 
            {
                String s = br.readLine();
                
                count++;
            }
            br.close(); 
        }  catch (Exception e) {
            System.out.println(e);
        }
        
        
        return count;
        
    }
}

public class JudgeOption {
    public static void judge(String arg, String readPath, String writePath) {
        int count = 0;
        String str = "";
        
        switch (arg) {
        case "-c":
        case "—c":
            count = BaseFunc.count_charsNum(readPath);
            str = readPath.split("/")[ (readPath.split("/").length-1) ];
            str += ", 字符数：";
            str += count;
            WriteCount.writeCount(str, writePath);
            break;
            
        case "-w":
        case "—w":
            count = BaseFunc.count_wordsNum(readPath);
            str = readPath.split("/")[ (readPath.split("/").length-1) ];
            str += ", 单词数：";
            str += count;
            WriteCount.writeCount(str, writePath);
            break;
            
        case "-l":
        case "—l":
            count = BaseFunc.count_linesNum(readPath);
            str = readPath.split("/")[ (readPath.split("/").length-1) ];
            str += ", 行数：";
            str += count;
            WriteCount.writeCount(str, writePath);
            break;
            
        }
    }
}