Java Stream API

 The Java Stream API, introduced in Java 8, provides a functional and declarative way to process sequences of elements, typically from collections or arrays. It allows developers to perform operations like filtering, mapping, and reducing data in a more concise and readable manner compared to traditional loop-based approaches.

Key characteristics and concepts of the Java Stream API:

• Functional Programming Paradigm:

  Streams leverage functional interfaces and lambda expressions, enabling a more functional style of programming where operations are treated as functions applied to data.
• Declarative Approach:

  Instead of specifying how to iterate and process elements (as in imperative loops), streams allow you to declare what operations you want to perform on the data.
• Non-Mutating Operations:

  Stream operations do not modify the original data source. Instead, they produce new streams or results, ensuring data immutability.
• Pipeline of Operations:

  Stream operations can be chained together in a pipeline, where the output of one operation becomes the input for the next. This allows for complex data transformations to be expressed clearly.
• Intermediate and Terminal Operations:

  • Intermediate Operations: These operations transform a stream into another stream (e.g., filter(), map(), sorted()). They are typically lazy, meaning they don't process elements until a terminal operation is invoked.
  • Terminal Operations: These operations produce a result or a side effect and consume the stream (e.g., forEach(), collect(), reduce(), count(), min(), max()). Once a terminal operation is called, the stream cannot be reused.
• Lazy Evaluation:

  Intermediate operations are often evaluated lazily, meaning they only perform computations when a terminal operation requests the data. This can improve performance by avoiding unnecessary processing.
• Parallel Processing:

  Streams can be easily parallelized using parallelStream(), allowing operations to be executed concurrently on multi-core processors for improved performance with large datasets.

Example of using the Stream API:

Java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamApiExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        // Filter names starting with 'A', convert to uppercase, and collect into a new list
        List<String> filteredAndTransformedNames = names.stream() // Create a stream from the list
                                                    .filter(name -> name.startsWith("A")) // Intermediate operation: filter
                                                    .map(String::toUpperCase) // Intermediate operation: map
                                                    .collect(Collectors.toList()); // Terminal operation: collect

        System.out.println(filteredAndTransformedNames); // Output: [ALICE]
    }
}