## Uses of Interface
java.util.function.Predicate

- Packages that use Predicate
  Package | Description
  --- | ---
  java.util | Contains the collections framework, some internationalization support classes, a service loader, properties, random number generation, string parsing and scanning classes, base64 encoding and decoding, a bit array, and several miscellaneous utility classes.
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  java.util.function | Functional interfaces provide target types for lambda expressions and method references.
  java.util.regex | Classes for matching character sequences against patterns specified by regular expressions.
  java.util.stream | Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.

- - ### Uses of Predicate in java.util

    Methods in java.util with parameters of type Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `Optional<T>` | Optional.`filter​(Predicate<? super T> predicate)` | If a value is present, and the value matches the given predicate, returns an `Optional` describing the value, otherwise returns an empty `Optional`.
    `boolean` | ArrayDeque.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | ArrayList.`removeIf​(Predicate<? super E> filter)` |
    `default boolean` | Collection.`removeIf​(Predicate<? super E> filter)` | Removes all of the elements of this collection that satisfy the given predicate.
    `boolean` | PriorityQueue.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | Vector.`removeIf​(Predicate<? super E> filter)` |

  - ### Uses of Predicate in java.util.concurrent

    Methods in java.util.concurrent with parameters of type Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | ArrayBlockingQueue.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | ConcurrentLinkedDeque.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | ConcurrentLinkedQueue.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | CopyOnWriteArrayList.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | CopyOnWriteArraySet.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | LinkedBlockingDeque.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | LinkedBlockingQueue.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | LinkedTransferQueue.`removeIf​(Predicate<? super E> filter)` |
    `boolean` | PriorityBlockingQueue.`removeIf​(Predicate<? super E> filter)` |

    Constructors in java.util.concurrent with parameters of type Predicate
    Constructor | Description
    --- | ---
    `ForkJoinPool​(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode, int corePoolSize, int maximumPoolSize, int minimumRunnable, Predicate<? super ForkJoinPool> saturate, long keepAliveTime, TimeUnit unit)` | Creates a `ForkJoinPool` with the given parameters.

  - ### Uses of Predicate in java.util.function

    Methods in java.util.function that return Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Predicate<T>` | Predicate.`and​(Predicate<? super T> other)` | Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
    `static <T> Predicate<T>` | Predicate.`isEqual​(Object targetRef)` | Returns a predicate that tests if two arguments are equal according to `Objects.equals(Object, Object)`.
    `default Predicate<T>` | Predicate.`negate()` | Returns a predicate that represents the logical negation of this predicate.
    `static <T> Predicate<T>` | Predicate.`not​(Predicate<? super T> target)` | Returns a predicate that is the negation of the supplied predicate.
    `default Predicate<T>` | Predicate.`or​(Predicate<? super T> other)` | Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.

    Methods in java.util.function with parameters of type Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `default Predicate<T>` | Predicate.`and​(Predicate<? super T> other)` | Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
    `static <T> Predicate<T>` | Predicate.`not​(Predicate<? super T> target)` | Returns a predicate that is the negation of the supplied predicate.
    `default Predicate<T>` | Predicate.`or​(Predicate<? super T> other)` | Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.

  - ### Uses of Predicate in java.util.regex

    Methods in java.util.regex that return Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `Predicate<String>` | Pattern.`asMatchPredicate()` | Creates a predicate that tests if this pattern matches a given input string.
    `Predicate<String>` | Pattern.`asPredicate()` | Creates a predicate that tests if this pattern is found in a given input string.

  - ### Uses of Predicate in java.util.stream

    Methods in java.util.stream with parameters of type Predicate
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | Stream.`allMatch​(Predicate<? super T> predicate)` | Returns whether all elements of this stream match the provided predicate.
    `boolean` | Stream.`anyMatch​(Predicate<? super T> predicate)` | Returns whether any elements of this stream match the provided predicate.
    `default Stream<T>` | Stream.`dropWhile​(Predicate<? super T> predicate)` | Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.
    `Stream<T>` | Stream.`filter​(Predicate<? super T> predicate)` | Returns a stream consisting of the elements of this stream that match the given predicate.
    `static <T,​A,​R> Collector<T,​?,​R>` | Collectors.`filtering​(Predicate<? super T> predicate, Collector<? super T,​A,​R> downstream)` | Adapts a `Collector` to one accepting elements of the same type `T` by applying the predicate to each input element and only accumulating if the predicate returns `true`.
    `static <T> Stream<T>` | Stream.`iterate​(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)` | Returns a sequential ordered `Stream` produced by iterative application of the given `next` function to an initial element, conditioned on satisfying the given `hasNext` predicate.
    `boolean` | Stream.`noneMatch​(Predicate<? super T> predicate)` | Returns whether no elements of this stream match the provided predicate.
    `static <T> Collector<T,​?,​Map<Boolean,​List<T>>>` | Collectors.`partitioningBy​(Predicate<? super T> predicate)` | Returns a `Collector` which partitions the input elements according to a `Predicate`, and organizes them into a `Map<Boolean, List<T>>`.
    `static <T,​D,​A> Collector<T,​?,​Map<Boolean,​D>>` | Collectors.`partitioningBy​(Predicate<? super T> predicate, Collector<? super T,​A,​D> downstream)` | Returns a `Collector` which partitions the input elements according to a `Predicate`, reduces the values in each partition according to another `Collector`, and organizes them into a `Map<Boolean, D>` whose values are the result of the downstream reduction.
    `default Stream<T>` | Stream.`takeWhile​(Predicate<? super T> predicate)` | Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.