BloomFilter

A Bloom filter for instances of T. A Bloom filter offers an approximate containment test with one-sided 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.

From the Guava BloomFilter tutorial:

implicit object PersonFunnel extends Funnel[Person] {
   override def funnel(from: Person, into: PrimitiveSink) = ...
}

val friends: BloomFilter[Person] = BloomFilter.create(500, 0.01)
friendsList.foreach { case p: Person => friends.put(p) }

// much later
if (friends.mightContain(dude)) {
   // the probability that dude reached this place if he isn't a friend is 1%
   // we might, for example, start asynchronously loading things for dude while we do a more expensive exact check
}

The false positive probability (FPP) of a bloom filter is defined as the probability that #mightContain(T) will erroneously return true for an object that has not actually been put in the BloomFilter.

Annotations: @Beta() @SerialVersionUID()
Since: 0.6 (copied from Guava-libraries)

Linear Supertypes

Product, Equals, Serializable, Serializable, (T) ⇒ Boolean, AnyRef, Any

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def andThen[A](g: (Boolean) ⇒ A): (T) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
def apply(input: T): Boolean

Equivalent to #mightContain; provided only to satisfy the Predicate interface.
Equivalent to #mightContain; provided only to satisfy the Predicate interface. When using a reference of type BloomFilter, always invoke #mightContain directly instead.

Definition Classes
BloomFilter → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[A](g: (A) ⇒ T): (A) ⇒ Boolean

Definition Classes
Function1
Annotations
@unspecialized()
def copy(): BloomFilter[T]

Creates a new BloomFilter that's a copy of this instance.
Creates a new BloomFilter that's a copy of this instance. The new instance is equal to this instance but shares no mutable state.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def expectedFpp(): Double

Returns the probability that #mightContain(T) will erroneously return true for an object that has not actually been put in the BloomFilter.
Returns the probability that #mightContain(T) will erroneously return true for an object that has not actually been put in the BloomFilter.
Ideally, this number should be close to the fpp parameter passed in #create(Integer, Double), or smaller. If it is significantly higher, it is usually the case that too many elements (more than expected) have been put in the BloomFilter, degenerating it.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mightContain(obj: T): Boolean

Returns true if the element might have been put in this Bloom filter, false if this is definitely not the case.
Returns true if the element might have been put in this Bloom filter, false if this is definitely not the case.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def put(obj: T): Boolean

Puts an element into this BloomFilter.
Puts an element into this BloomFilter. Ensures that subsequent invocations of #mightContain(T) with the same element will always return true.
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 time object has been added to the filter. Note that put(t) always returns the opposite result to what mightContain(t) would have returned at the time it is called."
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
BloomFilter → Function1 → AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object BloomFilter | package hash

final case class BloomFilter[T] extends (T) ⇒ Boolean with Serializable with Product

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[A](g: (Boolean) ⇒ A): (T) ⇒ A

def apply(input: T): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[A](g: (A) ⇒ T): (A) ⇒ Boolean

def copy(): BloomFilter[T]

final def eq(arg0: AnyRef): Boolean

def expectedFpp(): Double

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def mightContain(obj: T): Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def put(obj: T): Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Product

Inherited from Equals

Inherited from Serializable

Inherited from Serializable

Inherited from (T) ⇒ Boolean

Inherited from AnyRef

Inherited from Any

Ungrouped