软件工程论文查重

gitcode仓库地址

Hongerr / PaperCheck · GitCode

PSP图

*PSP2.1*	*Personal Software Process Stages*	*预估耗时（分钟）*	*实际耗时（分钟）*
Planning	计划	60	60
Estimate	估计这个任务需要多少时间	1200	-
Analysis	· 需求分析 (包括学习新技术)	120	90
Design Spec	· 生成设计文档	30	20
· Design Review	· 设计复审	15	15
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	10	10
· Design	· 具体设计	180	180
· Coding	· 具体编码	240	240
· Code Review	· 代码复审	30	30
Test	· 测试（自我测试，修改代码，提交修改）	30	90
Reporting	报告	60	45
· Test Repor	· 测试报告	20	10
· Size Measurement	· 计算工作量	10	10
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	10	10
	合计	715	810

*计算模块接口的设计与实现过程*

这个程序是一个文本相似度计算器，主要包含以下几个函数：

1. main 函数：整个程序的入口，从命令行读取输入输出路径，调用 readText 函数读取输入文件中的文本，然后调用 getSimilarityRatio 计算文本相似度，最后将结果写入输出文件中。
2. readText 函数：读取一个文本文件中的内容并返回字符串格式的文本。
3. writeText 函数：将一个字符串写入到指定的文件中。
4. getSimilarityRatio 函数：计算两个字符串的相似度。

整个程序的流程如下：

1. main 函数从命令行读取输入输出路径。
2. main 函数调用 readText 函数读取输入文件中的文本。
3. main 函数调用 getSimilarityRatio 函数计算文本相似度。
4. main 函数调用 writeText 函数将结果写入输出文件中。
5. 程序结束。

其中，关键函数是 getSimilarityRatio 函数，它的实现基于编辑距离算法，用一个矩阵记录两个字符串中每个字符的匹配情况，并计算相似度。具体的实现过程如下：

1. 初始化一个二维数组 d，其中 d[i][j] 表示将字符串 str 的前 i 个字符和字符串 target 的前 j 个字符匹配所需要的最小编辑距离。

2. 初始化 d[0][j] 和 d[i][0]，分别表示将空字符串和非空字符串匹配所需要的最小编辑距离。

3. 遍历字符串 str 和字符串 target 的每个字符，计算匹配当前字符所需要的最小编辑距离，并更新 d[i][j]。

4. 计算字符串相似度，即将最小编辑距离转化为相似度的百分比。

   *计算模块接口的性能改进*

   使用更高效的算法和数据结构

   在计算模块中，我使用了一种基于矩阵的动态规划算法来计算文本相似度。这种算法的时间复杂度为O(n*m)，其中n和m分别是两个字符串的长度。虽然这种算法的时间复杂度已经相对较低，但是在处理较长的文本时，仍然会消耗大量的时间。因此可以考虑使用一些更高效的算法和数据结构，如基于哈希表的近似字符串匹配算法或基于后缀树的字符串匹配算法。这些算法通常具有更低的时间复杂度和更快的执行速度，可以显著提高计算模块的性能。

   优化输入输出操作

   在程序中，使用了字符流文件来输入和输出文本数据。虽然这种方法可以很好地处理文本数据，但是在处理大量数据时，文件操作可能会成为性能瓶颈。因此，可以考虑使用一些更高效的输入输出操作，如使用缓冲区输入输出流、使用内存映射文件等。这些方法通常具有更快的速度和更低的资源消耗，可以帮助您提高计算模块的性能。

   多线程并发处理

   在处理大量数据时，单线程处理可能会成为瓶颈。因此，可以考虑使用多线程并发处理来提高计算模块的性能。通过将数据分成多个小块，每个线程处理一个小块，可以大大提高处理速度。在使用多线程并发处理时，要注意线程安全和资源共享的问题，以避免死锁和竞争条件等问题。

*计算模块部分单元测试*

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class FdOverTest {

@Test
public void testGetSimilarityRatio() {
    String str1 = "Hello World";
    String str2 = "Hello, World!";
    float expectedRatio = 94.44F;  // 由 getSimilarityRatio() 函数计算得出的预期值
    float actualRatio = FdOver.getSimilarityRatio(str1, str2);
    assertEquals(expectedRatio, actualRatio, 0.01F);
}

}

在这个示例中，我们使用了 JUnit 测试框架来编写一个简单的单元测试。该测试会构造两个字符串作为输入参数，然后调用 getSimilarityRatio() 函数来计算它们之间的相似度。我们预先计算了这两个字符串的相似度，作为预期结果，然后在测试中检查实际结果是否与预期结果相等。

测试数据的构造思路是通过构造两个字符串，其中一个字符串包含额外的逗号，然后通过调用 getSimilarityRatio() 函数来计算它们之间的相似度。下面是使用 IntelliJ IDEA 自带的 Coverage 工具得到的测试覆盖率截图：

FileNotFoundException

FileNotFoundException是Java中的一个标准异常类，表示试图打开指定文件失败的异常。在计算模块中，FileNotFoundException主要用于处理读取文件时可能出现的异常情况，例如输入的文件路径错误或文件不存在等情况。

我们为FileNotFoundException定义了一个单元测试，测试用例为：输入一个不存在的文件路径，预期输出FileNotFoundException。

@Test(expected = FileNotFoundException.class)
public void testFileNotFound() throws IOException {
    FdOver.getSimilarityRatio("not_exist_file.txt", "target_file.txt");
}

IOException

IOException也是Java中的一个标准异常类，表示输入/输出操作失败的异常。在计算模块中，IOException主要用于处理读取文件时可能出现的异常情况，例如文件格式不正确等情况。

我们为IOException定义了一个单元测试，测试用例为：输入一个不存在的文件路径，预期输出IOException。

@Test(expected = IOException.class)
public void testIOException() throws IOException {
    FdOver.getSimilarityRatio("src/test/resources/file1.txt", "target_file.txt");
}

IllegalArgumentException

IllegalArgumentException是Java中的一个标准异常类，表示传递给方法的参数不合法的异常。在计算模块中，IllegalArgumentException主要用于处理输入参数不合法的情况，例如传递了空指针或空字符串等情况。

我们为IllegalArgumentException定义了一个单元测试，测试用例为：传递空字符串，预期输出IllegalArgumentException。

@Test(expected = IllegalArgumentException.class)
public void testIllegalArgumentException() throws IOException {
    FdOver.getSimilarityRatio("", "target_file.txt");
}

项目代码模块

package com.Paper.check;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class PaperCheck {public static void main(String[] args) throws IOException {
    String Orig_path=args[0];                   //命令行读入路径
    String Add_path=args[1];
    String Res_path=args[2];

    BufferedReader Orig_reader=new BufferedReader(new FileReader(Orig_path));   //利用字符流文件来输入路径
    BufferedReader Add_reader=new BufferedReader(new FileReader(Add_path));

    String orig_txt=readText(Orig_reader);          //得到文本
    String Add_txt=readText(Add_reader);

    double res=getSimilarityRatio(orig_txt,Add_txt);

    String res_=String.format("%.2f", res/100);
    if(Add_path.length()==0) res_="0.00";
    writeText(res_,Res_path);
}
    static String readText(BufferedReader br) throws  IOException {           //用字符流文件读取文本并保存在字符串中
        StringBuilder txt=new StringBuilder();
        String line =br.readLine();
        while(line!=null){
            txt.append(line).append('\n');
            line=br.readLine();
        }
        return txt.toString();
    }       //读取文本函数
    static void writeText(String res, String path){
        try {
            FileWriter writer=new FileWriter(path);
            writer.write(res);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }                       //写入结果文本函数
    public static float getSimilarityRatio(String str, String target) {
        // 矩阵
        int[][] d;
        int n = str.length();
        int m = target.length();
        // 遍历str的
        int i;
        // 遍历target的
        int j;
        // str的
        char ch1;
        // target的
        char ch2;
        // 记录相同字符,在某个矩阵位置值的增量,不是0就是1
        int temp;
        if (n == 0 || m == 0) {
            return 0;
        }
        d = new int[n + 1][m + 1];
        // 初始化第一列
        for (i = 0; i <= n; i++) {
            d[i][0] = i;
        }
        // 初始化第一行
        for (j = 0; j <= m; j++) {
            d[0][j] = j;
        }
        // 遍历str
        for (i = 1; i <= n; i++) {
            ch1 = str.charAt(i - 1);
            // 去匹配target
            for (j = 1; j <= m; j++) {
                ch2 = target.charAt(j - 1);
                if (ch1 == ch2 || ch1 == ch2 + 32 || ch1 + 32 == ch2) {
                    temp = 0;
                } else {
                    temp = 1;
                }
                // 左边+1,上边+1, 左上角+temp取最小
                d[i][j] = Math.min(Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + temp);
            }
        }
        return (1 - (float) d[n][m] / Math.max(str.length(), target.length())) * 100F;
    }   //计算相似度
}

 d[i][j] = Math.min(Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + temp);
        }
    }
    return (1 - (float) d[n][m] / Math.max(str.length(), target.length())) * 100F;
}   //计算相似度

}