Algorithm 有没有一种方法可以根据这个实现给出的启发式定理来确定m？

Bloom提出了一种应用技术，如果应用“传统的”无错误散列技术，那么大量的源数据将需要大量不切实际的内存。他举了一个50万字字典的断字算法的例子，其中90%遵循简单的断字规则，但其余10%需要昂贵的磁盘访问来检索特定的断字模式

public class BloomFilter {
    int m;
    int k;
    HashSet<String> map = new HashSet<>();
    public BloomFilter(){
        int c = 100;
        float e = 0.1f;
        m = (int) Math.floor(  -1 * c * Math.log(e) / (Math.log(2)*Math.log(2)) ) + 1;
        k = (int) Math.floor( 0.7 * m / (float) c ) + 1;
    }
    private static int[] createHashes(String key, int hashes, int m) {
    byte[] data = key.getBytes();
    int[] result = new int[hashes];

    MessageDigest digestFunction;
    try {
        digestFunction = MessageDigest.getInstance("MD5");
    } catch (Exception e) {
        throw new RuntimeException();
    }

    int k = 0;
    byte salt = 0;
    while (k < hashes) {
        byte[] digest;

        digestFunction.update(salt);
        salt++;
        digest = digestFunction.digest(data);                

        for (int i = 0; i < digest.length / 4 && k < hashes; i++) {
            int h = 0;
            for (int j = (i * 4); j < (i * 4) + 4; j++) {
                h <<= 8;
                h |= ((int) digest[j]) & 0xFF;
            }
            result[k] = Math.abs(h % m);
            k++;
        }
    }
    return result;
    }
    public void add(String s){
        map.add(Arrays.toString(createHashes(s, k, m)));
    }
    public boolean contains(String s){
        return map.contains(Arrays.toString(createHashes(s, k, m)));
    }
}

公共类过滤器{
int m；
int k；
HashSet map=新的HashSet（）；
公共过滤器（）{
int c=100；
浮球e=0.1f；
m=（int）数学层（-1*c*Math.log（e）/（Math.log（2）*Math.log（2））+1；
k=（int）数学地板（0.7*m/（浮动）c）+1；
}
私有静态int[]createHashes（字符串键，int散列，int m）{
byte[]data=key.getBytes（）；
int[]结果=新的int[散列]；
消息摘要功能；
试一试{
digestFunction=MessageDigest.getInstance（“MD5”）；
}捕获（例外e）{
抛出新的RuntimeException（）；
}
int k=0；
字节salt=0；
while（k<散列）{
字节[]摘要；
功能更新（salt）；
salt++；
摘要=摘要函数。摘要（数据）；
for（int i=0；i
m=-（n lnp）/（（ln2）^2）

这意味着对于给定的误报概率p，Bloom过滤器的长度m与被过滤的元素数量n成比例[5]，而上述公式是渐近的（即适用于m，n→ ∞), 与m，n的有限值的一致性也很好

因此m—提交的比特数，基于所需的错误率。
From

m=-（n lnp）/（（ln2）^2）

这意味着对于给定的误报概率p，Bloom过滤器的长度m与被过滤的元素数量n成比例[5]，而上述公式是渐近的（即适用于m，n→ ∞), 与m，n的有限值的一致性也很好

因此，m—提交的位数是基于所需的误码率。
谢谢，但这并不是严格正确的，因为它假设设置的每个位的概率都是独立的。但是，假设这是一个近似值，则误报概率会随着m（数组中的位数）的减少而降低增加，并随着n（插入的图元数）的增加而增加增加。最佳bloom筛选器为50%集。高质量哈希算法应能保证这一点，但这并不是严格正确的，因为它假设设置的每个位的概率独立。但是，假设这是一个近似值，则误报概率降低为m（数组中的位数）增加，并随着n（插入元素的数量）的增加而增加。最佳布卢姆过滤器设置为50%。高质量的哈希算法应保证这一点