Predicate<T> is a boolean predicate that checks whether an element meets a given condition. It’s used for filtering data in a stream with the filter() method, making it useful for finding elements, excluding unnecessary data, or applying complex conditions.

Function<T, R> takes an object of type T, transforms it, and returns an object of type R. It’s used in map() when you need to modify data representation, such as extracting information or converting values.

Comparator<T> and Comparable<T> are interfaces for comparing objects. Comparable defines a natural ordering, while Comparator allows specifying different comparison rules. In Stream API, the sorted() method is used for sorting data.

Consumer<T> accepts an object and performs an action without returning a result. It’s often used in forEach() when you need to process each element in a stream, such as printing, saving, or logging.

Supplier<T> is a supplier of values that takes no arguments but returns an object. It is commonly used for data generation, such as creating random numbers.

BiPredicate<T, U>, BiFunction<T, U, R>, and BiConsumer<T, U> are extended versions of standard interfaces that work with two arguments. They allow you to filter pairs of values or perform actions on two objects.

BinaryOperator<T> is a specialized version of BiFunction that takes two arguments of the same type and returns a result of the same type. It is used for combining values, such as calculating a sum or concatenating strings.

map – the map operation transforms each element in the stream by applying a Function. This takes an input of one type and returns a transformed result of another type. This is often used to convert objects from one type to another, such as extracting fields from objects or performing calculations on numerical values.

filter – this operation is used to select elements from a stream based on a given condition. It takes a Predicate, a functional interface that represents a boolean-valued function (i.e., it returns true or false). Only elements that satisfy the predicate are included in the resulting stream. This is useful for extracting relevant data while ignoring unnecessary elements.

flatMap – unlike map, which applies a transformation to each element and returns a single result, flatMap works with nested structures. It maps each element to a stream and then flattens the nested streams into a single stream. It is particularly useful when dealing with lists of lists or collections of collections, enabling seamless processing of hierarchical data.

sorted – the sorted operation sorts elements in a stream, either in their natural order (if they implement Comparable) or using a custom Comparator. This allows for flexible sorting criteria, such as ordering elements based on numeric values, string lengths, or complex object properties. Sorting is an essential step before aggregation or further analysis of data.

distinct – this operation removes duplicate elements from a stream, ensuring that only unique values are retained. It relies on the equals() and hashCode() methods of the objects being processed to determine uniqueness. This is particularly useful when working with collections that may contain redundant data.

limit – restricts the number of elements in the stream to a specified maximum, which is useful for pagination or retrieving a fixed number of results. skip – discards the first few elements in the stream, allowing us to ignore irrelevant data at the beginning of a dataset. These methods work well together when processing large datasets where only a subset of elements is needed.

peek – the peek operation is a non-destructive way to inspect elements in a stream without modifying them. It takes a Consumer, which performs an action (such as logging or debugging) on each element without affecting the stream. Since peek does not alter the structure of the stream, it is often used for troubleshooting and intermediate debugging in stream processing pipelines.

The collect method gathers the elements of a stream into a collection, such as a List, Set, or Map. It is one of the most powerful terminal operations, often used with Collectors, which provide various reduction strategies like grouping, partitioning, and summarization.

The forEach method processes each element of the stream by applying a Consumer, which performs an action but does not return a result. It is commonly used for printing, logging, or updating external systems. Unlike traditional loops, forEach expresses iteration in a more declarative manner.

The reduce method is used for aggregation and combination of stream elements into a single result. It applies an associative function to elements, successively reducing them to a final value. This is useful for computing sums, concatenating strings, or finding the maximum value in a dataset.

The count method returns the total number of elements in a stream. It is useful for determining the size of filtered results without needing to collect them into a List.

These methods find the maximum or minimum element in a stream based on a Comparator. They are particularly useful when working with numerical values or objects that have comparable properties.

The summaryStatistics method provides a statistical summary of numerical streams, including count, sum, min, max, and average. It is a convenient way to perform multiple statistical calculations at once without iterating over the data multiple times.

findFirst retrieves the first element of a stream, often used when order matters. findAny retrieves any element, which is useful for parallel processing where order is not guaranteed.

These methods check whether elements in a stream satisfy a given Predicate: allMatch returns true if all elements meet the condition. anyMatch returns true if at least one element meets the condition. noneMatch returns true if no elements meet the condition. These are useful for validating datasets and filtering information based on conditions.