Stream api methods with examples

Certainly! Here are the examples of each method in the Stream API without using method references:

1. `filter(Predicate<T> predicate)`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
System.out.println(evenNumbers); // Output: [2, 4, 6, 8, 10]
```

2. `map(Function<T, R> mapper)`:
```java
List<String> names = Arrays.asList("John", "Jane", "Adam", "Eve");
List<Integer> nameLengths = names.stream()
                                 .map(name -> name.length())
                                 .collect(Collectors.toList());
System.out.println(nameLengths); // Output: [4, 4, 4, 3]
```

3. `forEach(Consumer<T> action)`:
```java
List<String> fruits = Arrays.asList("Apple", "Banana", "Mango");
fruits.stream()
      .forEach(fruit -> System.out.println(fruit));
// Output:
// Apple
// Banana
// Mango
```

4. `collect(Collector<T, A, R> collector)`:
```java
List<String> fruits = Arrays.asList("Apple", "Banana", "Mango");
String fruitString = fruits.stream()
                           .collect(Collectors.joining(", "));
System.out.println(fruitString); // Output: Apple, Banana, Mango
```

5. `reduce(BinaryOperator<T> accumulator)`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
                               .reduce((a, b) -> a + b);
System.out.println(sum.orElse(0)); // Output: 15
```

6. `sorted()`:
```java
List<String> names = Arrays.asList("John", "Adam", "Jane");
List<String> sortedNames = names.stream()
                               .sorted((name1, name2) -> name1.compareTo(name2))
                               .collect(Collectors.toList());
System.out.println(sortedNames); // Output: [Adam, Jane, John]
```

7. `distinct()`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5);
List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());
System.out.println(distinctNumbers); // Output: [1, 2, 3, 4, 5]
```

8. `skip(long n)`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
                                      .skip(2)
                                      .collect(Collectors.toList());
System.out.println(skippedNumbers); // Output: [3, 4, 5]
```

9. `limit(long maxSize)`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
                                      .limit(3)
                                      .collect(Collectors.toList());
System.out.println(limitedNumbers); // Output: [1, 2, 3]
```

10. `anyMatch(Predicate<T> predicate)`:
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyEvenNumber = numbers.stream()