第二周个人作业WordCount

第二周个人作业WordCount

Github地址：

https://github.com/zhao-123456/WC

PSP2.1表格

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

解题思路

拿到题目后，老师推荐语言是java，所以我又去重新学习了一遍。分析一下题目，基本功能是要实现对指定文件的字符数，单词数，行数的统计以及将输出结果放入指定文件中。我第一反应是对文件一行一行进行读入，进而统计字符数，单词数，行数。而对于扩展功能，递归处理目录下符合条件的文件，则可从输入中获取文件名的后缀，再遍历该路径下所有文件找到符合后缀的文件名，进行操作。返回更复杂的数据（代码行 / 空行 / 注释行）则可使用正则表达式。对于停用词表的想法就是先获取表中单词，将其放入列表中，在进行逐行读取单词时判断其是否在该列表中，若不在，单词数加一。至于对高级功能，因为时间有限，尚未考虑。

程序设计实现过程

由wordcount.java和main.java两个java文件构成 。

wordcount.java主要实现统计的方法，包含count()函数，根据输入参数来获取flag的值进而选择不同的方法。basiccount()函数用来统计文件基本的字符数，单词数，行数。complexcount()函数则是通过正则式来判断代码行 / 空行 / 注释行并进行统计。

而main.java主要实现对文件的读取，获取参数，对停用词表的操作。包含getparameters()函数，它完成对输入参数的获取识别，并进行合理划分。ListFile(),Liststop()则完成对文件的存放和对停用词表中单词的存放。

代码说明

wordcount.java中的count函数可以属于控制函数，根据参数来获取flag的值进而选择不同的方法。

      public void count(Vector<String> parameters)throws IOException{
         for(int i=0;i<source.size();i++){ 
             if(parameters.contains("-c")){
                 flag=1;                   //对每种参数进行标记
                 basiccount(source.get(i));
             }
             if(parameters.contains("-w")){
                 flag=2;
                 basiccount(source.get(i));
             }
             if(parameters.contains("-l")){
                 flag=3;
                 basiccount(source.get(i));
             }
             if(parameters.contains("-a")){
                 complexcount(source.get(i));
             }
         }
      }

basiccount()函数使用统计字符数，单词数，行数。

public static void basiccount(File name)throws IOException{ 
          int charnum=0;
          int wordnum=0;
          int linenum=0;
          try{
          InputStreamReader reader=new InputStreamReader(new FileInputStream(name)) ;
          BufferedReader br=new BufferedReader(reader);
          while(br.read()!=-1){
              String s=br.readLine();         //按行读取
              charnum=s.length()+charnum+1;
              String list[]=s.split(" |,");
              //wordnum+=list.length;
              for(int i=0;i<list.length;i++){
                  if(lists.isEmpty()){
                      if(!Pattern.matches("\\s*",list[i])){  //停用词表为空
                          wordnum++;
                      }
                  }
                  
                  else {
                      if(!lists.contains(list[i])&&!Pattern.matches("\\s*",list[i])){ //停用词表不为空
                            wordnum++;
                        }
                  }
                 
              }
              linenum++;
          }
          reader.close();
          }catch (Exception e){
              e.printStackTrace();
          }
          switch(flag){
              case 1:
                  String result=name.getName()+",字符数："+charnum+"\r\n";
                  output.write(result.getBytes());
                  System.out.println(result);
                  break;
              case 2:
                  String result1=name.getName()+",单词数："+wordnum+"\r\n";
                  output.write(result1.getBytes());
                  System.out.println(result1);
                  break;
              case 3:
                  String result2=name.getName()+",行数："+linenum+"\r\n";
                  output.write(result2.getBytes());
                  System.out.println(result2);
                  break;
          }
      }
}

complexcount()函数则是通过正则式来判断代码行 / 空行 / 注释行。

 public static void complexcount(File name)throws IOException{  
          int codeline=0;
          int nullline=0;
          int annotationline=0;
          try{
              InputStreamReader reader=new InputStreamReader(new FileInputStream(name)) ;
              BufferedReader br=new BufferedReader(reader);
              boolean comment = false; 
              Pattern annotationLinePattern = Pattern.compile("((//)|(/\\*+)|((^\\s)*\\*)|((^\\s)*\\*+/))+",   
                      Pattern.MULTILINE + Pattern.DOTALL);    // 注释匹配器(匹配单行、多行、文档注释)  
              Pattern nullLinePattern = Pattern.compile("^\\s*$");   // 空白行匹配器（匹配回车、tab键、空格）  
              
              Pattern codeLinePattern = Pattern.compile("(?!import|package).+;\\s*(((//)|(/\\*+)).*)*",  
                      Pattern.MULTILINE + Pattern.DOTALL);// 代码行匹配器（以分号结束为一行有效语句,但不包括import和package语句）
             
              while(br.read()!=-1){
                  String s=br.readLine();
                  if(annotationLinePattern.matcher(s).find()){
                      annotationline++;
                  }
                  if(nullLinePattern.matcher(s).find()){
                      nullline++;
                  }
                  if(codeLinePattern.matcher(s).find()){
                      codeline++;
                  }
              }
              reader.close();  
          }catch (Exception e){
              e.printStackTrace();
          }
          String result=name.getName()+",代码行/空行/注释行:"+codeline+"/"+nullline+"/"+annotationline+"\r\n";
          output.write(result.getBytes());
          System.out.println(result);
      }

对于main.java，十分关键的是getparameters()函数，它完成对输入参数的获取识别，是指实现对应的功能。

 public static void getparameters(String[] args){
        outpath="result.txt";
        parameters=new Vector<String>();
        source=new Vector<File>();   //初始化，避免空指针错误
        lists=new Vector<String>();
        for(int i=0;i<args.length;i++){
            if(args[i].equals("-o")){   //判断“-o”后面是否跟有文件名
                if(i<args.length-1){
                    outpath=args[i+1]; 
                }
                else{
                     System.out.println("wrong");
                }
                    
            }
            else if(args[i].equals("-c")||args[i].equals("-w")||args[i].equals("-l")||args[i].equals("-a")){
                parameters.addElement(args[i]);   //将参数加入parameters容器中
            }
            else if(args[i].equals("-s")){
                for(int j=0;j<args.length;j++){
                    if(args[j].contains("*")){
                        String type=args[j].substring(args[j].indexOf("."));//获取文件的类型
                        ListFile(type);
                    }
                }
            }
            else if(args[i].equals("-e")){
                stopname=args[i+1];
                 try{
                     Liststop(stopname);
                     }
                 catch(Exception e){
                     e.printStackTrace();
                 }
            }
            else{
                source.addElement(new File(args[i]));
            }
        }              
    }

最后的ListFile(),Liststop()则完成对文件的存放和对停用词表中单词的存放。

  public static void Liststop(String stopname)throws IOException{
        File file=new File(stopname);
        InputStreamReader reader=new InputStreamReader(new FileInputStream(file));
        BufferedReader br=new BufferedReader(reader);
        while(br.read()!=-1){
            String s=br.readLine();
            String liststop[]=s.split(" ");
            for(int i=0;i<liststop.length;i++){
                lists.addElement(liststop[i]);
            }            
        }
        reader.close();
    }
    
    public static void ListFile(String type){
        File file=new File(nowpath);
        File[] files=file.listFiles();  //将当前路径下所有文件装入文件列表中
        if(files==null){
             System.out.println("null");
        }
        for(int i=0;i<files.length;i++){
            if(files[i].isFile()&&files[i].getName().endsWith(type)){//判断是否以特定类型结尾的文件
                source.addElement(files[i]);
            }
            else if (files[i].isDirectory()) {
                ListFile(type);//递归
            }
        }
    }
}

测试设计过程

这里都是通过控制台进行的测试

file1.c

!@#$%^&*()_+{}|"?><[]\;',./~`a

file2.c

import java.util.Vector;

public class wordcount {
      public static Vector<File> source;
      public static int flag;
      private File outfile;
      public static String outpath;
      private static OutputStream output;

/*ds
对方是否是
sfs*/     
      public wordcount(Vector<File> source,String outpath)throws IOException{
          this.source=source;
          this.outpath=outpath;
          this.outfile=new File(outpath);
          this.output=new FileOutputStream(outfile);
      }

file3.c

File write,name = new File(outputPath); 
            writename.createNe|wFile();
            Buffe,redWriter out = new BufferedWrit,er(new FileWriter(writename));
            out.close();

wc.exe -c -w -l *.c -o out.txt
wc.exe -s -a *.c
wc.exe -s -a –c -w *.c –e stop.txt –o output.txt

out.txt

file1.c,字符数：30
file1.c,单词数：2
file1.c,行数：1
file2.c,字符数：466
file2.c,单词数：41
file2.c,行数：18
file3.c,字符数：184
file3.c,单词数：16
file3.c,行数：4

参考链接

http://www.runoob.com/java/java-environment-setup.html

http://www.cnblogs.com/xinz/archive/2011/10/22/2220872.html