@techwithvishalraj
Java
Stream API
@techwithvishalraj
Stream API
Java provides a new additional package in Java 8 called
java.util.stream.
This package consists of classes, interfaces and enum to allows
functional-style operations on the elements.
A stream is a sequence of elements that supports various
operations to perform computations upon those elements. Streams
do not store elements; they are functional-style constructs that
allow for processing elements on-demand.
The elements of a stream are only visited once during the life of a
stream.
Intermediate Operations: Operations that can be chained together
to form a pipeline for processing elements in a stream. Examples
include filter, map, flatMap, distinct, sorted, limit, skip, etc.
Terminal Operations: Operations that terminate a stream pipeline
and produce a result. Examples include forEach, collect, reduce,
count, min, max, anyMatch, toList, etc.
Lazy Evaluation: intermediate operations are only executed when a
terminal operation is invoked.
Parallel Streams: Streams can be processed in parallel to take
advantage of multi-core processors. This can be achieved by
invoking the parallel() method on a stream.
@techwithvishalraj
List<Integer> list = Arrays.asList(1, 4, 5, 3, 2, 8, 6, 3, 0);
filter()
syntax: Stream<T> filter(Predicate<? super T> predicate)
It returns a stream consisting of the elements of this stream that match
the given predicate.
List<Integer> evenList = list.stream().filter(x->x%2==0).toList();
Sop(evenList); -------> [4, 2, 8, 6, 0]
map()
syntax: <R> Stream<R> map(Function<? super T, ? extends R> mapper)
It returns a stream consisting of the results of applying the given
function to the elements of this stream.
List<Integer> evenSquaresList = list.stream().map(x-> x*x).toList();
Sop(evenSquaresList); ----> [1, 16, 25, 9, 4, 64, 36, 9, 0]
sorted()
List<Integer> sortedlist = list.stream().sorted().toList();
Sop(sortedlist); ----> [0, 1, 2, 3, 3, 4, 5, 6, 8]
@techwithvishalraj
List<Integer> list = Arrays.asList(1, 1, 3, 3, 2, 2, 6, 3, 0);
distinct()
It eliminates duplicate elements, ensuring that each element in the
resulting stream is unique.
List<Integer> distinctList = list.stream().distinct().toList();
System.out.println(distinctList); -------> [1, 3, 2, 6, 0]
skip(long n)
skips the first n elements of the stream and returns a new stream
consisting of the remaining elements. If the stream contains fewer than
n elements then empty stream is returned.
List<Integer> skippedList = list.stream().skip(3).toList();
System.out.println(skippedList); ----> [3, 2, 2, 6, 3, 0]
limit(lomg maxSize)
returns a stream consisting of the first maxSize elements of the original
stream. If the original stream contains fewer than maxSize elements,
then all elements of the original stream is returned.
List<Integer> limitedList = list.stream().limit(2).toList();
System.out.println(limitedList); ----> [1, 1]
flatmap()
@techwithvishalraj
flatMap() method is an intermediate operation that is used to flatten
nested streams into a single stream.
It is particularly useful when dealing with nested collections or when
you want to transform each element in a stream into multiple
elements and then flatten those elements into a single stream by
concatenating them.
List<List<Integer>> nestedList = Arrays.asList(Arrays.asList(5, 6, 7),
Arrays.asList(2, 1, 3),
Arrays.asList(3, 5, 0));
List<Integer> flattenedList = nestedList.stream()
.flatMap(List::stream)
.toList();
System.out.println("flattenedList: "+flattenedList);
List<Integer> sortedFlattenedList = nestedList.stream()
.flatMap(List::stream)
.sorted()
.toList();
System.out.println("sortedFlattenedList: "+sortedFlattenedList);
output: flattenedList: [5, 6, 7, 2, 1, 3, 3, 5, 0]
sortedFlattenedList: [0, 1, 2, 3, 3, 5, 5, 6, 7]
flatmap()
@techwithvishalraj
flatMap() is used is when you have a collection of objects, and each
object contains a collection of elements.
class Person{
String name;
List<Long> phoneNo;
Person (String name, Long... phoneNo){
this.name=name;
this.phoneNo= Arrays.asList(phoneNo);
}
}
public class Test2 {
public static void main(String[] args) {
List<Person> persons = Arrays.asList(
new Person("ram", 9087897899L, 9089076540L),
new Person("shyam", 8978900890L, 7897897890L),
new Person("baburao", 8888888888L, 9999887890L));
List<Long> phoneNos= persons.stream()
.flatMap(person -> person.phoneNo.stream())
.toList();
System.out.println(phoneNos);
}
}
output: [9087897899, 9089076540, 8978900890,
7897897890, 8888888888, 9999887890]
forEach()
@techwithvishalraj
List<Integer> list = Arrays.asList(1, 1, 3, 3, 2, 2, 6, 3, 0);
list.stream().filter(x-> x%2==0).forEach(x->System.out.print(x+" "));
-----> 2 2 6 0
list.stream().filter(x-> x%2==0).forEach(System.out::print); ---> 2260
count(), max(), min()
List<Integer> list = Arrays.asList(1, 1, 3, 3, 2, 2, 6, 3, 0);
long count = list.stream().count(); ----------> 9
Optional<Integer> max = list.stream().max(Integer::compareTo);
System.out.println(max.orElse(null)); ----------> 6
Optional<Integer> min = list.stream().min(Integer::compareTo);
System.out.println(min.orElse(null)); -----------> 0
anyMatch()
Syntax: boolean anyMatch(Predicate<? super T> predicate)
It check whether any element of the stream matches a given predicate.
boolean result = list.stream().anyMatch(x-> x>5); -----> true
reduce()
@techwithvishalraj
Syntax: T reduce(T identity, BinaryOperator<T> accumulator )
Performs a reduction on the elements of this stream, using the
provided identity value and an associative accumulation function, and
returns the reduced value. This is equivalent to:
T result = identity;
for (T element : this stream)
result = accumulator.apply(result, element)
return result;
List<Integer> list = Arrays.asList(1, 1, 3, 3, 2, 2, 6, 3, 0);
int sum = list.stream().reduce(0, (a, b)->a+b); ----> 21
int sum = list.stream().reduce(0, Integer::sum); ----> 21
int sum = list.stream().reduce(2, (a, b)->a+b); ----> 23
int max = list.stream().reduce(Integer.MIN_VALUE,
(a, b)->Math.max(a, b)); -----> 6
int min = list.stream().reduce(Integer.MAX_VALUE,
(a, b)->Math.min(a, b)); -----> 0
List<String> names = Arrays.asList("ram", "shyam", "baburao");
String result = names.stream().reduce("", (s1, s2)-> s1+s2);
----------> ramshyambaburao
collect() @techwithvishalraj
It is used to accumulate the elements of a stream into a collection or
another container.
It's a versatile operation that allows you to collect stream elements
into various data structures such as lists, sets, maps, and even custom
collectors.
List<Integer> list = Arrays.asList(1, 1, 3, 3, 2, 2, 6, 3, 0);
List<Integer> collectedList = list.stream().collect(Collectors.toList());
System.out.println(collectedList); -----> [1, 1, 3, 3, 2, 2, 6, 3, 0]
Set<Integer> set = list.stream().collect(Collectors.toSet());
System.out.println(set); ------> [0, 1, 2, 3, 6]
List<String> names = Arrays.asList("ram", null, "shyam", "baburao");
String result = names.stream().filter(Objects::nonNull)
.collect(Collectors.joining("-"));
System.out.println(result); ---> ram-shyam-baburao
collect(Collectors.toMap()) @techwithvishalraj
class Employee{
private String name;
private Integer age;
private String city;
public Employee(String name, Integer age, String city) {
this.name = name;
this.age = age;
this.city = city;
}
// getters and setters
}
public class Test {
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("ram", 27, "culcutta"),
new Employee("shyam", 28, "delhi"),
new Employee("baburao", 45, "mumbai"));
Map<String, Integer> map = employees.stream()
.collect(Collectors.toMap(Employee::getName,
Employee::getAge));
System.out.println(map); ----> {shyam=28, baburao=45, ram=27}
}
}
Sorting more than once @techwithvishalraj
class Employee{
private String name;
private Integer age;
private String city;
private Integer salary;
// constructor, getters and setters
}
public class Test {
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("baburao", 45, "mumbai", 4500),
new Employee("ram", 27, "kalkatta", 0),
new Employee("shyam", 25, "jaipur", 1000),
new Employee("sam", 25, "delhi", 1000));
employees.stream().sorted(Comparator
.comparing(Employee::getSalary)
.thenComparing(Employee::getAge)
.thenComparing(Employee::getCity))
.forEach(x-> System.out.println(x.getName()+
" : "+ x.getAge()+" : "+ x.getCity()+
" : "+x.getSalary()));
}
} output: ram : 27 : kalkatta : 0
sam : 25 : delhi : 1000
shyam : 25 : jaipur : 1000
baburao : 45 : mumbai : 4500
HashMap Sorting @techwithvishalraj
public class Test {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("baburao", 45);
map.put("ram", 27);
map.put("shyam", 25);
map.put("sam", 25);
Map<String, Integer> sortedMap = new LinkedHashMap<>();
map.entrySet().stream().sorted(Map.Entry.comparingByValue())
.forEachOrdered(x-> sortedMap.put(x.getKey(), x.getValue()));
Sop(sortedMap); ----> {shyam=25, sam=25, ram=27, baburao=45}
Map<String, Integer> sortedMap1 = new LinkedHashMap<>();
map.entrySet().stream().sorted(Map.Entry.comparingByKey())
.forEachOrdered(x->sortedMap1.put(x.getKey(), x.getValue()));
Sop(sortedMap1); -----> {baburao=45, ram=27, sam=25, shyam=25}
Map<String, Integer> sortedMap2 = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<String, Integer>comparingByValue()
.thenComparing(Map.Entry.comparingByKey()))
.forEachOrdered(x->sortedMap2.put(x.getKey(), x.getValue()));
Sop(sortedMap2); ----> {sam=25, shyam=25, ram=27, baburao=45}
@techwithvishalraj
Thank
you!
vishal-bramhankar
techwithvishalraj
Vishall0317
