Introduction

Java Streams, introduced in Java 8, are a powerful and expressive programming feature designed to simplify the process of working with collections, arrays, and I/O channels

They provide a functional programming approach to processing data, enabling developers to perform complex operations on data sources with concise, readable, and maintainable code

What is a Stream?

In Java, a stream helps you manage and process a sequence of data elements more easily.

It consists of connected actions that run only when required, making it efficient

Streams don't store or alter data, so they're great for handling lots of information from various sources.

Types of Streams

Sequential Streams

Sequential streams process the elements in their original order, one at a time. This is the default mode when creating a stream, and it ensures that the operations are executed in a predictable manner.

Sequential streams are well-suited for situations where maintaining the order of the data is essential or when parallel processing doesn't offer significant performance benefits

Parallel Streams

Parallel streams, on the other hand, enable concurrent processing of the elements by splitting the data into multiple segments and processing them simultaneously. This can significantly improve performance, particularly on multi-core systems

Stream Operations

Stream operations in Java are divided into two categories: intermediate and terminal operations

Intermediate Operations

These operations transform a stream into a new stream without producing a final result. They're lazy, meaning they only execute when a terminal operation is called. Common intermediate operations include filter(), map(), and sorted()

Terminal Operations

Terminal operations produce a final result or a side-effect, triggering the execution of the entire stream pipeline. Examples of terminal operations include forEach(), reduce(), and collect()

Filtering and Mapping

Filtering and mapping are common operations in Java streams that help manipulate and transform data elements

filter()

The filter() method, an intermediate operation, selects elements in a stream based on a given condition, using a predicate. It generates a new stream with only the elements that meet the condition.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0);

map()

The map() method is another intermediate operation that applies a transformation to each element in a stream, creating a new stream with the transformed elements. It takes a function as an argument, which defines how each element should be transformed

List<String> names = Arrays.asList("Alice" , "Bob" , "Charlie");
Stream<Integer> nameLengths = names.stream().map(name -> name.length());

Sorting and Removing Duplicates

Sorting and removing duplicates are useful operations when working with Java streams to organize and clean data

sorted

The sorted() method is an intermediate operation that sorts the elements in a stream based on their natural order or a provided comparator. It creates a new stream with the sorted elements

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2); 
Stream<Integer> sortedNumbers = numbers.stream().sorted();

distinct()

The distinct() method, another intermediate operation, removes duplicate elements from a stream. It creates a new stream containing only unique elements, based on their natural order

List<Integer> numbersWithDuplicates = Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5);
Stream<Integer> uniqueNums = numsWithDuplicates.stream().distinct();

Reduction and Aggregation

Reduction and aggregation operations in Java streams help combine elements into a single value or a new data structure.

reduce()

The reduce() method is a terminal operation that combines stream elements using a provided function, often referred to as an accumulator. It's commonly used to calculate sums, products, or other aggregate values.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream().reduce((a, b) -> a + b);

collect()

The collect() method is another terminal operation used to accumulate stream elements into a new data structure, like a list, set, or map. It utilizes a Collector to define the accumulation process.

List<String> names = Arrays.asList("Alice","Bob",
"Charlie");

List<String> upperCaseNames = names.stream()

.map(String::toUpperCase)
.collect(Collectors.toList());

• toList(): Accumulate elements into a list

• toSet(): Accumulate elements into a set

• toMap(): Accumulate elements into a map

• joining(): Concatenate elements into a string

• grouping(): Group elements based on a specified classification function

Search and Match

Search and match operations in Java streams help you find elements that satisfy certain conditions or determine if a stream's elements meet specific criteria

anyMatch()

The anyMatch() method is a terminal operation that checks if any element in a stream satisfies a given predicate. It returns a boolean value indicating the result.

List<String> names  = Arrays.asList("Alice","Bob","Charlie");
boolean anyShortName = names.stream().anyMatch(name -> name.length() <= 3);

allMatch()

The allMatch() method is another terminal operation that checks if all elements in a stream meet a specified condition. It also returns a boolean value.

List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);
boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);

findFirst()

The findFirst() method is a terminal operation that returns the first element in a stream that satisfies an optional condition, wrapped in an Optional object.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstEven = numbers.stream().filter(n -> n % 2 == 0).findFirst();