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

一：引入

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"));
	}
}