java.util.stream

---

1. Filter a List of Strings

List<String> names = Arrays.asList("John", "Mary", "Bob", "Alice");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("M"))
    .collect(Collectors.toList());

2. Map a List of Integers to Squares

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = numbers.stream()
    .map(num -> num * num)
    .collect(Collectors.toList());

3. Find the Maximum Value in a List

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int max = numbers.stream()
    .max(Comparator.naturalOrder())
    .get();

4. Find the First Element in a List that Matches a Condition

List<String> names = Arrays.asList("John", "Mary", "Bob", "Alice");
String firstMatchingName = names.stream()
    .filter(name -> name.startsWith("M"))
    .findFirst()
    .orElse(null);

5. Check if Any Element in a List Matches a Condition

List<String> names = Arrays.asList("John", "Mary", "Bob", "Alice");
boolean anyMatchingName = names.stream()
    .anyMatch(name -> name.startsWith("M"));

6. Count the Number of Elements in a List that Match a Condition

List<String> names = Arrays.asList("John", "Mary", "Bob", "Alice");
long countMatchingNames = names.stream()
    .filter(name -> name.startsWith("M"))
    .count();

7. Reduce a List of Numbers to a Single Value (Sum)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, (acc, num) -> acc + num);

8. Reduce a List of Strings to a Single String (Concatenation)

List<String> names = Arrays.asList("John", "Mary", "Bob", "Alice");
String concatenatedNames = names.stream()
    .reduce("", (acc, name) -> acc + ", " + name);

9. Group Elements by a Key

List<Person> people = Arrays.asList(
    new Person("John", 30),
    new Person("Mary", 25),
    new Person("Bob", 35),
    new Person("Alice", 20));

Map<Integer, List<Person>> peopleByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge));

10. Partition Elements into Two Groups

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Boolean, List<Integer>> partitionedNumbers = numbers.stream()
    .collect(Collectors.partitioningBy(num -> num % 2 == 0));

11. FlatMap a List of Lists into a Single List

List<List<Integer>> listOfLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9));

List<Integer> flattenedList = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());

12. Sort a List of Objects

List<Person> people = Arrays.asList(
    new Person("John", 30),
    new Person("Mary", 25),
    new Person("Bob", 35),
    new Person("Alice", 20));

List<Person> sortedPeople = people.stream()
    .sorted(Comparator.comparing(Person::getAge))
    .collect(Collectors.toList());

13. Limit the Number of Results

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> firstThreeNumbers = numbers.stream()
    .limit(3)
    .collect(Collectors.toList());

14. Skip a Number of Results

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> startingFromFourthNumber = numbers.stream()
    .skip(3)
    .collect(Collectors.toList());

15. Convert a Stream to an Array

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numbersArray = numbers.stream()
    .toArray(Integer[]::new);

16. Convert a Stream to a List

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> numbersList = numbers.stream()
    .collect(Collectors.toList());

17. Convert a Stream to a Set

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Set<Integer> numbersSet = numbers.stream()
    .collect(Collectors.toSet());

18. Convert a Stream to a Map

List<Person> people = Arrays.asList(
    new Person("John", 30),
    new Person("Mary", 25),
    new Person("Bob", 35),
    new Person("Alice", 20));

Map<String, Person> peopleMap = people.stream()
    .collect(Collectors.toMap(Person::getName, person -> person));

19. Parallel Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
    .parallel()
    .forEach(System.out::println);

20. Sequential Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
    .sequential()
    .forEach(System.out::println);

21. Unordered Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
    .unordered()
    .forEach(System.out::println);

22. Distinct Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .distinct()
    .forEach(System.out::println);

23. Sorted Stream

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .sorted()
    .forEach(System.out::println);

24. Find First

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .findFirst()
    .ifPresent(System.out::println);

25. Find Any

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .findAny()
    .ifPresent(System.out::println);

26. Max

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .max(Integer::compareTo)
    .ifPresent(System.out::println);

27. Min

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
numbers.stream()
    .min(Integer::compareTo)
    .ifPresent(System.out::println);

28. Count

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
long count = numbers.stream()
    .count();
System.out.println(count);

29. Reduce

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

// Summing all elements
int sum = numbers.stream()
    .reduce((a, b) -> a + b)
    .get();
System.out.println(sum);

// Multiplying all elements
int product = numbers.stream()
    .reduce((a, b) -> a * b)
    .get();
System.out.println(product);

30. Collectors

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

// Creating a list of all elements
List<Integer> list = numbers.stream()
    .collect(Collectors.toList());
System.out.println(list);

// Creating a set of all elements
Set<Integer> set = numbers.stream()
    .collect(Collectors.toSet());
System.out.println(set);

// Creating a map of all elements with their frequency
Map<Integer, Long> map = numbers.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
System.out.println(map);

31. Joining

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

// Joining all elements with a comma separator
String joined = names.stream()
    .collect(Collectors.joining(", "));
System.out.println(joined);