WordCount扩展实现——结对编程

合作者：

　　201631062221，201631062514

地址：

　　代码地址

本次作业地址：

　　https://edu.cnblogs.com/campus/xnsy/2018Systemanalysisanddesign/homework/2188

正文：

　1.PSP表格：

 

2.互审代码情况：

　　审查的罗博伦的WordCount的基础功能实现代码。
　　CommandScanner类：这个类的注释较少，代码比较冗杂。
　　myFunction类：逻辑比较清楚，但可以优化一下逻辑，减少内存的开辟，代码复用性可以提高一下，可以抽象出相近的一些方法。

　　我发现，在最初的基础功能实现逻辑上，我们两个都会出现的问题是，完全忽略掉了面向对象的几大设计原则，没有考虑到整个系统的扩展性，

　　因此，在实现扩展功能的时候，我们花费了较多的时间去调整整个项目的结构。

 

3.设计过程：

 

 4.代码说明：

　　逻辑处理类

public class Main {
    public static File outFile;
    public static File stopFile;
    public static File inputFile;

    /*
     * 用于标记是否输入了相关文件
     */
    public static boolean inputFileFlag = false;
    public static boolean outFileFlag = false;
    public static boolean stopFileFlag = false;
    public static boolean operateFileTypeFlag = false;

    /*
     * 相关功能类
     */

    public static BaseCount baseCount = new BaseCount();;
    public static ExtendCount extendCount = new ExtendCount(baseCount);
    public static FileOutputer fileOutputer = new FileOutputer(baseCount,
            extendCount);
    public static CommandGetter commandGetter;
    
    public static String[] commands;
    
    public Main(String[] commands) {
        // TODO Auto-generated constructor stub
        this.commands=commands;
    }

    public static void originalMain() {
        commandGetter = new CommandGetter(commands);

        /*
         * 获取是否输入相应的文件
         */
        inputFileFlag = commandGetter.setInputFile();// 标识是否输入源操作文件
        outFileFlag = commandGetter.setOutFile();// 标识是否指定输出文本文件
        stopFileFlag = commandGetter.setStopFile();// 标识是否输入停用词文件
        operateFileTypeFlag = commandGetter.setOperateFileType();// 标识是否输入批量操作文件的类型

        /*
         * 得到相关文件
         */
        outFile = commandGetter.getOutFile();
        inputFile = commandGetter.getInputFile();
        stopFile = commandGetter.getStopFile();

        try {
            if (inputFile.exists()) {
                chooiseCommand(inputFile);
            } else {
                System.out.println("输入的操作源文件不存在！");
            }
            manageScommand();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    /**
     * 
     * 管理基本的操纵命令，根据不同的命令调用不同的方法
     * 
     * @param targetFile
     *            操作源文件
     * @throws IOException
     */
    public static void chooiseCommand(File targetFile) throws IOException {

        if (inputFileFlag) {
            for (String str : commandGetter.getCommandStrings()) {
                switch (str) {
                case "-c":
                    baseCount.countChar(targetFile);
                    break;
                case "-l":
                    baseCount.countLine(targetFile);
                    break;
                case "-w":
                    baseCount.countWord(targetFile);
                    break;
                case "-a":
                    extendCount.countEveryLine(targetFile);
                    // 加入统计代码行数、空行数、注释行数的方法
                    break;
                case "-e":
                    if (stopFileFlag) {
                        if (stopFile.exists()) {
                            extendCount.afterIgoreWordsCount(stopFile,
                                    targetFile);
                        } else {
                            System.out.println("输入的停用词文件不存在！");
                        }
                    } else {
                        System.out
                                .println("-e 必须与停用词文件名同时使用，且停用词文件必须紧跟在-e参数后面，不允许单独使用-e参数。");
                    }
                    break;
                default:
                    break;
                }
            }
            manageOcommand();

        } else {
            System.out.println("请输入源文件");
        }
    }

    /**
     * 
     * 判断命令行中是否存在输出指令以及指定输出的文本文件，并作出相应的回应
     * 
     * @throws IOException
     */
    public static void manageOcommand() throws IOException {
        if (commandGetter.checkOcommand()) {
            if (outFileFlag) {
                fileOutputer.outputFile(outFile);
            } else {
                System.out
                        .println("-o 必须与文件名同时使用，且输出文件必须紧跟在-o参数后面，不允许单独使用-o参数!");
            }
        } else {
            fileOutputer.outputFile(new File("result.txt"));
        }
    }

    /**
     * 判断输入的命令行中是否存在递归处理该目录下相关文件的指令，并作出相应的回应
     *
     * @throws IOException
     */
    public static void manageScommand() throws IOException {
        boolean sCommandExist = commandGetter.checkScommand();
        if (sCommandExist) {
            if (operateFileTypeFlag) {
                // 加入递归处理文件的方法 String fileType

                ArrayList<File> files;
                String fileType = commandGetter.getFileType();
                String fileDir=commandGetter.getFileDir();
                if (extendCount.setTargetFileList(fileType, fileDir)) {
                    files = extendCount.getTargetFileList();
                    for (File f : files) {
                        chooiseCommand(f);
                    }
                } else {
                    System.out.println("该类型文件在本目录下不存在！");
                }

            } else {
                System.out.println("请输入要批量处理的文件格式！");
            }
        } else if (operateFileTypeFlag) {
            System.out.println("请指定-S操作符！");
        }
    }
}

基础功能类：

package com.kong.base;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;


/**
 * 实现WC的基础功能，统计字符数，单词数，行数
 * 
 * @author 孔绍坤
 * @version 1.0
 * @since 最低的JDK版本
 * 
 *
 */
public class BaseCount {
    private static int c = -1;
    private static int w = -1;
    private static int l = -1;
    private static File file;

    /**
     * 
     * 统计总的字符数
     * 
     * @param inputFile
     *            指定的目标操作文件
     * @return c 返回统计的字符数
     * @throws IOException
     */
    public int countChar(File inputFile) throws IOException {
        file = inputFile;
        if (inputFile.exists()) {
            FileInputStream fip = new FileInputStream(file);
            InputStreamReader reader = new InputStreamReader(fip);
            StringBuffer sBuffer = new StringBuffer();
            while (reader.ready()) {
                sBuffer.append((char) reader.read());
            }

            c = sBuffer.length();
            reader.close();
            fip.close();
            return c;
        } else {
            System.out.println("统计字符：输入的源文件不存在！");
            return -1;
        }
    }

    /**
     * 统计总的行数
     * 
     * @param inputFile
     *            接收一个目标操作文件
     * @return l 返回统计的行数
     */
    public int countLine(File inputFile) throws IOException {
        if (inputFile.exists()) {
            file = inputFile;
            FileInputStream fip = new FileInputStream(file);
            InputStreamReader reader = new InputStreamReader(fip);
            StringBuffer sBuffer = new StringBuffer();
            while (reader.ready()) {
                sBuffer.append((char) reader.read());
            }
            String str = sBuffer.toString();
            char[] ch = str.toCharArray();
            l = 0;
            for (char c : ch) {
                if (c == '\n') {
                    l++;
                }
            }
            reader.close();
            fip.close();
            return l;
        } else {
            System.out.println("统计行数：输入的源文件不存在！");
            return -1;
            
        }

    }

    /**
     * 统计总的单词数
     * 
     * @param inputFile
     *            接收一个目标操作文件
     * 
     * @return w 返回统计的单词数
     */
    public int countWord(File inputFile) throws IOException {
        if(inputFile.exists())
        {
        file = inputFile;
        FileInputStream fip = new FileInputStream(file);
        InputStreamReader reader = new InputStreamReader(fip);
        StringBuffer sBuffer = new StringBuffer();
        while (reader.ready()) {
            sBuffer.append((char) reader.read());
        }
        String str = sBuffer.toString();
        char[] ch = str.toCharArray();
        w = 0;
        for (char c : ch) {
            if (c == '\n' || c == '\r' || c == ' ' || c == ',' || c == ';'
                    || c == '.') {
                w++;
            }
        }
        reader.close();
        fip.close();
        return w;
        }else {
            System.out.println("统计单词数：输入的源文件不存在！");
            return -1;
        }
    }

    public int getC() {
        return c;
    }

    public int getW() {
        return w;
    }

    public int getL() {
        return l;
    }
    
    public File getFile()
    {
        return file;
    }
}

文件输出类：

package com.kong.base;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 文件输出类，处理输出信息，输出信息到文件
 * 
 * @author kong
 * @version 1.0 2018/10/9
 *
 */
public class FileOutputer {

    private BaseCount baseCount;
    private ExtendCount extendCount;

    /**
     * 
     * @param baseCount
     *            基础功能类
     * @param extendCount
     *            扩展功能类
     */
    public FileOutputer(BaseCount baseCount, ExtendCount extendCount) {
        this.baseCount = baseCount;
        this.extendCount = extendCount;
        // TODO Auto-generated constructor stub
    }

    /**
     * 判断输入的操作源文件是否存在
     * 
     * @return 如果存在，则返回true否则返回false
     */
    public boolean checkInputFileExist() {
        if (baseCount.getFile().exists()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 
     * 将统计结果输出到文本文件中 输出详细的文本文件的统计结果
     * 
     * @see com.kong.base.BaseCount
     * @see ExtendCount
     * 
     * @param outputFile
     *            输出文本文件
     * @throws IOException
     */
    public void outputFile(File outputFile) throws IOException {
        boolean inputFileExist = checkInputFileExist();
        if (inputFileExist) {
            File f = outputFile;
            FileOutputStream fop = new FileOutputStream(f, true);
            OutputStreamWriter writer = new OutputStreamWriter(fop);
            if (baseCount.getC() >= 0) {

                writer.append(baseCount.getFile().getName() + ",总字符数："
                        + baseCount.getC() + "\r\n");
            }
            if (baseCount.getW() >= 0) {
                writer.append(baseCount.getFile().getName() + ",总单词数："
                        + baseCount.getW() + "\r\n");
            }
            if (baseCount.getL() >= 0) {
                writer.append(baseCount.getFile().getName() + ",总行数："
                        + baseCount.getL() + "\r\n");
            }
            if (extendCount.getCodeLine() >= 0) {
                writer.append(extendCount.getFile().getName()
                        + ",代码行数\\空行数\\注释行数：" + extendCount.getCodeLine()
                        + "\\" + extendCount.getEmptyLine() + "\\"
                        + extendCount.getCommentLine() + "\r\n");
            }
            if (extendCount.getAfterIngoreWords() >= 0) {
                writer.append(extendCount.getFile().getName() + ",不统计的单词有：");
                for (String temp : extendCount.getStopWords()) {
                    writer.append(temp + " ");
                }
                writer.append("结果单词数：" + extendCount.getAfterIngoreWords()
                        + "\r\n");
            }
            writer.close();
            fop.close();
        }
    }
}

命令获取提取类：

package com.kong.base;

import java.io.File;

/**
 * 
 * 
 * 获取输入的命令行，并且提取出，源操作文件，停用词文件， 指定输出文件，批量操作文件的类型
 * 
 * @author 孔绍坤
 * @version 1.0 2018/10/9
 * @since 不清楚
 *
 */
public class CommandGetter {
    private File outFile;
    private File stopFile;
    private File inputFile;
    private String fileType;
    private String[] commandStrings;

    /**
     * 新加的
     */

    private String fileDir;

    /**
     * 获取输入的命令行
     * 
     * @param commandStrings
     *            输入的命令行
     */
    /*
     * private CommandGetter() {
     * 
     * }
     */
    public CommandGetter(String[] commandStrings) {
        // TODO Auto-generated constructor stub
        this.commandStrings = commandStrings;
    }

    public String getFileDir() {
        setFileDir();
        return fileDir;
    }

    /**
     * 此处是为了配合新的需求（用户指定操作目录添加的得到文件目录的方法） 实现方法跟之前的不同，可能不够严谨
     */
    public void setFileDir() {

        /*
         * 添加获取command中的指定文件目录
         */
        boolean flag = false;
        for (int i = 0; i < commandStrings.length; i++) {
            if (commandStrings[i].equals("-s")) {
                fileDir = commandStrings[i + 1];
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            fileDir = ".";
        }

    }

    /**
     * 设置操作源文件
     * 
     * @return 成功读取到文件 返回true，否则返回false
     */
    public boolean setInputFile() {
        for (String temp : commandStrings) {
            if (temp.endsWith(".java")) {
                /*
                 * 内部的判断语句用于区分输入格式为*.java以及.java
                 */
                if (!temp.equals("*.java")) {
                    this.inputFile = new File(temp);
                    return true;
                }
            } else {
                inputFile = null;
            }
        }
        return false;
    }

    /**
     * 设置批量操作文件的类型
     * 
     * @return 成功读取到文件类型 返回true，否则返回false
     */
    public boolean setOperateFileType() {
        for (String temp : commandStrings) {
            if (temp.startsWith("*.")) {
                String[] strs = temp.split("\\.");
                this.fileType = strs[strs.length - 1];
                return true;
            }
        }
        return false;
    }

    /**
     * 设置输出文本文件
     * 
     * @return 成功读取到文件类型 返回true，否则返回false
     */
    public boolean setOutFile() {
        for (int i = 0; i < commandStrings.length; i++) {
            if (i < commandStrings.length - 1) {
                if (commandStrings[i + 1].endsWith(".txt")
                        && commandStrings[i].equals("-o")) {
                    outFile = new File(commandStrings[i + 1]);
                    return true;
                } else {
                    outFile = null;
                }
            }
        }
        return false;
    }

    /**
     * 检查S命令符是否输入
     * 
     * @return 成功读取到S命令 返回true，否则返回false
     */
    public boolean checkScommand() {
        for (String temp : commandStrings) {
            if (temp.equals("-s")) {
                return true;
            }
        }
        return false;
    }

    /**
     * 检查O命令符是否输入
     * 
     * @return 成功读取到O命令 返回true，否则返回false
     */
    public boolean checkOcommand() {
        for (String temp : commandStrings) {
            if (temp.equals("-o")) {
                return true;
            }
        }
        return false;
    }

    /**
     * 设置停用词文件
     * 
     * @return 成功读取到停用词文件 返回true，否则返回false
     */
    public boolean setStopFile() {
        for (int i = 0; i < commandStrings.length; i++) {
            if (i < commandStrings.length - 1) {
                if (commandStrings[i + 1].endsWith(".txt")
                        && commandStrings[i].equals("-e")) {
                    stopFile = new File(commandStrings[i + 1]);
                    return true;
                }
            } else {
                stopFile = null;

            }
        }
        return false;
    }

    /**
     * 
     * @return 获取指定输出文件
     */
    public File getOutFile() {
        return outFile;
    }

    /**
     * 
     * @return 获取停用词文件
     * 
     */
    public File getStopFile() {
        return stopFile;
    }

    /**
     * 
     * @return 获取源操作文件
     */
    public File getInputFile() {
        return inputFile;
    }

    /**
     * 
     * @return
     * 
     *         获取批量操作文件的类型
     */
    public String getFileType() {
        return fileType;
    }

    /**
     * 
     * @return 获取输入的命令行
     */
    public String[] getCommandStrings() {
        return commandStrings;
    }

}

进行测试的部分代码：

package com.kong.base;

import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/**
 * 
    用 @RunWith(Parameterized.class) 来注释 test 类。
    创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
    创建一个公共的构造函数，它接受和一行测试数据相等同的东西。
    为每一列测试数据创建一个实例变量。
    用实例变量作为测试数据的来源来创建你的测试用例。

 * @author 孔绍坤
 *
 */
@RunWith(Parameterized.class)
public class CommandGetterTest {
    private String[] commands;
    private String[] expectedResult;
    private CommandGetter commandGetter;
    
    /*
     *特备说明：expectedResult存数的都boolean的数据，为了使所有的方法都可以同时进行参数化测试
     */
    @Before
    public void Init()
    {
        commandGetter=new CommandGetter(commands);
    }
    
    public CommandGetterTest(String[] commands,String[] expectedResult) {
        this.commands=commands;
        this.expectedResult=expectedResult;
        // TODO Auto-generated constructor stub
    }
    
    @Parameters
    public static Collection primeData() {
        
        //模拟命令
        String[] str1={"test.java","-o","-s"};
        String[] str2={"-c","-l","-w","test1.java","-o","out1.txt"};
        String[] str3={"-o","out.txt","test.java","*.c","-s","-e","stop.txt"};
        String[] str4={"*.c","-s","-e"};
        
        //调用的方法返回值集合
        String[] bool1={"true","false","false","true","true","false"};
        String[] bool2={"true","false","true","false","true","false"};
        String[] bool3={"true","true","true","true","true","true"};
        String[] bool4={"false","true","false","true","false","false"};
        Object[][] object=new Object[][]{
                {str1,bool1},
                {str2,bool2},
                {str3,bool3},
                {str4,bool4}
                };
        return Arrays.asList(object);
        }


    @Test
    public void testSetInputFile() {
        System.out.println("This is testSetInputFile :");
        assertEquals(expectedResult[0], ((Boolean)commandGetter.setInputFile()).toString());
    }
    
    @Test
    public void testSetOperateFileType() {
        System.out.println("This is testSetOperateFileType :");
        assertEquals(expectedResult[1], ((Boolean)commandGetter.setOperateFileType()).toString());
    }


    @Test
    public void testSetOutFile() {
        System.out.println("This is testSetOutFile :");
        assertEquals(expectedResult[2], ((Boolean)commandGetter.setOutFile()).toString());
    }

    @Test
    public void testCheckScommand() {
        System.out.println("This is testCheckScommand :");
        assertEquals(expectedResult[3], ((Boolean)commandGetter.checkScommand()).toString());
    }

    @Test
    public void testCheckOcommand() {
        System.out.println("This is testCheckOcommand :");
        assertEquals(expectedResult[4], ((Boolean)commandGetter.checkOcommand()).toString());
    }

    
    @Test
    public void testSetStopFile() {
        System.out.println("This is testSetStopFile :");
        assertEquals(expectedResult[5], ((Boolean)commandGetter.setStopFile()).toString());
    }

}

 

其他具体代码详参gittee.

5.总结：

这次结对编程让我认识到结对编程是一个渐进的过程，有效的结对编程不是一天就能够做到的。结对编程是一个相互学习，相互磨合的渐进的过程。我们需要时间来适应这种新的开发模式。这次结对编程让我意识到有些时候还是1+1>2的，就是把很多复杂的工作分离成小工作，分工合作完成的时候，效率很快，但是在完整的开发过程中有时候是1+1<2的，那就是沟通不流畅的时候，这里的沟通指的是有时候不能坐在一起沟通，只能通过沟通工具沟通的时候，能够很明显感觉到需求说不出，或者是说出了对方理解不了的情况，这也是这个项目拖延得比较久的原因，今天大部分功能完成的时候，大家坐到一起时马上就解决了之前几天遗留的问题，项目运行也完成了，还有一些逻辑的优化、界面的友好度和一些小bug可以优化，但是不影响功能的完整运行。