使用Java删除文件中的重复行

Question

作为我正在处理的项目的一部分，我想清理我生成的重复行条目的文件。 然而，这些重复通常不会彼此靠近。 我想出了一种在 Java 中这样做的方法（它基本上制作了文件的副本，然后使用嵌套的 while 语句将一个文件中的每一行与另一个文件的其余部分进行比较）。 问题是我生成的文件非常大而且文本很重（大约 225k 行文本，大约 40 兆字节）。 我估计我目前的流程需要 63 小时！ 这是绝对不能接受的。

但是，我需要一个集成的解决方案。 最好是Java。 有任何想法吗？ 谢谢！

Answer 1

嗯... 40 兆似乎足够小，您可以构建一Set线条，然后将它们全部打印出来。 这比做 O(n ² ) I/O 工作要快得多。

它会是这样的（忽略异常）：

public void stripDuplicatesFromFile(String filename) {
    BufferedReader reader = new BufferedReader(new FileReader(filename));
    Set<String> lines = new HashSet<String>(10000); // maybe should be bigger
    String line;
    while ((line = reader.readLine()) != null) {
        lines.add(line);
    }
    reader.close();
    BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
    for (String unique : lines) {
        writer.write(unique);
        writer.newLine();
    }
    writer.close();
}

如果顺序很重要，您可以使用LinkedHashSet而不是HashSet 。 由于元素是通过引用存储的，与实际数据量相比，额外链表的开销应该是微不足道的。

编辑：正如 Workshop Alex 所指出的，如果您不介意制作一个临时文件，您可以在阅读时简单地打印出这些行。 这允许您使用简单的HashSet而不是LinkedHashSet 。 但我怀疑您是否会注意到像这样的 I/O 绑定操作的不同之处。

Answer 2

好的，大多数答案都有些愚蠢和缓慢，因为它涉及向某些哈希集或其他内容添加行，然后再次将其从该集移回。 让我用伪代码展示最佳解决方案：

Create a hashset for just strings.
Open the input file.
Open the output file.
while not EOF(input)
  Read Line.
  If not(Line in hashSet)
    Add Line to hashset.
    Write Line to output.
  End If.
End While.
Free hashset.
Close input.
Close output.

请伙计们，不要让它变得比需要的更困难。 :-) 甚至不用理会排序，你不需要。

Answer 3

类似的方法

public void stripDuplicatesFromFile(String filename) {
    IOUtils.writeLines(
        new LinkedHashSet<String>(IOUtils.readLines(new FileInputStream(filename)),
        "\n", new FileOutputStream(filename + ".uniq"));
}

Answer 4

像这样的事情，也许：

BufferedReader in = ...;
Set<String> lines = new LinkedHashSet();
for (String line; (line = in.readLine()) != null;)
    lines.add(line); // does nothing if duplicate is already added
PrintWriter out = ...;
for (String line : lines)
    out.println(line);

LinkedHashSet保持插入顺序，而不是HashSet （虽然查找/插入速度稍快）将重新排序所有行。

Answer 5

您可以使用集合库中的 Set 来存储读取文件时的唯一可见值。

Set<String> uniqueStrings = new HashSet<String>();

// read your file, looping on newline, putting each line into variable 'thisLine'

    uniqueStrings.add(thisLine);

// finish read

for (String uniqueString:uniqueStrings) {
  // do your processing for each unique String
  // i.e. System.out.println(uniqueString);
}

Answer 6

如果顺序无关紧要，最简单的方法是编写 shell 脚本：

<infile sort | uniq > outfile

Answer 7

尝试一个简单的 HashSet 来存储您已经阅读的行。 然后遍历文件。 如果您遇到重复项，它们将被简单地忽略（因为 Set 只能包含每个元素一次）。

Answer 8

• 读入文件，存储行号和行：O(n)
• 按字母顺序排序：O(n log n)
• 删除重复项：O(n)
• 将其排序为其原始行号顺序：O(n log n)

Answer 9

Hash Set 方法没问题，但您可以调整它，使其不必将所有字符串存储在内存中，而是将逻辑指针存储在文件中的位置，以便您可以仅在需要时返回读取实际值。

另一种创造性的方法是将行号附加到每一行，然后对所有行进行排序，删除重复项（忽略应该是数字的最后一个标记），然后根据最后一个标记再次对文件进行排序并将其剥离在输出中。

Answer 10

我对这个有效的解决方案做了两个假设：

1. 有一个相当于 line 的 Blob，或者我们可以将其作为二进制处理
2. 我们可以保存偏移量或指向每行开头的指针。

基于这些假设的解决方案是： 1.读取一行，将哈希图中的长度保存为 key ，因此我们有更轻的哈希图。 将列表保存为 hashmap 中所有具有 key 中提到的长度的行的条目。 构建这个哈希图是 O(n)。 在映射哈希图中每一行的偏移量时，将行 blob 与此键长度的行（偏移量）列表中的所有现有条目进行比较，除了条目 -1 作为偏移量。如果发现重复，则删除两行并保存偏移量 - 1 在列表中的那些地方。

因此，请考虑复杂性和内存使用情况：

Hashmap 内存，空间复杂度 = O(n)，其中 n 是行数

时间复杂度 - 如果没有重复但所有等长的线都考虑到每条线的长度 = m，考虑线数 =n 那么那就是 O(n)。 由于我们假设我们可以比较 blob ，因此 m 无关紧要。 那是最坏的情况。

在其他情况下，我们节省了比较，尽管我们在 hashmap 中几乎不需要额外的空间。

此外，我们可以在服务器端使用 mapreduce 来拆分集合并稍后合并结果。 并使用长度或行首作为映射器键。

Answer 11

void deleteDuplicates(File filename) throws IOException{
    @SuppressWarnings("resource")
    BufferedReader reader = new BufferedReader(new FileReader(filename));
    Set<String> lines = new LinkedHashSet<String>();
    String line;
    String delims = " ";
    System.out.println("Read the duplicate contents now and writing to file");
    while((line=reader.readLine())!=null){
        line = line.trim(); 
        StringTokenizer str = new StringTokenizer(line, delims);
        while (str.hasMoreElements()) {
            line = (String) str.nextElement();
            lines.add(line);
            BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
            for(String unique: lines){
                writer.write(unique+" ");               
            }
            writer.close();
        }
    }
    System.out.println(lines);
    System.out.println("Duplicate removal successful");
}

Answer 12

这些答案都依赖于文件足够小以存储在内存中。

如果可以对文件进行排序，则此算法可用于任何大小的文件。

你需要这个库： https : //github.com/lemire/externalsortinginjava

我假设你从一个文件fileDumpCsvFileUnsorted开始，你最终会得到一个新的文件fileDumpCsvFileSorted ，它已经排序并且没有重复。

ExternalSort.sort(fileDumpCsvFileUnsorted, fileDumpCsvFileSorted);
int numDupes = 0;
File dupesRemoved = new File(fileDumpCsvFileSorted.getAbsolutePath() + ".nodupes");
String previousLine = null;
try (FileWriter fw = new FileWriter(dupesRemoved);
     BufferedWriter bw = new BufferedWriter(fw);
     FileReader fr = new FileReader(fileDumpCsvFileSorted);
     LineIterator lineIterator = new LineIterator(fr)
) {
  while (lineIterator.hasNext()) {
    String nextLine = lineIterator.nextLine();
    if (StringUtils.equals(nextLine, previousLine)) {
      ++numDupes;
      continue;
    }
    bw.write(String.format("%s%n", nextLine));
    previousLine = nextLine;
  }
}
logger.info("Removed {} dupes from {}", numDupes, fileDumpCsvFileSorted.getAbsolutePath());
FileUtils.deleteQuietly(fileDumpCsvFileSorted);
FileUtils.moveFile(dupesRemoved, fileDumpCsvFileSorted);

现在创建的文件fileDumpCsvFileSorted已排序，没有fileDumpCsvFileSorted 。

Answer 13

如果您可以使用 UNIX shell 命令，您可以执行以下操作：

for(i = line 0 to end)
{
    sed 's/\$i//2g' ; deletes all repeats
}

这将遍历您的整个文件，并且每次 sed 调用仅传递每个唯一的事件一次。 这样，您就不必进行以前做过的大量搜索。

Answer 14

有两种可扩展的解决方案，其中可扩展是指磁盘而不是基于内存，这取决于过程是否稳定，其中稳定是指删除重复项后的顺序是相同的。 如果可扩展性不是问题，那么只需将内存用于相同类型的方法。

对于不稳定的解决方案，首先对磁盘上的文件进行排序。 这是通过将文件拆分为较小的文件，在内存中对较小的块进行排序，然后按排序顺序合并文件来完成的，其中合并会忽略重复项。

通过只比较每个文件中的当前行，合并本身几乎可以不使用内存来完成，因为保证下一行更大。

稳定的解决方案稍微有点棘手。 首先，像以前一样对文件进行分块排序，但在每一行中指明原始行号。 然后，在“合并”期间不要费心存储结果，只需删除要删除的行号。

然后逐行复制原始文件，忽略上面存储的行号。

Answer 15

这些行以何种顺序出现以及您指望看到多少重复是否重要？

如果没有，并且如果您指望大量重复（即读多于写），我还会考虑并行化 hashset 解决方案，将 hashset 作为共享资源。