A QUICK GUIDE TO

JAVA
STREAMS
LINEUP

INTRODUCTION
WHAT ARE STREAMS?
TYPES OF STREAMS
STREAM OPERATIONS
FILTERING AND MAPPING
SORTING AND REMOVING
DUPLICATES
REDUCTION AND AGGREGATION
SEARCH AND MATCH
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

1
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

Java streams leverage lazy

evaluation, allowing
efficient processing of
large or even infinite data
sets by executing
operations only when
necessary and avoiding
unnecessary computations

2
 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

3
Types of Streams
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

4
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()

5
Stream Operations
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()

6
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);

7
Filtering and Mapping

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());

8
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();

9
Sorting and Removing
Duplicates

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();

10
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);

11
 Reduction and Aggregation
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
groupingBy(): Group elements based on a specified
classification function
12
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);

13
Search and Match

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);

14
Search and Match

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();

15
 This informational document on
Java streams was brought to you
by Dileesha Rajapakse.
My goal is to provide clear,
concise, and accessible
educational resources to help you
gain a deeper understanding of
programming concepts and
technologies. I hope you found
this guide helpful and informative
as you continue your journey in
the world of Java programming.

dileeshar