Package io.vavr

Class Predicates

java.lang.Object
io.vavr.Predicates

public final class Predicates extends Object
Defines general-purpose predicates which are particularly useful when working with API.Match.
  • Constructor Details

    • Predicates

      private Predicates()
  • Method Details

    • allOf

      @SafeVarargs public static <T> Predicate<T> allOf(Predicate<T>... predicates)
      A combinator that checks if all of the given predicates are satisfied.

      By definition allOf is satisfied if the given predicates are empty.

      
       Predicate<Integer> isGreaterThanOne = i -> i > 1;
       Predicate<Integer> isGreaterThanTwo = i -> i > 2;
       allOf().test(0);                                   // true
       allOf(isGreaterThanOne, isGreaterThanTwo).test(3); // true
       allOf(isGreaterThanOne, isGreaterThanTwo).test(2); // false
       
      Type Parameters:
      T - closure over tested object types
      Parameters:
      predicates - An array of predicates
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicates is null
    • anyOf

      @SafeVarargs public static <T> Predicate<T> anyOf(Predicate<T>... predicates)
      A combinator that checks if at least one of the given predicates is satisfies.
      
       Predicate<Integer> isGreaterThanOne = i -> i > 1;
       Predicate<Integer> isGreaterThanTwo = i -> i > 2;
       anyOf().test(0);                                   // false
       anyOf(isGreaterThanOne, isGreaterThanTwo).test(3); // true
       anyOf(isGreaterThanOne, isGreaterThanTwo).test(2); // true
       anyOf(isGreaterThanOne, isGreaterThanTwo).test(1); // false
       
      Type Parameters:
      T - closure over tested object types
      Parameters:
      predicates - An array of predicates
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicates is null
    • exists

      public static <T> Predicate<Iterable<T>> exists(Predicate<? super T> predicate)
      A combinator that checks if one or more elements of an Iterable satisfy the predicate.
      
       Predicate<Integer> isGreaterThanOne = i -> i > 1;
       Predicate<Iterable<Integer>> existsGreaterThanOne = exists(isGreaterThanOne);
       existsGreaterThanOne.test(List.of(0, 1, 2)); // true
       existsGreaterThanOne.test(List.of(0, 1));    // false
       
      Type Parameters:
      T - tested object type
      Parameters:
      predicate - A Predicate that tests elements of type T
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicate is null
    • forAll

      public static <T> Predicate<Iterable<T>> forAll(Predicate<? super T> predicate)
      A combinator that checks if all elements of an Iterable satisfy the predicate.
      
       Predicate<Integer> isGreaterThanOne = i -> i > 1;
       Predicate<Iterable<Integer>> forAllGreaterThanOne = forAll(isGreaterThanOne);
       forAllGreaterThanOne.test(List.of(0, 1, 2)); // false
       forAllGreaterThanOne.test(List.of(2, 3, 4)); // true
       
      Type Parameters:
      T - tested object type
      Parameters:
      predicate - A Predicate that tests elements of type T
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicate is null
    • instanceOf

      @GwtIncompatible public static <T> Predicate<T> instanceOf(Class<? extends T> type)
      Creates a Predicate that tests, if an object is instance of the specified type.
      
       Predicate<Object> instanceOfNumber = instanceOf(Number.class);
       instanceOfNumber.test(1);    // true
       instanceOfNumber.test("1");  // false
       
      Type Parameters:
      T - tested object type
      Parameters:
      type - A type
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if type is null
    • is

      public static <T> Predicate<T> is(T value)
      Creates a Predicate that tests, if an object is equal to the specified value using Objects.equals(Object, Object) for comparison.
      
       Predicate<Integer> isOne = is(1);
       isOne.test(1); // true
       isOne.test(2); // false
       
      Type Parameters:
      T - tested object type
      Parameters:
      value - A value, may be null
      Returns:
      A new Predicate
    • isIn

      @SafeVarargs public static <T> Predicate<T> isIn(T... values)
      Creates a Predicate that tests, if an object is equal to at least one of the specified values using Objects.equals(Object, Object) for comparison.
      
       Predicate<Integer> isIn = isIn(1, 2, 3);
       isIn.test(1); // true
       isIn.test(0); // false
       
      Type Parameters:
      T - closure over tested object types
      Parameters:
      values - an array of values of type T
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if values is null
    • isNotNull

      public static <T> Predicate<T> isNotNull()
      Creates a Predicate that tests, if an object is not null
      
       Predicate<Integer> isNotNull = isNotNull();
       isNotNull.test(0);    // true
       isNotNull.test(null); // false
       
      Type Parameters:
      T - tested object type
      Returns:
      A new Predicate
    • isNull

      public static <T> Predicate<T> isNull()
      Creates a Predicate that tests, if an object is null
      
       Predicate<Integer> isNull = isNull();
       isNull.test(null); // true
       isNull.test(0);    // false
       
      Type Parameters:
      T - tested object type
      Returns:
      A new Predicate
    • noneOf

      @SafeVarargs public static <T> Predicate<T> noneOf(Predicate<T>... predicates)
      A combinator that checks if none of the given predicates is satisfied.

      Naturally noneOf is satisfied if the given predicates are empty.

      
       Predicate<Integer> isGreaterThanOne = i -> i > 1;
       Predicate<Integer> isGreaterThanTwo = i -> i > 2;
       noneOf().test(0);                                   // true
       noneOf(isGreaterThanOne, isGreaterThanTwo).test(1); // true
       noneOf(isGreaterThanOne, isGreaterThanTwo).test(2); // false
       
      Type Parameters:
      T - closure over tested object types
      Parameters:
      predicates - An array of predicates
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicates is null
    • not

      public static <T> Predicate<T> not(Predicate<? super T> predicate)
      Negates a given Predicate.
      
       // negates a method reference
       Predicate<String> isNotNull1 = not(Objects::isNull);
       isNotNull1.test("");   // true
       isNotNull1.test(null); // false
      
       // negates a predicate instance
       Predicate<String> isNotNull2 = not(Predicates.isNull());
       isNotNull2.test("");   // true
       isNotNull2.test(null); // false
       
      Type Parameters:
      T - tested object type
      Parameters:
      predicate - A Predicate that tests elements of type T
      Returns:
      A new Predicate
      Throws:
      NullPointerException - if predicate is null