In Java, the Stream API provides a powerful way to process data in a functional and declarative style. One of the key features of the Stream API is the ability to perform reduction and aggregation operations on streams of data. These operations allow you to combine, summarize, and transform the elements of a stream into a single result.

Reduction Operations

A reduction operation combines the elements of a stream into a single result. The reduction operation is specified using a reduction function that takes two elements and returns a result that can be the same type as the elements or a different type. The most common reduction operation is the reduce method, which can take either two or three arguments.

reduce(BinaryOperator<T> accumulator)

This method takes a binary operator that specifies how to combine two elements into a single result. It returns an Optional<T> that represents the reduced value, or an empty Optional if the stream is empty.

Optional<Integer> sum = Stream.of(1, 2, 3, 4, 5)
    .reduce((a, b) -> a + b);

reduce(T identity, BinaryOperator<T> accumulator)

This method takes an identity value and a binary operator. The identity value is used as the initial value of the reduction and the binary operator is used to combine the elements of the stream. It returns the reduced value.

int sum = Stream.of(1, 2, 3, 4, 5)
    .reduce(0, (a, b) -> a + b);

Aggregation Operations

Aggregation operations are specialized reduction operations that perform a summary computation on the elements of a stream. The Stream API provides several built-in aggregation operations, such as sum, average, min, max, and count.

sum()

This operation computes the sum of the elements in the stream.

int sum = Stream.of(1, 2, 3, 4, 5)
    .mapToInt(Integer::valueOf)
    .sum();

average()

This operation computes the average of the elements in the stream.

double average = Stream.of(1, 2, 3, 4, 5)
    .mapToInt(Integer::valueOf)
    .average()
    .orElse(0);

min() and max()

These operations find the minimum and maximum values in the stream, respectively.

Optional<Integer> min = Stream.of(1, 2, 3, 4, 5)
    .min(Integer::compare);
    
Optional<Integer> max = Stream.of(1, 2, 3, 4, 5)
    .max(Integer::compare);

count()

This operation counts the number of elements in the stream.

long count = Stream.of(1, 2, 3, 4, 5)
    .count();

Conclusion

The Java Streams API provides powerful features for reducing and aggregating data in a concise and functional manner. By using reduction and aggregation operations, you can perform complex computations on streams of data with ease. Whether you need to calculate the sum, average, or find the minimum or maximum value, the Stream API has got you covered.

#Java #StreamAPI