1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

import java.io.*;

public class QQDuplicateRemover {

    // 43亿个连续数字需要约 512MB 内存
    private static final long MAX_QQ_NUMBER = 4300000000L;

    // 一个long有64位
    private final long[] bits;

    public QQDuplicateRemover() {
        // 计算需要多少个long才能装下43亿个bit
        int size = (int) (MAX_QQ_NUMBER / 64) + 1;
        this.bits = new long[size];
    }

    /**
     * 标记一个QQ号存在
     * @return 如果之前已经存在，返回 true；如果是新数据，返回 false
     */
    public boolean add(long qq) {
        int index = (int) (qq / 64); // 找到在哪个 long 元素里
        int position = (int) (qq % 64); // 找到在该 long 的哪一位 (0-63)

        long mask = 1L << position;

        // 检查这一位是否已经是 1
        if ((bits[index] & mask) != 0) {
            return true; // 已存在，即重复了
        }

        // 将该位置为 1
        bits[index] |= mask;
        return false; // 新数据
    }

    public static void main(String[] args) {
        QQDuplicateRemover remover = new QQDuplicateRemover();

        // 模拟大数据流式读取（假设从一个巨大的文件中一行行读取，不占用内存）
        String filePath = "huge_qq_list.txt";
        String outputPath = "unique_qq_list.txt";

        try (BufferedReader br = new BufferedReader(new FileReader(filePath));
             BufferedWriter bw = new BufferedWriter(new FileWriter(outputPath))) {

            String line;
            long duplicateCount = 0;

            while ((line = br.readLine()) != null) {
                if (line.trim().isEmpty()) continue;

                long qq = Long.parseLong(line.trim());

                // 去重核心：如果add返回false，说明是第一次见，写入新文件
                if (!remover.add(qq)) {
                    bw.write(String.valueOf(qq));
                    bw.newLine();
                } else {
                    duplicateCount++;
                }
            }
            System.out.println("去重完成！检测到重复QQ号数量: " + duplicateCount);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

const maxQQNumber = 4300000000

type QQBitMap struct {
	bits []uint64
}

func NewQQBitMap() *QQBitMap {
	// 计算需要多少个 uint64 元素
	size := (maxQQNumber / 64) + 1
	return &QQBitMap{
		bits: make([]uint64, size),
	}
}

// Add 标记一个QQ号存在
// 如果之前已经存在，返回 true；如果是新数据，返回 false
func (bm *QQBitMap) Add(qq uint64) bool {
	index := qq / 64
	position := qq % 64

	mask := uint64(1) << position

	// 检查该位是否已经是 1
	if (bm.bits[index] & mask) != 0 {
		return true // 已存在，重复
	}

	// 置为 1
	bm.bits[index] |= mask
	return false // 新数据
}

func main() {
	bitmap := NewQQBitMap()

	// 模拟流式读取大文件（不一次性加载到内存）
	inputFile, err := os.Open("huge_qq_list.txt")
	if err != nil {
		fmt.Println("打开文件失败:", err)
		return
	}
	defer inputFile.Close()

	outputFile, err := os.Create("unique_qq_list.txt")
	if err != nil {
		fmt.Println("创建输出文件失败:", err)
		return
	}
	defer outputFile.Close()

	scanner := bufio.NewScanner(inputFile)
	writer := bufio.NewWriter(outputFile)
	defer writer.Flush()

	duplicateCount := 0

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue
		}

		qq, err := strconv.ParseUint(line, 10, 64)
		if err != nil {
			continue
		}

		// 去重判断
		if !bitmap.Add(qq) {
			_, _ = writer.WriteString(strconv.FormatUint(qq, 10) + "\n")
		} else {
			duplicateCount++
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("读取过程中发生错误:", err)
	}

	fmt.Printf("去重完成！检测到重复QQ号数量: %d\n", duplicateCount)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Write};

const MAX_QQ_NUMBER: u64 = 4_300_000_000;

struct QQBitMap {
    bits: Vec<u64>,
}

impl QQBitMap {
    fn new() -> Self {
        let size = (MAX_QQ_NUMBER / 64) as usize + 1;
        // 分配 512MB 的连续堆内存，初始化为 0
        Self { bits: vec![0; size] }
    }

    /// 标记一个QQ号存在
    /// 如果之前已经存在，返回 true；如果是新数据，返回 false
    fn add(&mut self, qq: u64) -> bool {
        let index = (qq / 64) as usize;
        let position = (qq % 64) as u32;

        let mask = 1u64 << position;

        if (self.bits[index] & mask) != 0 {
            true // 已存在
        } else {
            self.bits[index] |= mask;
            false // 新数据
        }
    }
}

fn main() -> io::Result<()> {
    let mut bitmap = QQBitMap::new();

    let input_file = File::open("huge_qq_list.txt")?;
    let reader = BufReader::new(input_file);

    let output_file = File::create("unique_qq_list.txt")?;
    let mut writer = BufWriter::new(output_file);

    let mut duplicate_count = 0;

    for line in reader.lines() {
        let line = line?;
        let trimmed = line.trim();
        if trimmed.is_empty() {
            continue;
        }

        if let Ok(qq) = trimmed.parse::<u64>() {
            if !bitmap.add(qq) {
                writeln!(writer, "{}", qq)?;
            } else {
                duplicate_count += 1;
            }
        }
    }

    // 显式刷新缓冲区
    writer.flush()?;
    println!("去重完成！检测到重复QQ号数量: {}", duplicate_count);

    Ok(())
}

1
2

[dependencies]
roaring = "0.10"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

use roaring::RoaringTreemap; // 支持 64 位整数的 Roaring Bitmap
use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Write};

fn main() -> io::Result<()> {
    // 实例化一个支持 u64 范围的压缩位图
    let mut bitmap = RoaringTreemap::new();

    let reader = BufReader::new(File::open("huge_qq_list.txt")?);
    let mut writer = BufWriter::new(File::create("unique_qq_list.txt")?);
    let mut duplicate_count = 0;

    for line in reader.lines() {
        let line = line?;
        let trimmed = line.trim();
        if trimmed.is_empty() {
            continue;
        }

        if let Ok(qq) = trimmed.parse::<u64>() {
            // bitmap.insert 如果原本不存在会返回 true，存在则返回 false
            if bitmap.insert(qq) {
                writeln!(writer, "{}", qq)?;
            } else {
                duplicate_count += 1;
            }
        }
    }

    writer.flush()?;
    println!("去重完成！检测到重复QQ号数量: {}", duplicate_count);
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 需要引入 Guava 依赖
// com.google.common.hash.BloomFilter;

long expectedInsertions = 4000000000L; // 40亿
double fpp = 0.01; // 允许 1% 的误判率

// Guava 会根据数据量和误判率自动计算并分配最省内存的 Bit 数组
BloomFilter<Long> filter = BloomFilter.create(
    Funnels.longFunnel(),
    expectedInsertions,
    fpp
);

// 判断与插入
if (filter.mightContain(qq)) {
    // 可能是重复数据（有1%概率误判）
} else {
    filter.put(qq); // 绝对是新数据，留下来
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

[ 客户端 ] --( 上传 Excel )--> [ Controller 接收并落盘临时文件 ]
                                        |
                               ( 异步触发，返回 TaskID )
                                        |
                                        v
                            [ EasyExcel 流式解析 (单线程) ]
                                        |
                            ( 每解析 2000 条，执行本地校验 )
                                        |
                                        v
                            [ 提交给自定义线程池 (多线程并行) ]
                               /        |        \
                        [Thread-1]  [Thread-2]  [Thread-3]
                            |           |           |
               (批量DB校验 + writeBatchedStatements 批量写入)
                            \           |           /
                                        v
                             [ 数据库 (MySQL/PgSQL) ]
                                        |
                           (如果有失败行 -> 写入错误日志)
                                        |
                                        v
                             [ 导出 error.xlsx 供用户下载 ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TopWords {
    public static void main(String[] args) {
        String filePath = "large_file.txt";
        Map<String, Long> wordCounts = new HashMap<>(1024 * 1024); // 预估初始容量减少扩容
        Pattern pattern = Pattern.compile("[a-zA-Z]+"); // 仅匹配英文字母

        // 1. 流式读取与计数
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath), 8 * 1024 * 1024)) { // 8MB Buffer
            String line;
            while ((line = reader.readLine()) != null) {
                Matcher matcher = pattern.matcher(line);
                while (matcher.find()) {
                    String word = matcher.group().toLowerCase(); // 统一转小写
                    wordCounts.put(word, wordCounts.getOrDefault(word, 0L) + 1);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 2. 最小堆获取 Top 100
        PriorityQueue<Map.Entry<String, Long>> minHeap = new PriorityQueue<>(
            100, Comparator.comparingLong(Map.Entry::getValue)
        );

        for (Map.Entry<String, Long> entry : wordCounts.entrySet()) {
            if (minHeap.size() < 100) {
                minHeap.add(entry);
            } else if (entry.getValue() > minHeap.peek().getValue()) {
                minHeap.poll();
                minHeap.add(entry);
            }
        }

        // 3. 输出结果
        List<Map.Entry<String, Long>> result = new ArrayList<>(minHeap);
        result.sort((e1, e2) -> Long.compare(e2.getValue(), e1.getValue())); // 降序排列
        result.forEach(e -> System.out.println(e.getKey() + ": " + e.getValue()));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

                    [ 2GB 大文件 ]
                          |
            +-------------+-------------+  (步骤 1: 内存不放大的 Hash 分流)
            |             |             |
       [小文件 0]     [小文件 1]   ... [小文件 63]
            |             |             |
        (内存 Map)     (内存 Map)     (内存 Map)   (步骤 2: 分别统计各小文件的 Top 100)
            |             |             |
       [Top 100]     [Top 100]    ...  [Top 100]
            \             |             /
             +------------+------------+   (步骤 3: 汇总到总的最小堆，滤出全局 Top 100)
                          |
                   [ 全局 Top 100 ]

1

cat large_file.txt | tr -cs 'a-zA-Z' '[\n*]' | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr | head -n 100