当前位置：首页 > news >正文

数据结构与算法之Set布隆过滤器

news 来源：原创 2025/4/23 14:27:30

一：引入

1.常见的基础数据存储容器有哪些？基础数据结构：数组+链表+map+set（树）

2.假设给你一个10亿的黑名单email，如何来进行黑名单过滤？垃圾邮件：HashMap 或者 Hash算法白名单

3.缓存相信大家都知道，但是缓存并不是百分百命中的，通常我们会根据一个id（字符串uuid）判断缓存里面有没有数据，如果没有再去数据库查询，那你有没有想过突然来了一个超级并发去查询一个缓存不存在的id怎么办？缓存击穿：分布式锁： bitMap：

二：set数据结构

        Set是一种数据结构，它的特点是里面所存的元素是不能重复的。C++ 在Java中主要有两种实现方式： hashMap key-value Set：key

        HashSet：其内部是一个Hash表（HashMap）实现，不能保证元素的顺序。但是如过是Integer类型的其实在jdk1.8是有序的，大家可以去看看源码，Integher.HashCode返回就知道为啥了.

        TreeSet：使用元素的自然顺序进行排序，当然你也可以自己指定排序的规则。其底层是通过二叉树实现的，也就是红黑树。

三：各种容器对比

        我们到目前为止主要的容器存储结构有：

        List：可以重复存储对象插入的顺序和遍历的顺序是一致的常用的实现方式：链表+数组（ArrayList,LinkedList,Vector）

        Set：不允许重复对象无法保证每个元素的插入和输出顺序，无序容器。 TreeSet是有序的常用的实现方式：HashSet，TreeSet，LinkedHashSet（强行保证输出顺序和插入顺序一致，双向链表，耗费空间）

        Map：Map是键值对的形式存储，会有key+value： Map不允许出现相同的key，出现就会倍覆盖 Map主要实现方式：HashMap，HashTable，TreeMap（也是一个有序的，默认按照自然顺序，其底层结构同样是红黑树）

四：布隆过滤器

        布隆过滤器是一个非常巧妙的数据结构，在很多高并发大数据项目中都有应用，它的特点就是高效的查找和插入，他的核心一句话就是：我告诉你不存在的那就肯定不存在，但是我告诉你存在，其实有可能存在的。嘿嘿~~ 布隆过滤器结构：它的结构和我们上节课讲的bitMap非常类似。它是由一个很长的bit数组以及k个hash函数组成。

实现的思想：

        插入：将一个插入的元素使用K个hash函数进行k次计算，将得到的Hash值所对应的bit数组下标置为1。

        查找：跟插入一样的道理，将查找的元素使用k个函数进行k次计算，将得到的值找出对应的bit数组下标，判断是否为1，如果都为1则说明这个值可能在序列中，反之肯定不在序列中。为什么是可能在序列中呢？

        删除：非常明确的告诉你，这玩意是不支持删除的。

package tree.set布隆过滤器;

import java.util.BitSet;

public class BloomFilter {

	int size;
	BitSet bits; // bit数组,bitMap: long /64 %34
					// 00000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111

	public BloomFilter(int size) {
		this.size = size;
		bits = new BitSet(size);
	}

	public void add(String key) {	//O(1)
		int hash1 = hash_1(key);
		int hash2 = hash_2(key);
		int hash3 = hash_3(key);

		bits.set(hash1, true);
		bits.set(hash2, true);
		bits.set(hash3, true);
	}

	public boolean find(String key) {
		int hash1 = hash_1(key);
		if (!bits.get(hash1))
			return false;
		int hash2 = hash_2(key);
		if (!bits.get(hash2))
			return false;
		int hash3 = hash_3(key);
		if (!bits.get(hash3))
			return false;

		return true;
	}

	public int hash_1(String key) {
		int hash = 0;
		int i;
		for (i = 0; i < key.length(); ++i) {
			hash = 33 * hash + key.charAt(i);
		}
		return Math.abs(hash) % size;
	}

	public int hash_2(String key) {
		final int p = 16777619;
		int hash = (int) 2166136261L;
		for (int i = 0; i < key.length(); i++) {
			hash = (hash ^ key.charAt(i)) * p;
		}
		hash += hash << 13;
		hash ^= hash >> 7;
		hash += hash << 3;
		hash ^= hash >> 17;
		hash += hash << 5;
		return Math.abs(hash) % size;
	}

	public int hash_3(String key) {
		int hash, i;
		for (hash = 0, i = 0; i < key.length(); ++i) {
			hash += key.charAt(i);
			hash += (hash << 10);
			hash ^= (hash >> 6);
		}
		hash += (hash << 3);
		hash ^= (hash >> 11);
		hash += (hash << 15);
		return Math.abs(hash) % size;
	}

	public static void main(String[] args) {
		// O(1000000000)
		//8bit= 1byte
		BloomFilter bloomFilter = new BloomFilter(Integer.MAX_VALUE);	//21亿
		System.out.println(bloomFilter.hash_1("1"));
		System.out.println(bloomFilter.hash_2("1"));
		System.out.println(bloomFilter.hash_3("1"));
		
		
		bloomFilter.add("1111");
		bloomFilter.add("1123");
		bloomFilter.add("11323");
		
		System.out.println(bloomFilter.find("1"));
		System.out.println(bloomFilter.find("1123"));
	}
}