com.google.common.base
Class Predicates

java.lang.Object
  com.google.common.base.Predicates

public final class Predicates
extends Object

Contains static factory methods for creating Predicate instances.

All methods returns serializable predicates as long as they're given serializable parameters.

Since:

2 (imported from Google Collections Library)

Author:

Kevin Bourrillion

alwaysTrue

public static <T> Predicate<T> alwaysTrue()

Returns a predicate that always evaluates to true.

alwaysFalse

public static <T> Predicate<T> alwaysFalse()

Returns a predicate that always evaluates to false.

isNull

public static <T> Predicate<T> isNull()

Returns a predicate that evaluates to true if the object reference being tested is null.

notNull

public static <T> Predicate<T> notNull()

Returns a predicate that evaluates to true if the object reference being tested is not null.

not

public static <T> Predicate<T> not(Predicate<T> predicate)

Returns a predicate that evaluates to true if the given predicate evaluates to false.

and

public static <T> Predicate<T> and(Iterable<? extends Predicate<? super T>> components)

Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.

and

public static <T> Predicate<T> and(Predicate<? super T>... components)

Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.

and

public static <T> Predicate<T> and(Predicate<? super T> first,
                                   Predicate<? super T> second)

Returns a predicate that evaluates to true if both of its components evaluate to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found.

or

public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> components)

Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.

or

public static <T> Predicate<T> or(Predicate<? super T>... components)

Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.

or

public static <T> Predicate<T> or(Predicate<? super T> first,
                                  Predicate<? super T> second)

Returns a predicate that evaluates to true if either of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found.

equalTo

public static <T> Predicate<T> equalTo(@Nullable
                                       T target)

Returns a predicate that evaluates to true if the object being tested equals() the given target or both are null.

instanceOf

public static Predicate<Object> instanceOf(Class<?> clazz)

Returns a predicate that evaluates to true if the object being tested is an instance of the given class. If the object being tested is null this predicate evaluates to false.

If you want to filter an Iterable to narrow its type, consider using Iterables.filter(Iterable, Class) in preference.

in

public static <T> Predicate<T> in(Collection<? extends T> target)

Returns a predicate that evaluates to true if the object reference being tested is a member of the given collection. It does not defensively copy the collection passed in, so future changes to it will alter the behavior of the predicate. This method can technically accept any Collection, but using a typed collection helps prevent bugs. This approach doesn't block any potential users since it is always possible to use Predicates.<Object>in().

Parameters:

target - the collection that may contain the function input

compose

public static <A,B> Predicate<A> compose(Predicate<B> predicate,
                                         Function<A,? extends B> function)

Returns the composition of a function and a predicate. For every x, the generated predicate returns predicate(function(x)).

Returns:

the composition of the provided function and predicate

containsPattern

@Beta
public static Predicate<CharSequence> containsPattern(String pattern)

Returns a predicate that evaluates to true if the CharSequence being tested contains any match for the given regular expression pattern. The test used is equivalent to Pattern.compile(pattern).matcher(arg).find()

Throws:

PatternSyntaxException - if the pattern is invalid

Since:

3

contains

public static Predicate<CharSequence> contains(Pattern pattern)

Returns a predicate that evaluates to true if the CharSequence being tested contains any match for the given regular expression pattern. The test used is equivalent to regex.matcher(arg).find()

Since:

3