x,y,z不是同时往里边添加,一个一个的添加; 每一个元素它会分配到一系列的二进制位中。
假设x会分配3个二进制位,蓝色线表示, 把x插入布隆过滤器时即把x对应的这三个位置置为1就可以了。

y插入进来,根据它的哈希函数分为红色的这三条线所对应的二进制位,置为1。
同理z也置为1。
这个二进制的数组用来表示所有的已经存入的xyz是否已经在索引里边了。
重新插入一个x, 这时x始终会对应这3个蓝色的二进制位, 去表里查就查到这三个都是1, 所以我们认为x是存在的。
如果是一个陌生的元素w进来, 它把它分配给通过布隆过滤器的二进制索引的函数, w就得到灰色的这三个二进制位110, 有一个为0说明w未在索引里边。


只要布隆过滤器中有一个为0就说明这个元素不在布隆过滤器的索引里面, 且我们肯定它不在。
但比如又来一个元素q, 它刚好分配的三个二进制都为1, 我们不一定说它是存在的。 

结论：
当布隆过滤器把元素全部插入完之后, 对于测试(新来)的元素要验证它是否存在
当它验证这个元素所对应的二进制位是1时, 我们只能说它可能存在布隆过滤器里边。
但是当这个元素所对应的二进制位只要有一个不为1, 则它肯定不在。

---一个元素去布隆过滤器里边查, 如果查到它不存在, 那么它肯定就是不存在的。
                               如果查到它的二进制都是1,为存在的状态比如B,则它可能存在。
那我们到底怎么判断B这种元素是否存在呢? 
    布隆过滤器只是放在外边当一个缓存使用，来作为一个很快速的判断来使用
    当B查到了，布隆过滤器里边是存在的，则B会继续在这个机器上的数据库DB中来查询，去查询B是否存在。
    而C就会直接打到布隆过滤器里边，这样C就不用查询了节省了查询访问数据库的时间。
布隆过滤器只是挡在一台机器前边的快速查询的缓存。

class LRUCache(object): 
    def __init__(self, capacity): 
        self.dic = collections.OrderedDict() 
        self.remain = capacity 
    def get(self, key): 
        if key not in self.dic: 
            return -1 
        v = self.dic.pop(key) 
        self.dic[key] = v   # key as the newest one 
        return v 
    def put(self, key, value): 
        if key in 
            self.dic: self.dic.pop(key) 
        else: 
            if self.remain > 0: 
                self.remain -= 1 
            else:   # self.dic is full 
                self.dic.popitem(last=False) 
            self.dic[key] = value

    private Map<Integer, Integer> map;

    public LRUCache(int capacity) {
        map = new LinkedCappedHashMap<>(capacity);
    }
    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        return map.get(key);
    }
    public void put(int key, int value) {
        map.put(key, value);
    }

    private static class LinkedCappedHashMap<K, V> extends LinkedHashMap<K, V> {
        int maximumCapacity;

        LinkedCappedHashMap(int maximumCapacity) {
            // initialCapacity代表map的容量, loadFactor代表加载因子, accessOrder默认false,如果要按读取顺序排序需要将其设为true
            super(16, 0.75f, true);//default initial capacity (16) and load factor (0.75) and accessOrder (false)
            this.maximumCapacity = maximumCapacity;
        }
        /* 重写 removeEldestEntry()函数，就能拥有我们自己的缓存策略 */
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > maximumCapacity;
        }
    }