Class BloomFilter<T>
 java.lang.Object

 com.google.common.hash.BloomFilter<T>

 Type Parameters:
T
 the type of instances that theBloomFilter
accepts
 All Implemented Interfaces:
Predicate<T>
,Serializable
@Beta public final class BloomFilter<T> extends Object implements Predicate<T>, Serializable
A Bloom filter for instances ofT
. A Bloom filter offers an approximate containment test with onesided error: if it claims that an element is contained in it, this might be in error, but if it claims that an element is not contained in it, then this is definitely true.If you are unfamiliar with Bloom filters, this nice tutorial may help you understand how they work.
The false positive probability (
FPP
) of a bloom filter is defined as the probability that mightContain(Object) will erroneously returntrue
for an object that has not actually been put in theBloomFilter
. Since:
 11.0
 See Also:
 Serialized Form


Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description boolean
apply(T input)
Equivalent tomightContain(T)
; provided only to satisfy thePredicate
interface.BloomFilter<T>
copy()
Creates a newBloomFilter
that's a copy of this instance.static <T> BloomFilter<T>
create(Funnel<T> funnel, int expectedInsertions)
Creates aBloomFilter
with the expected number of insertions and a default expected false positive probability of 3%.static <T> BloomFilter<T>
create(Funnel<T> funnel, int expectedInsertions, double fpp)
Creates aBloomFilter
with the expected number of insertions and expected false positive probability.boolean
equals(Object object)
Indicates whether another object is equal to this predicate.double
expectedFpp()
Returns the probability that mightContain(Object) will erroneously returntrue
for an object that has not actually been put in theBloomFilter
.int
hashCode()
boolean
isCompatible(BloomFilter<T> that)
Determines whether a given bloom filter is compatible with this bloom filter.boolean
mightContain(T object)
Returnstrue
if the element might have been put in this Bloom filter,false
if this is definitely not the case.boolean
put(T object)
Puts an element into thisBloomFilter
.void
putAll(BloomFilter<T> that)
Combines this bloom filter with another bloom filter by performing a bitwise OR of the underlying data.



Method Detail

copy
public BloomFilter<T> copy()
Creates a newBloomFilter
that's a copy of this instance. The new instance is equal to this instance but shares no mutable state. Since:
 12.0

mightContain
public boolean mightContain(T object)
Returnstrue
if the element might have been put in this Bloom filter,false
if this is definitely not the case.

apply
public boolean apply(T input)
Equivalent tomightContain(T)
; provided only to satisfy thePredicate
interface. When using a reference of typeBloomFilter
, always invokemightContain(T)
directly instead.

put
public boolean put(T object)
Puts an element into thisBloomFilter
. Ensures that subsequent invocations ofmightContain(Object)
with the same element will always returntrue
. Returns:
 true if the bloom filter's bits changed as a result of this operation. If the bits
changed, this is definitely the first time
object
has been added to the filter. If the bits haven't changed, this might be the first timeobject
has been added to the filter. Note thatput(t)
always returns the opposite result to whatmightContain(t)
would have returned at the time it is called."  Since:
 12.0 (present in 11.0 with
void
return type})

expectedFpp
public double expectedFpp()
Returns the probability that mightContain(Object) will erroneously returntrue
for an object that has not actually been put in theBloomFilter
.Ideally, this number should be close to the
fpp
parameter passed in create(Funnel, int, double), or smaller. If it is significantly higher, it is usually the case that too many elements (more than expected) have been put in theBloomFilter
, degenerating it. Since:
 14.0 (since 11.0 as expectedFalsePositiveProbability())

isCompatible
public boolean isCompatible(BloomFilter<T> that)
Determines whether a given bloom filter is compatible with this bloom filter. For two bloom filters to be compatible, they must: not be the same instance
 have the same number of hash functions
 have the same bit size
 have the same strategy
 have equal funnels
 Parameters:
that
 The bloom filter to check for compatibility. Since:
 15.0

putAll
public void putAll(BloomFilter<T> that)
Combines this bloom filter with another bloom filter by performing a bitwise OR of the underlying data. The mutations happen to this instance. Callers must ensure the bloom filters are appropriately sized to avoid saturating them. Parameters:
that
 The bloom filter to combine this bloom filter with. It is not mutated. Throws:
IllegalArgumentException
 ifisCompatible(that) == false
 Since:
 15.0

equals
public boolean equals(@Nullable Object object)
Description copied from interface:Predicate
Indicates whether another object is equal to this predicate.Most implementations will have no reason to override the behavior of
Object.equals(java.lang.Object)
. However, an implementation may also choose to returntrue
wheneverobject
is aPredicate
that it considers interchangeable with this one. "Interchangeable" typically means thatthis.apply(t) == that.apply(t)
for allt
of typeT
). Note that afalse
result from this method does not imply that the predicates are known not to be interchangeable.

create
public static <T> BloomFilter<T> create(Funnel<T> funnel, int expectedInsertions, double fpp)
Creates aBloomFilter
with the expected number of insertions and expected false positive probability.Note that overflowing a
BloomFilter
with significantly more elements than specified, will result in its saturation, and a sharp deterioration of its false positive probability.The constructed
BloomFilter<T>
will be serializable if the providedFunnel<T>
is.It is recommended that the funnel be implemented as a Java enum. This has the benefit of ensuring proper serialization and deserialization, which is important since
equals(java.lang.Object)
also relies on object identity of funnels. Parameters:
funnel
 the funnel of T's that the constructedBloomFilter<T>
will useexpectedInsertions
 the number of expected insertions to the constructedBloomFilter<T>
; must be positivefpp
 the desired false positive probability (must be positive and less than 1.0) Returns:
 a
BloomFilter

create
public static <T> BloomFilter<T> create(Funnel<T> funnel, int expectedInsertions)
Creates aBloomFilter
with the expected number of insertions and a default expected false positive probability of 3%.Note that overflowing a
BloomFilter
with significantly more elements than specified, will result in its saturation, and a sharp deterioration of its false positive probability.The constructed
BloomFilter<T>
will be serializable if the providedFunnel<T>
is. Parameters:
funnel
 the funnel of T's that the constructedBloomFilter<T>
will useexpectedInsertions
 the number of expected insertions to the constructedBloomFilter<T>
; must be positive Returns:
 a
BloomFilter

