Collect
Collect the stream values
into a list.

package com.minte9.lambdas.common_operations;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
public class Collect {
public static void main(String[] args) {
List<String> A = Stream.of("a", "b", "c")
.collect(Collectors.toList());
assertEquals(Arrays.asList("a", "b", "c"), A);
}
}
Map
Map each value
to uppercase.

package com.minte9.lambdas.common_operations;
import java.util.ArrayList;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static org.junit.Assert.assertEquals;
public class MapApp {
public static void main(String[] args) {
List<String> A, B, C;
A = asList("a", "b", "c");
B = asList("A", "B", "C");
C = new ArrayList<>();
for(String s : A) {
C.add(s.toUpperCase());
}
assertEquals(B, C);
C = A.stream()
.map(x -> x.toUpperCase())
.collect(toList());
assertEquals(B, C);
}
}
Filter
Filter only strings that
starts with a number.

package com.minte9.lambdas.common_operations;
import static java.lang.Character.isDigit;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.List;
public class Filter {
public static void main(String[] args) {
List<String> A, B, C;
A = asList("1abc");
B = asList("a", "1abc", "abc1");
C = new ArrayList<>();
for(String s : A) {
if (isDigit(s.charAt(0))) {
C.add(s);
}
}
assertEquals(A, C);
C = B.stream()
.filter(x -> isDigit(x.charAt(0)))
.collect(toList());
assertEquals(A, C);
}
}
Reduce
Reduce is used when you want a
single result from collection.

package com.minte9.lambdas.common_operations;
import static org.junit.Assert.assertEquals;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
public class Reduce {
public static void main(String[] args) {
int sum = 0;
for(Integer i : asList(1, 2, 3)) {
sum += i;
}
assertEquals(6, sum);
int sum2 = Stream.of(1, 2, 3)
.reduce(0, (acc, x) -> acc + x);
assertEquals(6, sum2);
}
}
Comparing
Comparing to find
minimum or maximum of an element.

package com.minte9.lambdas.common_operations;
import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class Comparing {
public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("John", 23),
new Student("Mary", 30),
new Student("Mike", 27)
);
Student youngest = students.stream()
.min(Comparator.comparing(x -> x.getAge()))
.get();
assertEquals(students.get(0), youngest);
}
}
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public int getAge() { return age; }
}
PartitioningBy
Partitioning a Stream into
two collections of values.

package com.minte9.lambdas.common_operations;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class PartitioningBy {
public static void main(String[] args) {
Map<Boolean, List<Integer>> map;
map = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
.collect(Collectors.partitioningBy(
x -> x > 3
))
;
System.out.println(map.get(true));
System.out.println(map.get(false));
}
}
GroupingBy
Groupingby to use whatever
keys you want for spliting.

package com.minte9.lambdas.common_operations;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class GroupingBy {
public static void main(String[] args) {
Map<Object, List<String>> map;
map = Stream.of("ab", "bc", "ac", "bd")
.collect(Collectors.groupingBy(
x -> x.charAt(0)
))
;
System.out.println(map);
System.out.println(map.get('a'));
System.out.println(map.get('b'));
}
}