# java.util.stream

***

**1. Filter a List of Strings**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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)**

```java
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)**

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

**9. Group Elements by a Key**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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**

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

**16. Convert a Stream to a List**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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**

```java
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**

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

**23. Sorted Stream**

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

**24. Find First**

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

**25. Find Any**

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

**26. Max**

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

**27. Min**

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

**28. Count**

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

**29. Reduce**

```java
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**

```java
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**

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

```