局域网监控网页中的布隆过滤器Java语言算法

import java.nio.charset.StandardCharsets;
import com.google.common.hash.Hashing;
/**
 * 适用于局域网监控网页的布隆过滤器实现
 * 用于合法设备IP地址的快速校验与非法设备拦截
 */
public class BloomFilterForLanMonitor {
    // 二进制位数组（采用long数组减少内存占用，每个long对应64位）
    private final long[] bitArray;
    // 位数组总长度（单位：位）
    private final int bitSize;
    // 哈希函数个数
    private final int hashCount;
    /**
     * 构造方法：根据预期元素数量和可接受误判率初始化布隆过滤器
     * @param expectedNum 预期存储的元素数量（如局域网合法设备总数）
     * @param falsePositiveRate 可接受误判率（如0.01表示1%）
     */
    public BloomFilterForLanMonitor(int expectedNum, double falsePositiveRate) {
        if (expectedNum <= 0 || falsePositiveRate <= 0 || falsePositiveRate >= 1) {
            throw new IllegalArgumentException("参数不合法：预期元素数需大于0，误判率需在(0,1)区间");
        }
        // 计算最优位数组长度m
        this.bitSize = (int) Math.ceil(-expectedNum * Math.log(falsePositiveRate) / Math.pow(Math.log(2), 2));
        // 计算最优哈希函数个数k
        this.hashCount = (int) Math.ceil(Math.log(2) * bitSize / expectedNum);
        // 初始化位数组（long数组长度 = 总位数 / 64，向上取整）
        this.bitArray = new long[(bitSize + 63) >> 6];
    }
    /**
     * 插入元素（如合法设备IP地址）
     * @param element 待插入元素
     */
    public void add(String element) {
        if (element == null) {
            throw new NullPointerException("待插入元素不能为空");
        }
        // 生成两个不同的哈希值，通过组合得到k个哈希索引（减少哈希函数数量，提升性能）
        long hash1 = hash(element, 0);
        long hash2 = hash(element, 1);
        for (int i = 0; i < hashCount; i++) {
            // 计算第i个哈希索引
            long index = (hash1 + i * hash2) % bitSize;
            // 将对应位设置为1（位运算优化）
            bitArray[(int) (index >> 6)] |= 1L << (index & 63);
        }
    }
    /**
     * 查询元素是否可能存在（用于局域网监控网页设备校验）
     * @param element 待查询元素（如接入设备IP地址）
     * @return true：可能存在（合法设备），false：一定不存在（非法设备）
     */
    public boolean contains(String element) {
        if (element == null) {
            return false;
        }
        long hash1 = hash(element, 0);
        long hash2 = hash(element, 1);
        for (int i = 0; i < hashCount; i++) {
            long index = (hash1 + i * hash2) % bitSize;
            // 检查对应位是否为1，若有一位为0则元素一定不存在
            if ((bitArray[(int) (index >> 6)] & (1L << (index & 63))) == 0) {
                return false;
            }
        }
        return true;
    }
    /**
     * 哈希函数：基于MurmurHash3实现，生成指定种子的哈希值
     * @param element 待哈希元素
     * @param seed 哈希种子
     * @return 哈希值
     */
    private long hash(String element, int seed) {
        return Hashing.murmur3_128(seed)
                .hashString(element, StandardCharsets.UTF_8)
                .asLong();
    }
    // 测试方法：模拟局域网监控网页设备校验场景
    public static void main(String[] args) {
        // 初始化：预期1000个合法设备，误判率0.01
        BloomFilterForLanMonitor filter = new BloomFilterForLanMonitor(1000, 0.01);
        // 插入合法设备IP
        filter.add("192.168.1.101");
        filter.add("192.168.1.102");
        filter.add("192.168.1.103");
        // 模拟设备接入校验（局域网监控网页核心流程）
        String accessIp1 = "192.168.1.101";
        String accessIp2 = "192.168.1.200";
        System.out.println("设备" + accessIp1 + "校验结果：" + (filter.contains(accessIp1) ? "合法（允许接入）" : "非法（拦截）"));
        System.out.println("设备" + accessIp2 + "校验结果：" + (filter.contains(accessIp2) ? "合法（允许接入）" : "非法（拦截）"));
    }
}