WordCount合作－－自己部分

前言：

（1）合作者：２０１６３１０６２１２７，２０１６３１０６２６２５

（2）合作代码地址：WordCount

一.结对的PSP表格：

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

二.代码互审情况：

　　相关情况：　相互之间对代码通看了一边，对一些好的全部借鉴下来，不好的全部丢弃。比如整个的程序流程

我们重新构思了一下。

三.设计过程：

　　由于我们是用ｊａｖａ语言来编写的，当然首先是面向对象吧，我们先分析这个项目中所存在的对象，进而分析其需要包含的变量函数。

当然了，博客上已经明确说明此次项目需求，只需要依次实现相关方法即可。

　　流程图：

　　

　　部分运行截图：

　

 命令行运行结果：

目标文件：

停用词表：

结果文件：

 通配符递归测试：

结果：

四.代码说明：

　　这次代码和前次基础功能差别不是很大，类就多了一个，总的５个类。

　　

　　说明：

　　　　Main-----------主函数所在类

　　　　Client----------界面类

　　　　Parameter-----------参数存放的类，所有解析的参数命令放入此类

　　　　Resulte--------------结果集放置类，所有的结果集中放置

　　　　WordCount-------------主要函数所在类（计词，行等）

　　　　Tools-------------------工具类，包含需要用到的函数,具有较高的复用性（参数解析，文件的写入与读取）

　　另外对以前的ＷｏｒｄＣｏｕｎｔ进行了重构，源码如下(包含部分注释)：

Ｍian:

 import java.io.IOException;

 public class Main {
     //-c   字符数
     // -w  词数
     // -l  行数
     // -o  指定输出文件
     // -e  停用词表，接文件名
     // -a  返回更复杂的数据（代码行 / 空行 / 注释行）
     // -s  递归处理目录下符合条件的文件，接文件名
     // -x  调用高级功能
     //public static final String DEFAULTPARAS[] = {"-c","-w","-l","-o","-e","-a","-s","-x"};//8个

     public static void main(String[] args) throws IOException {
         //String canshu = "-w -c -l -a /home/kevin/cb/a.txt -e /home/kevin/s.txt";
         //canshu = "-x";
         String canshu = "";
         canshu = Tools.junctParas(args);

         //System.out.println(canshu);
         WordCount wordCount = new WordCount(canshu);
         wordCount.processFile();

         //String str = " {}"+System.lineSeparator();
         //System.out.println(str.replaceAll("[\\s\\{\\}]","6"));
         //String str = Tools.text2String(new File("/home/kevin/a.txt"));
         //System.out.println(wordCount.getLineCount(str));

         //System.out.println(Tools.getRealFileNameFromList("/home/kevin/cb/"));

         //System.out.println("a*".matches("a..*"));
     }
 }

Client:

 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.File;
 import java.io.IOException;

 public class Client implements ActionListener {

     /*
     * ＵＩ相关
     * */
     private  JButton buttonF = null;
     private JButton buttonOK = null;
     private JFrame frame = null;
     private JTextArea jTextArea = null;
     private Container conFile = null;
     private Container conResult = null;
     private  JLabel jLabel = null;
     private JTextField textF = null;
     private JFileChooser jFileChooser = null;
     private JTabbedPane tabbedPane = null;

     /*
     * WordCound　调用参数相关
     * */
     private File file = null;
     private Parameter parameter = null;

     public Client(Parameter parameter){

         this.parameter = parameter;
         buttonF = new JButton();
         buttonOK = new JButton();
         frame = new JFrame("WordCount");
         jTextArea = new JTextArea();
         conFile=new Container();
         conResult=new Container();
         jLabel = new JLabel();
         textF=new JTextField();
         tabbedPane = new JTabbedPane();
         jFileChooser = new JFileChooser();

     }

     /**
      * @Auther: kevin
      * @param
      * @return: void
      * @Descriptions:
      * @date: 18-10-17 下午8:45
      */
     public void createAndShowGUI() {

         // 确保一个漂亮的外观风格
         //JFrame.setDefaultLookAndFeelDecorated(true);

         // 创建及设置窗口
         //frame.getContentPane().setBackground(Color.red);
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         /*
          *获取屏幕的宽，高
          *
          * */
         double hostL = Toolkit.getDefaultToolkit().getScreenSize().getWidth();
         double hostW = Toolkit.getDefaultToolkit().getScreenSize().getHeight();
         frame.setLocation((int)(hostL/2-100),(int)(hostW/2-250));//根据面板大小设置面板出现位置
         frame.setSize(500,200);//设置整个面板大小
         frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);

         /*
          *添加面板
          *
          * */
         tabbedPane.addTab("chose your file",conFile);
         tabbedPane.addTab("results",conResult);

         /*
          *设置结果显示文本框
          *
          * */
         jTextArea.setBounds(0,0,500,200);
         jTextArea.setLineWrap(true);
         //jTextArea.setText("464648564444444444444416555555555555555555555555555555555555555555");
         //add to pane
         conResult.add(jTextArea);

         /*
          * 设置文件选择框
          * */
         jLabel.setText("file: ");
         jLabel.setSize(40,40);
         jLabel.setLocation(30,40);
         conFile.add(jLabel);

         //文件路径名
         textF.setSize(180,25);
         textF.setLocation(70,50);
         conFile.add(textF);

         //文件选择框
         jFileChooser.setCurrentDirectory(new File("").getAbsoluteFile());
         conFile.add(jFileChooser);

         /*
          *设置文件选择按钮和确认按钮
          *
          * */
         //文字
         buttonF.setText("chose");
         buttonOK.setText("sure");
         //位置
         buttonF.setLocation(270,50);
         buttonOK.setLocation(340,50);
         //大小
         buttonF.setSize(50,25);
         buttonOK.setSize(50,25);
         //内边距
         buttonF.setMargin(new Insets(0,0,0,0));
         buttonOK.setMargin(new Insets(0,0,0,0));
         //加入pane
         conFile.add(buttonF);
         conFile.add(buttonOK);
         //添加监听
         buttonF.addActionListener(this);
         buttonOK.addActionListener(this);

         frame.add(tabbedPane);
         // 显示窗口
         frame.setVisible(true);

     }

     @Override
     public void actionPerformed(ActionEvent actionEvent) {

         if(actionEvent.getSource().equals(buttonF)) {
             jFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);//只选择文件
             int status = jFileChooser.showOpenDialog(null);//文件选择状态

             if(status==JFileChooser.CANCEL_OPTION){
                 return;
             }else if(JFileChooser.APPROVE_OPTION == status){

                 file=jFileChooser.getSelectedFile();//选择到的文件
                 //System.out.println(file.exists());
                 textF.setText(file.getAbsolutePath());
             }

         }else if(actionEvent.getSource().equals(buttonOK)){
             if(file==null){
                 // 消息对话框无返回, 仅做通知作用
                 JOptionPane.showMessageDialog( frame, "File is not exist !!!", "error", JOptionPane.INFORMATION_MESSAGE );
             }else{

                 tabbedPane.setSelectedComponent(conResult);
                 setParameter(parameter ,file);
                 Result result = new Result();
                 String textData = Tools.text2String(new File(this.parameter.getInputfileName()));
                 try {
                     Tools.setResult(new WordCount(""),parameter,result,textData);
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
                 //设置显示数据
                 String sResult= Tools.formatInputData(parameter.getInputfileName(),result.getCharCount(),result.getWordCount(),result.getLineCount(),result.getCodeLineCount(),result.getCommentLineCount(),result.getEmptyLineCount());
                 jTextArea.setText(sResult);
             }
         }
     }

     /**
      * @Auther: kevin
      * @param parameter
     * @param file
      * @return: void
      * @Descriptions:
      * @date: 18-10-17 下午8:44
      */
     private void setParameter(Parameter parameter ,File file){

         parameter.setInputfileName(file.getAbsolutePath());
         parameter.setShowCharCount(true);
         parameter.setShowWordCount(true);
         parameter.setShowlineCount(true);
         parameter.setShowMore(true);
     }

     /*public static void main(String[] args){
         Client swingUI = new Client();
         swingUI.createAndShowGUI();
         int a = 0,b=1;
         if(a==0){
             System.out.println("0");
         }else if(b==1){
             System.out.println("1");
         }

     }*/
 }

Parameter:

 import java.util.List;

 public class Parameter {
     //-c   字符数
     // -W  词数
     // -l  行数
     // -o  指定输出文件
     // -e  停用词表，接文件名
     // -a  返回更复杂的数据（代码行 / 空行 / 注释行）
     // -s  递归处理目录下符合条件的文件，接文件名
     // -x  调用高级功能

     //单文件使用的输入名
     private String inputfileName=null;

     //默认输出文件
     private String outPutFileName="result.txt";

     //停用词表
     private String filterFilename = null;

     //多文件使用
     private List<String> filesName = null;

     //是否计算字符数
     private boolean isShowCharCount=false;

     //是否计算词数
     private boolean isShowWordCount=false;

     //是否计算行数
     private boolean isShowlineCount=false;

     //是否有指定输出文件
     private boolean isOutput=false;

     //是否用停用词表
     private boolean filterWord=false;

     //是否显示更多信息（代码行，注释行，空行）
     private boolean isShowMore=false;

     //是否处理多文件,就是递归处理符合条件的文件
     private boolean isProcessMultFiles=false;

     //是否启用高级功能，ＵＩ界面
     private boolean isAdvance=false;

     public String getInputfileName() {
         return inputfileName;
     }

     public void setInputfileName(String inputfileName) {
         this.inputfileName = inputfileName;
     }

     public String getOutPutFileName() {
         return outPutFileName;
     }

     public void setOutPutFileName(String outPutFileName) {
         this.outPutFileName = outPutFileName;
     }

     public String getFilterFilename() {
         return filterFilename;
     }

     public void setFilterFilename(String filterFilename) {
         this.filterFilename = filterFilename;
     }

     public List<String> getFilesName() {
         return filesName;
     }

     public void setFilesName(List<String> filesName) {
         this.filesName = filesName;
     }

     public boolean isShowCharCount() {
         return isShowCharCount;
     }

     public void setShowCharCount(boolean showCharCount) {
         isShowCharCount = showCharCount;
     }

     public boolean isShowWordCount() {
         return isShowWordCount;
     }

     public void setShowWordCount(boolean showWordCount) {
         isShowWordCount = showWordCount;
     }

     public boolean isShowlineCount() {
         return isShowlineCount;
     }

     public void setShowlineCount(boolean showlineCount) {
         isShowlineCount = showlineCount;
     }

     public boolean isOutput() {
         return isOutput;
     }

     public void setOutput(boolean output) {
         isOutput = output;
     }

     public boolean isFilterWord() {
         return filterWord;
     }

     public void setFilterWord(boolean filterWord) {
         this.filterWord = filterWord;
     }

     public boolean isShowMore() {
         return isShowMore;
     }

     public void setShowMore(boolean showMore) {
         isShowMore = showMore;
     }

     public boolean isProcessMultFiles() {
         return isProcessMultFiles;
     }

     public void setProcessMultFiles(boolean processMultFiles) {
         isProcessMultFiles = processMultFiles;
     }

     public boolean isAdvance() {
         return isAdvance;
     }

     public void setAdvance(boolean advance) {
         isAdvance = advance;
     }
 }

Result:

 public class Result {
     //处理的文件名
     private String inputFileName=null;
     //指定输出的文件名
     private String outPutFileName=null;

     //字符数
     private int charCount=-1;
     //词数
     private int WordCount=-1;
     //行数
     private int lineCount=-1;

     //空行数
     private int emptyLineCount=-1;
     //代码行
     private int codeLineCount=-1;
     //注释行
     private int commentLineCount=-1;

     public String getInputFileName() {
         return inputFileName;
     }

     public void setInputFileName(String inputFileName) {
         this.inputFileName = inputFileName;
     }

     public String getOutPutFileName() {
         return outPutFileName;
     }

     public void setOutPutFileName(String outPutFileName) {
         this.outPutFileName = outPutFileName;
     }

     public int getCharCount() {
         return charCount;
     }

     public void setCharCount(int charCount) {
         this.charCount = charCount;
     }

     public int getWordCount() {
         return WordCount;
     }

     public void setWordCount(int wordCount) {
         WordCount = wordCount;
     }

     public int getLineCount() {
         return lineCount;
     }

     public void setLineCount(int lineCount) {
         this.lineCount = lineCount;
     }

     public int getEmptyLineCount() {
         return emptyLineCount;
     }

     public void setEmptyLineCount(int emptyLineCount) {
         this.emptyLineCount = emptyLineCount;
     }

     public int getCodeLineCount() {
         return codeLineCount;
     }

     public void setCodeLineCount(int codeLineCount) {
         this.codeLineCount = codeLineCount;
     }

     public int getCommentLineCount() {
         return commentLineCount;
     }

     public void setCommentLineCount(int commentLineCount) {
         this.commentLineCount = commentLineCount;
     }
 }

WordCount:

 import java.io.*;
 import java.util.ArrayList;
 import java.util.List;

 public class WordCount {

     public Parameter parameter;

     public WordCount(String longparas) throws IOException {
         this.parameter = Tools.putParasToParameter(longparas);
     }

     /**
      * @Auther: kevin
      * @param
      * @return: void
      * @Descriptions:控制整个流程，单个文件处理还是多文件的递归，或者调出ＵＩ。
      * @date: 18-10-17 下午8:47
      */
     public void processFile() throws IOException {

         String outPutFile = null;
         String inputData = null;
         String textData = null;
         Result result = null;
        if(parameter.isAdvance()){

            Client swingUI = new Client(parameter);
            swingUI.createAndShowGUI();

        }else if(parameter.isProcessMultFiles()){

             result = new Result();
             //System.out.println("size: "+parameter.getFilesName().size());
             for(int i=0;i<parameter.getFilesName().size();i++){

                 textData = Tools.text2String(new File(this.parameter.getFilesName().get(i)));
                 Tools.setResult(this,parameter,result,textData);
                 outPutFile = result.getOutPutFileName();
                 inputData = Tools.formatInputData(this.parameter.getFilesName().get(i),result.getCharCount(),result.getWordCount(),result.getLineCount(),result.getCodeLineCount(),result.getCommentLineCount(),result.getEmptyLineCount());
                 Tools.writeFile(outPutFile,inputData);
                 //System.out.println(outPutFile+inputData);
             }

         }else{
            result = new Result();
            textData = Tools.text2String(new File(this.parameter.getInputfileName()));
            Tools.setResult(this,parameter,result,textData);
            outPutFile = parameter.getOutPutFileName();
            inputData = Tools.formatInputData(parameter.getInputfileName(),result.getCharCount(),result.getWordCount(),result.getLineCount(),result.getCodeLineCount(),result.getCommentLineCount(),result.getEmptyLineCount());
            Tools.writeFile(outPutFile,inputData);
            //System.out.println(outPutFile+inputData);
        }

     }

     /**
      * @Auther: kevin
      * @param textData
      * @return: int
      * @Descriptions:获取字符数
      * @date: 18-10-17 下午8:47
      */
     public int getCharCount(String textData){
         int ret = -1;
         ret = textData.length();
         return ret;
     }

     /**
      * @Auther: kevin
      * @param HasStopWords
     * @param textData
      * @return: int
      * @Descriptions:获取词数
      * @date: 18-10-17 下午8:46
      */
     public int getWordCount(boolean HasStopWords,String textData){

         int ret = -1;
         String tmp[] = textData.split("\\s+|,+");
         List<String> list=new ArrayList<String>();

         for(int i=0;i<tmp.length;i++){
             if(!tmp[i].equals(""))
                 list.add(tmp[i]);
         }

         //对停用词不进行计数
         if(HasStopWords){
             //File file = new File("/home/kevin/s.txt");
             File file = new File(parameter.getFilterFilename());
             String stopWord = Tools.text2String(file);
             String stopWords[] = stopWord.split("\\s+");
             for(int i=0;i<stopWords.length;i++){
                 for(int j=0;j<list.size();j++){
                     if(stopWords[i].equalsIgnoreCase(list.get(j))){
                         //System.out.println(list.get(j));
                         list.remove(j);
                         j--;
                     }
                 }
             }
         }

         ret = list.size();

         return ret;
     }

     /**
      * @Auther: kevin
      * @param textData
      * @return: int
      * @Descriptions:获取行数
      * @date: 18-10-17 下午8:46
      */
     public int getLineCount(String textData){

         int ret = -1;
         ret = textData.split(System.lineSeparator()).length;
         return ret;
     }

     /**
      * @Auther: kevin
      * @param textData
      * @return: int
      * @Descriptions:获取空行数
      * @date: 18-10-17 下午8:46
      */
     public int getEmptyLineCount(String textData){

         int ret = 0;
         String tmp[] = textData.split(System.lineSeparator());
         for(int i=0;i<tmp.length;i++){
             if(tmp[i].replaceAll("[\\s\\{\\}]","").equals(""))
                 ret++;
         }
         return ret;
     }

     /**
      * @Auther: kevin
      * @param textData
      * @return: int
      * @Descriptions:获取代码行数
      * @date: 18-10-17 下午8:46
      */

     public int getCodeLineCount(String textData){
         int ret = 0;
         String tmp[] = textData.split(System.lineSeparator());
         ret = getLineCount(textData)-getCommentLineCount(textData)-getEmptyLineCount(textData);
         return ret;

     }

     /**
      * @Auther: kevin
      * @param textData
      * @return: int
      * @Descriptions:获取注释行数
      * @date: 18-10-17 下午8:49
      */
     public int getCommentLineCount(String textData){

         int ret = 0;
         String tmp[] = textData.split(System.lineSeparator());
         for(int i=0;i<tmp.length;i++){
             if(tmp[i].contains("//"))
                 ret++;
         }
         return ret;
     }
 }

Tools:

 import java.io.*;
 import java.util.ArrayList;
 import java.util.List;

 public class Tools{
     //-c   字符数
     // -W  词数
     // -l  行数
     // -o  指定输出文件
     // -e  停用词表，接文件名
     // -a  返回更复杂的数据（代码行 / 空行 / 注释行）
     // -s  递归处理目录下符合条件的文件，接文件名
     // -x  调用高级功能
     public static final String DEFAULTPARAS[] = {"-c","-w","-l","-o","-e","-a","-s","-x"};//8个

     /*
     *
     * 将数组参数连接为字符串
     * */
     public static String junctParas(String args[]){
         String junction = "";

         for(int i=0;i<args.length;i++){
             junction += args[i]+" ";
             //System.out.println(args[i]);
         }

         return junction.trim();
     }

     /*
     * 将参数放进ｐａｒａｍｅｔｅｒ
     *
     * */
     public static  Parameter putParasToParameter(String longParas){
         String opt = null;
         String realParas[] = getRealParas(longParas);
         Parameter parameter = new Parameter();

         for(int i=0;i<realParas.length;i++){
             opt = realParas[i];
             switch (opt){
                 case "-c":
                     parameter.setShowCharCount(true);
                     break;
                 case "-w":
                     parameter.setShowWordCount(true);
                     break;
                 case "-l":
                     parameter.setShowlineCount(true);
                     break;
                 case "-o":
                     parameter.setOutput(true);
                     parameter.setOutPutFileName(getFileName("-o",longParas));
                     //System.out.println(parameter.getOutPutFileName());
                     break;
                 case "-e":
                     parameter.setFilterWord(true);
                     parameter.setFilterFilename(getFileName("-e",longParas));
                     break;
                 case "-a":
                     parameter.setShowMore(true);
                     break;
                 case "-s":
                     parameter.setProcessMultFiles(true);
                     parameter.setFilesName(getRealFileNameFromList(getFileName("-s",longParas)));
                     break;
                 case "-x":
                     parameter.setAdvance(true);
                     break;
                     default:
             }
         }
         parameter.setInputfileName(getInputFileName(longParas));

         return parameter;
     }
     /*
     *
     * 解析真实的命令参数
     * */
     private static String[] getRealParas(String longParas){
         String tmp[] = longParas.split(" ");
         List<String> realPara=new ArrayList<String>();
         for(int i=0;i<tmp.length;i++){
             for(int j=0;j<DEFAULTPARAS.length;j++){
                 if( tmp[i].trim().equals(DEFAULTPARAS[j]) ){
                     realPara.add(tmp[i]);
                 }
             }
         }

         return (String[])realPara.toArray(new String[realPara.size()]);
     }

     //String canshu="-c e:\\test.txt -W -l -o -s -e file.txt";
     /*
     * 基础功能，单个输入文件名获取
     *
     * */
     private static String getInputFileName(String longParas){
        String inputFileName = null;
        String tmp[] = longParas.split(" ");
        for(int i=0;i<DEFAULTPARAS.length;i++){
            for(int j=0;j<tmp.length;j++){
                if(!DEFAULTPARAS[i].equals(tmp[j]) && tmp[j].length()>2 ){
                    //System.out.println(tmp[j]+" "+DEFAULTPARAS[i]);
                    if( !tmp[j].equals(getFileName("-o",longParas)) && !tmp[j].equals(getFileName("-e",longParas)) && !tmp[j].equals(getFileName("-s",longParas))){
                        //System.out.println(getFileName("-o",longParas)+getFileName("-e",longParas)+getFileName("-s",longParas));
                        inputFileName = tmp[j];
                    }
                }
            }
        }

         return inputFileName;
     }

     /*
     *
     * 通过命令参数获取 所需文件，如：　停用词表，输出文件
     *
     * */
     private static String getFileName(String para,String paras){
         boolean isNewFile = paras.contains(para);
         String newFileName = null;
         String str[] = paras.substring(paras.indexOf(para)+3).split(" ");
         if(isNewFile){ newFileName = str[0];}
         return newFileName;
     }

     /*
     * 筛选需要用到的文件,递归做匹配相应的文件．
     *
     * */
     public static List<String> getRealFileNameFromList(String filePath){
         String processedFile = getProcessedFileName(filePath);
         String diviPath[] = getFileNameFormPath(filePath);

         List<String> fileList = getFileNameFromDir(new File(diviPath[0]));
         for(int i=0;i<fileList.size();i++){
             //System.out.println(fileList.size());
             String fileName = getFileNameFormPath(fileList.get(i))[1];
             //System.out.println(diviPath[0]+" "+processedFile);
             if(!fileName.matches(processedFile) && !diviPath[0].equals(processedFile)){//当文件名匹配不成功成功时，移除不符合规则文件
                 fileList.remove(i);
                 i--;
             }
         }

         return fileList;
     }

     /*
     *
     * 对文件名进行通配符解释
     *
     * */
     private static String getProcessedFileName(String filePath){

         String file[] = getFileNameFormPath(filePath);
         file[1] = file[1].replace("*",".*");//匹配任意一个或多个字符
         file[1] = file[1].replace("?",".{1,1}");//匹配任意一个字符
         //file[1] = file[0]+file[1];
         //System.out.println(file[0]+"6"+file[1]);
         return file[1];
     }

     /*
     *
     * 从路径中分离文件名和文件夹名,数组索引0为文件夹，数组索引1为文件
     * */
     private static String[] getFileNameFormPath(String filePath){
         String ret[] = new String[2];
         if(filePath.contains("/")){
             int index = filePath.lastIndexOf("/");
             int len = filePath.length();

             ret[0] = filePath;
             ret[1] = filePath;

             if(len != index+1){
                 String tmp = filePath.substring(index+1);
                 if(tmp.matches(".*\\.\\S*")) {
                     ret[0] = filePath.substring(0, index + 1);
                     ret[1] = filePath.substring(index + 1);
                 }
             }
         }else{
             File directory = new File("");
             ret[0] = directory.getAbsolutePath();
             ret[1] = filePath;
         }
         return ret;
     }

     /*
     *
     * 获取文件件下面所有文件
     * */
     private static List<String> getFileNameFromDir(File file){
         List<String> fileList = new ArrayList<String>();
         addFileNameToList(file,fileList);
         return fileList;
     }

     /*
     *
     * 通过递归把文件加入List
     * */
     private static void addFileNameToList(File file, List<String> fileList){

         //System.out.println(file);
         File files[] = file.listFiles();

         if(files!=null) {
             for (int i = 0; i < files.length; i++) {
                 //System.out.println(files.length);
                 if (files[i].isFile()) {

                     fileList.add(files[i].toString());

                 } else if (files[i].isDirectory()) {

                     File tmp = new File(files[i].toString());
                     addFileNameToList(tmp, fileList);

                 }
             }
         }
     }

     /*
     *
     * 从文件中读取数据转换为String类型数据
     * */
     public static String text2String(File file){
         if(!file.exists())return null;
         StringBuilder result = new StringBuilder();

         try{
             BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
             String s = null;
             while((s = br.readLine())!=null){//使用readLine方法，一次读一行

                 result.append(s+System.lineSeparator());
                 //System.out.println("+");
             }
             br.close();
         }catch(Exception e){
             e.printStackTrace();
         }
         return result.toString();
     }

     /*
     *
     * 对所有结果进行统一设置
     * */
     public static void setResult(WordCount wordCount,Parameter parameter,Result result,String textData){

         //System.out.println(wordCount);
         //字符计数
         if(parameter.isShowCharCount()){ result.setCharCount(wordCount.getCharCount(textData)); }
         //词数计数
         //System.out.println(result);
         if(parameter.isShowWordCount()){ result.setWordCount(wordCount.getWordCount(parameter.isFilterWord(),textData)); }

         //总行计数
         if(parameter.isShowlineCount()){ result.setLineCount(wordCount.getLineCount(textData)); }

         //代码行，注释行，空行计数
         if(parameter.isShowMore()){
             result.setCodeLineCount(wordCount.getCodeLineCount(textData));
             result.setCommentLineCount(wordCount.getCommentLineCount(textData));
             result.setEmptyLineCount(wordCount.getEmptyLineCount(textData));
         }
         //输出文件名
         if(parameter.isOutput()) result.setOutPutFileName(parameter.getOutPutFileName());
         else result.setOutPutFileName("result.txt");
     }

     /*
     *
     * 格式化输出结果
     * */
     public static String formatInputData(String fileName,int charCount,int wordCount,int lineCount,int codeLineCount,int commentLineCount,int emptyLineCount){
         String ret = "文件名路径： "+fileName+" 字符数： "+ String.valueOf(charCount)+" 词数: "+String.valueOf(wordCount)+" 总行数： "+String.valueOf(lineCount)+" 代码行数: "+String.valueOf(codeLineCount)+" 注释行数: "+String.valueOf(commentLineCount)+" 空行数:"+String.valueOf(emptyLineCount);
         return ret;
     }

     /*
     *
     * 将数据写入文件
     * */
     public static void writeFile(String fileName,String data){
         File file = new File(fileName);// 要写入的文件路径
         if (!file.exists()) {// 判断文件是否存在
             try {
                 file.createNewFile();// 如果文件不存在创建文件
                 System.out.println("文件"+file.getName()+"不存在已为您创建!");
             } catch (IOException e) {
                 System.out.println("创建文件异常!");
                 e.printStackTrace();
             }
         } else {
             System.out.println("文件"+file.getName()+"已存在!");
         }

         FileOutputStream fos = null;
         PrintStream ps = null;
         try {
             fos = new FileOutputStream(file,true);// 文件输出流    追加
             ps = new PrintStream(fos);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         }
         String string  = data+"\r\n";// +换行
         ps.print(string); // 执行写操作
         ps.close();    // 关闭流

         System.out.println("文件写入完毕!");
     }
 }

另外单元测试，也做了相应的函数测试：

界面：

Tools(太多就贴两张图):

WordCount(太多就贴两张图):

五.总结：

　　这次结对编程给我很大的影响。首先通过这次作业学到的不仅仅是编程的部分，合作也是之间相互协调很重要。

　　　　　　　　　　　　这个成立：　１＋１＞２

另外在讨论中我们都能相互学习到对方不了解的领域。另外编程部分了解一些工具的使用，学会一点皮毛的单元测

试，一些编码规范也同时了解到一些。

　　这次编码不是时间用的最多的，反而是两个人之间代码相互融合，以及对函数的缺陷的修改。当然此次项目的

结果还是有很多ｂｕｇ的，所以再之后我们还会抽时间继续完善一些函数，另外做到优化性能。这次合作项目只是

简单的开始，”路漫漫其修远兮，吾将上下而求索“。此后的时间里我会更加注重基础，因在这个项目中给我影响最

大是ｊａｖａ自带的函数之强大，让我感受到了算法之美！！！ps:贴上自己的ＷｏｒｄＣｏｕｎｔ