Java实现：运用字符串模式匹配算法，编程实现查重关键技术系统。给定两个字符串或两段文件，文件使用屏幕输入的方式，通过分解和比较，找出两个字符串相重复的字段或语句，输出重复字段和在两个文件中所处的位置，功能要求： 词语查重 语句查重 位置标注 重复率统计

好的，这是一个比较复杂的问题，需要一些时间来解答。首先，我们需要了解一下什么是字符串模式匹配算法。

字符串模式匹配算法是一种用于在一个文本串中查找一个模式串的算法。在这个问题中，我们需要比较两个字符串或两段文件中的重复部分。这些重复部分可以是单词、短语或整个句子。

常见的字符串模式匹配算法有朴素算法、KMP算法、Boyer-Moore算法等。

在本问题中，我们可以使用朴素算法来实现查重功能。具体实现步骤如下：

1. 将两个字符串或两段文件分别按照单词或句子分割成一个个小段落。

2. 对于每个小段落，使用朴素算法进行匹配。

3. 如果匹配成功，则记录下重复的部分以及在两个文件中的位置。

4. 统计所有重复的部分，计算重复率。

下面是一个Java实现的示例代码：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class StringMatch {

    public static void main(String[] args) throws IOException {
        String file1 = "file1.txt";
        String file2 = "file2.txt";
        List<String> list1 = readFile(file1);
        List<String> list2 = readFile(file2);
        Map<String, List<int[]>> map1 = new HashMap<>();
        Map<String, List<int[]>> map2 = new HashMap<>();
        for (int i = 0; i < list1.size(); i++) {
            String[] words = list1.get(i).split(" ");
            for (int j = 0; j < words.length; j++) {
                String word = words[j];
                if (!map1.containsKey(word)) {
                    map1.put(word, new ArrayList<>());
                }
                map1.get(word).add(new int[]{i, j});
            }
        }
        for (int i = 0; i < list2.size(); i++) {
            String[] words = list2.get(i).split(" ");
            for (int j = 0; j < words.length; j++) {
                String word = words[j];
                if (!map2.containsKey(word)) {
                    map2.put(word, new ArrayList<>());
                }
                map2.get(word).add(new int[]{i, j});
            }
        }
        double total = 0;
        int count = 0;
        for (String key : map1.keySet()) {
            if (map2.containsKey(key)) {
                List<int[]> list3 = map1.get(key);
                List<int[]> list4 = map2.get(key);
                for (int i = 0; i < list3.size(); i++) {
                    for (int j = 0; j < list4.size(); j++) {
                        int[] pos1 = list3.get(i);
                        int[] pos2 = list4.get(j);
                        if (match(list1, pos1[0], pos2[0]) && pos1[1] == pos2[1]) {
                            String str = getString(list1, pos1[0], pos2[0]);
                            System.out.println(str + " " + pos1[0] + " " + pos2[0]);
                            total += (double) str.length() / (double) list1.get(pos1[0]).length();
                            count++;
                        }
                    }
                }
            }
        }
        System.out.println("重复率：" + total / count);
    }

    private static List<String> readFile(String fileName) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(fileName));
        String line;
        List<String> list = new ArrayList<>();
        while ((line = reader.readLine()) != null) {
            list.add(line);
        }
        return list;
    }

    private static boolean match(List<String> list, int i, int j) {
        if (i == j) {
            return true;
        }
        String str1 = list.get(i);
        String str2 = list.get(j);
        return str1.equals(str2);
    }

    private static String getString(List<String> list, int i, int j) {
        StringBuilder builder = new StringBuilder();
        for (int k = i; k <= j; k++) {
            builder.append(list.get(k)).append(" ");
        }
        return builder.toString().trim();
    }
}

在这个示例代码中，我们首先读取了两个文件中的所有内容，并将它们按照单词分割成一个个小段落。

然后，我们使用两个Map来记录每个单词在两个文件中的出现位置。对于每个单词，我们记录下它在每个文件中的位置，以便后面进行匹配。

接下来，我们遍历第一个文件中的所有单词，如果这个单词在第二个文件中也出现过，就进行匹配。如果匹配成功，则记录下重复的部分以及在两个文件中的位置。

最后，我们统计所有重复的部分，计算重复率。

需要注意的是，在这个示例代码中，我们只是对每个单词进行了匹配，而没有考虑短语或整个句子的匹配。如果需要进行短语或整个句子的匹配，需要使用更为复杂的算法，如KMP算法或Boyer-Moore算法。