Java的位图和布隆过滤器深入详细讲解

public class MyBitSet {
    private byte[] elem;
    private int usedSize;
    // 构造函数，初始化位图大小
    public MyBitSet(int n) {
        elem = new byte[n / 8 + 1]; // 位图大小：n个比特位
    }
    // 设置某一位为1，表示对应的值存在
    public void set(int val) {
        int arrayIndex = val / 8;
        int bitIndex = val % 8;
        elem[arrayIndex] |= (1 << bitIndex);
        usedSize++;
    }
    // 检查某个值是否存在
    public boolean get(int val) {
        int arrayIndex = val / 8;
        int bitIndex = val % 8;
        return (elem[arrayIndex] & (1 << bitIndex)) != 0;
    }
    // 重置某一位为0，表示对应的值不存在
    public void reSet(int val) {
        int arrayIndex = val / 8;
        int bitIndex = val % 8;
        elem[arrayIndex] &= ~(1 << bitIndex);
        usedSize--;
    }
    // 获取已使用的比特位数量
    public int getUsedSize() {
        return usedSize;
    }
}

import java.util.BitSet;
// 简单哈希类
class SimpleHash {
    private int cap; // 哈希表的大小
    private int seed; // 哈希种子
    // 构造函数，初始化哈希表大小和种子
    public SimpleHash(int cap, int seed) {
        this.cap = cap;
        this.seed = seed;
    }
    // 哈希函数
    public int hash(String value) {
        int result = 0;
        int len = value.length();
        // 遍历字符串的每一个字符
        for (int i = 0; i < len; i++) {
            result = seed * result + value.charAt(i); // 计算哈希值
        }
        // 返回哈希值与 cap-1 的位与操作结果
        return (cap - 1) & result;
    }
}
// 布隆过滤器类
public class BloomFilter {
    private static final int DEFAULT_SIZE = 1 << 24; // 位数组大小
    private static final int[] seeds = {5, 7, 11, 13, 31, 37, 61}; // 哈希种子
    private BitSet bits = new BitSet(DEFAULT_SIZE); // 位数组
    private SimpleHash[] func = new SimpleHash[seeds.length]; // 哈希函数数组
    // 构造函数，初始化哈希函数
    public BloomFilter() {
        for (int i = 0; i < seeds.length; i++) {
            func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]); // 根据种子初始化 SimpleHash
        }
    }
    // 插入数据
    public void set(String value) {
        for (SimpleHash f : func) {
            bits.set(f.hash(value)); // 使用每个哈希函数设置位
        }
    }
    // 查询数据是否存在
    public boolean contains(String value) {
        for (SimpleHash f : func) {
            if (!bits.get(f.hash(value))) {
                return false; // 只要有一个哈希函数返回 false，就说明不在集合中
            }
        }
        return true; // 有可能误判
    }
    // 主函数，用于测试
    public static void main(String[] args) {
        BloomFilter filter = new BloomFilter();
        filter.set("test"); // 插入字符串 "test"
        System.out.println(filter.contains("test")); // 输出: true，表示 "test" 存在
        System.out.println(filter.contains("hello")); // 输出: false，表示 "hello" 不存在
    }
}

// 假设我们有一个包含100亿个整数的文件，下面的代码实现了位图的简单应用
MyBitSet bitSet = new MyBitSet(10000000000);  // 10 billion bits
for (int num : nums) {
    if (!bitSet.get(num)) {
        bitSet.set(num);  // 如果没有出现过，设置为1
    } else {
        bitSet.reSet(num);  // 如果再次出现，重置为0
    }
}
// 遍历 bitSet，输出所有只出现一次的整数

BloomFilter filter = new BloomFilter();
for (String url : urls) {
    if (!filter.contains(url)) {
        // 处理未访问过的 URL
        filter.set(url);
    }
}