Java实现布隆过滤器：使用Guava库和自己实现的方法

布隆过滤器（Bloom Filter）是一种高效的数据结构，用于判断某个元素是否在一个集合中。它通过一个位数组和多个哈希函数来实现。当一个元素被加入到布隆过滤器中时，多个哈希函数会将其映射到位数组上的多个位置，并将这些位置的值设为1。当我们需要查询某个元素是否在布隆过滤器中时，我们对该元素进行多次哈希，检查每个哈希值对应的位数组位置是否都为1，若是则认为该元素可能存在于集合中。

在 Java 中，可以使用由 Google Guava 提供的 BloomFilter 类来实现布隆过滤器。下面是一个简单的示例：

首先，我们需要引入 Guava 的依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1-jre</version>
</dependency>

`
然后，在代码中创建 BloomFilter 对象并添加元素：

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

public class BloomFilterDemo {
    public static void main(String[] args) {
        // 创建一个能容纳10000个元素、误判率为0.01%的布隆过滤器
        BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 10000, 0.01);

        // 添加元素
        bloomFilter.put("hello");
        bloomFilter.put("world");

        // 查询元素
        System.out.println(bloomFilter.mightContain("hello")); // true
        System.out.println(bloomFilter.mightContain("world")); // true
        System.out.println(bloomFilter.mightContain("java"));  // false
    }
}

上述示例中，我们使用 stringFunnel() 来指定元素类型为字符串，create() 方法创建了一个能容纳10000个元素、误判率为0.01%的布隆过滤器，put() 方法添加了两个元素，mightContain() 方法用于查询某个元素是否在布隆过滤器中。

需要注意的是，布隆过滤器有一定的误判率，即在查询某个元素是否在布隆过滤器中时，有可能得到一个错误的结果。误判率与布隆过滤器的容量和哈希函数数量有关，一般可以通过调整这些参数来平衡误判率和空间占用。

不使用Gauava 库 实现

import java.util.BitSet;
import java.util.Random;

public class BloomFilter {
    private BitSet bitSet;                  // 位数组，用于存储布隆过滤器的状态
    private int bitSetSize;                 // 位数组的长度
    private int expectedNumberOfElements;   // 预期元素数量
    private int numberOfHashFunctions;      // 哈希函数数量
    private Random random = new Random();   // 用于生成哈希种子的伪随机数生成器

    public BloomFilter(int bitSetSize, int expectedNumberOfElements) {
        this.bitSetSize = bitSetSize;
        this.expectedNumberOfElements = expectedNumberOfElements;

        // 根据公式计算哈希函数数量
        this.numberOfHashFunctions = (int) Math.round((bitSetSize / expectedNumberOfElements) * Math.log(2.0));

        // 创建位数组并初始化所有位为0
        this.bitSet = new BitSet(bitSetSize);
    }

    public void add(Object element) {
        // 对元素进行多次哈希，并将对应的位设置为1
        for (int i = 0; i < numberOfHashFunctions; i++) {
            long hash = computeHash(element.toString(), i);
            int index = getIndex(hash);
            bitSet.set(index, true);
        }
    }

    public boolean contains(Object element) {
        // 对元素进行多次哈希，并检查所有哈希值所对应的位是否都被设置为1
        for (int i = 0; i < numberOfHashFunctions; i++) {
            long hash = computeHash(element.toString(), i);
            int index = getIndex(hash);

            if (!bitSet.get(index)) {
                return false;
            }
        }

        return true;
    }

    private int getIndex(long hash) {
        // 将哈希值映射到位数组的下标（需要确保下标非负）
        return Math.abs((int) (hash % bitSetSize));
    }

    private long computeHash(String element, int seed) {
        // 使用伪随机数生成器生成不同的哈希种子
        random.setSeed(seed);

        // 将元素转换为字节数组，并计算其哈希值
        byte[] data = element.getBytes();
        long hash = 0x7f52bed27117b5efL;

        for (byte b : data) {
            hash ^= random.nextInt();
            hash *= 0xcbf29ce484222325L;
            hash ^= b;
        }

        return hash;
    }
}

使用

    public static void main(String[] args) {


        List<String> strings = Arrays.asList("apple", "banana", "orange", "peach", "grape");
        BloomFilter filter = new BloomFilter(1000, 5);

        // 将所有字符串添加到布隆过滤器中
        for (String s : strings) {
            filter.add(s);
        }

        String[] queries = {"watermelon", "banana", "kiwi", "peach"};
        for (String query : queries) {
            System.out.println("是否包含:" + query + "-" + filter.contains(query));
        }


    }

这个实现中，BloomFilter() 构造方法用于创建一个布隆过滤器对象，需要指定位数组长度和预期元素数量。根据公式计算哈希函数数量，并使用BitSet类创建位数组。

add() 方法用于将元素添加到布隆过滤器中，对于每个要添加的元素，使用多个哈希函数计算出其哈希值，并将对应的位设置为1。

contains() 方法用于查询元素是否可能在布隆过滤器中，对于查询元素的操作，同样需要根据多个哈希函数计算出其哈希值，并检查所有哈希值所对应的位是否都被设置为1。

需要注意的是，在这个实现中使用了伪随机数生成器来生成不同的哈希函数，而不是使用真正的散列函数。因此，在实际应用中，可能需要使用更加复杂、安全的哈希函数。同时，由于布隆过滤器是基于概率的数据结构，因此误判率是可以控制但也不可避免的。

需要注意的是，布隆过滤器的误判率并不能为0，因此在使用时需要考虑到这一点。另外，如果布隆过滤器存储的元素数量过多，位数组可能会占用大量内存，因此需要根据实际情况调整预期元素数量和误判率等参数以平衡时间、空间和误判率。

总之，布隆过滤器是一种非常实用的数据结构，可以用于快速判断某个元素是否在一个集合中，具有较低的时间和空间复杂度，适合处理大规模数据。在 Java 中，可以通过自己实现布隆过滤器来实现该功能。(建议直接使用Gauava 库的布隆过滤器)