Examples of using lambda expressions in Java8:

 

Here are examples of using lambda expressions in Java:

1. Iterating over a list:

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

2. Filtering a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());

3. Sorting a list:

List<String> names = Arrays.asList("John", "Jane", "Jim");
names.sort((a, b) -> a.compareTo(b));

4. Mapping a list:

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

5. Calculating sum of a list:

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

6. Creating a Runnable:

Runnable runnable = () -> System.out.println("Hello");

7. Implementing a comparator:

Comparator<Person> byAge = (p1, p2) -> p1.getAge() - p2.getAge();

8. Processing an optional value:

Optional<String> optional = Optional.of("Value");
optional.ifPresent(v -> System.out.println(v));

9. Converting a List to Map:

List<Person> people = Arrays.asList(new Person("John", 30), new Person("Jane", 25));
Map<String, Integer> map = people.stream().collect(Collectors.toMap(Person::getName, Person::getAge));

10. Using Predicate:

Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println(isEven.test(4));

11. Calculating minimum value in a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int min = numbers.stream().min(Integer::compare).get();

12. Calculating maximum value in a list:

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

13. Counting elements in a list:

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

14. Checking if all elements match a condition:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);

15. Checking if any element matches a condition:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyEven = numbers.stream().anyMatch(n -> n % 2 == 0);

16. Finding the first element that matches a condition:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int firstEven = numbers.stream().filter(n -> n % 2 == 0).findFirst().get();

17. Grouping elements in a list:

List<Person> people = Arrays.asList(new Person("John", 30), new Person("Jane", 25), new Person("Jim", 30));
Map<Integer, List<Person>> byAge = people.stream().collect(Collectors.groupingBy(Person::getAge));

18. Partitioning elements in a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> evenOdd = numbers.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0));

19. Joining elements in a list:

List<String> names = Arrays.asList("John", "Jane", "Jim");
String joined = names.stream().collect(Collectors.joining(", "));

20. Using a Consumer:

Consumer<String> printer = System.out::println;
printer.accept("Hello");

21. Using a Function:

Function<String, Integer> stringLength = String::length;
int length = stringLength.apply("Hello");

22. Using a Supplier:

Supplier<LocalDate> today = LocalDate::now;
LocalDate date = today.get();

23. Using a UnaryOperator:

UnaryOperator<Integer> square = n -> n * n;
int result = square.apply(5);

24. Using a BinaryOperator:

BinaryOperator<Integer> sum = (a, b) -> a + b;
int result = sum.apply(5, 10);

25. Using a Predicate:

Predicate<Integer> isPositive = n -> n > 0;
boolean positive = isPositive.test(5);

26. Using a Stream:

List<String> words = Arrays.asList("Hello", "World");
long count = words.stream().filter(w -> w.length() > 4).count();

27. Mapping elements in a stream:

List<String> words = Arrays.asList("Hello", "World");
List<Integer> lengths = words.stream().map(String::length).collect(Collectors.toList());

28. Flat mapping elements in a stream:

List<List<String>> lists = Arrays.asList(Arrays.asList("Hello"), Arrays.asList("World"));
List<String> words = lists.stream().flatMap(l -> l.stream()).collect(Collectors.toList());

29. Reducing elements in a stream:

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

30. Sorting elements in a stream:

List<String> words = Arrays.asList("Hello", "World");
List<String> sorted = words.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());

31. Skipping elements in a stream:

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

32. Limiting elements in a stream:

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

33. Peeking into a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> peeked = numbers.stream().peek(System.out::println).collect(Collectors.toList());

35. Grouping elements in a stream:

List<String> words = Arrays.asList("Hello", "World", "Java");
Map<Integer, List<String>> grouped = words.stream().collect(Collectors.groupingBy(String::length));

36. Partitioning elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitioned = numbers.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0));

37. Finding the maximum element in a stream:

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

38. Finding the minimum element in a stream:

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

39. Finding the sum of elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(Integer::intValue).sum();

40. Finding the average of elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream().mapToInt(Integer::intValue).average().getAsDouble();

41. Finding the first element in a stream:

List<String> words = Arrays.asList("Hello", "World", "Java");
Optional<String> first = words.stream().findFirst();

42. Finding any element in a stream:

List<String> words = Arrays.asList("Hello", "World", "Java");
Optional<String> any = words.stream().findAny();

43. Checking if all elements in a stream match a condition:

List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);

44. Checking if any element in a stream match a condition:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyEven = numbers.stream().anyMatch(n -> n % 2 == 0);

45. Checking if none of the elements in a stream match a condition:

List<Integer> numbers = Arrays.asList(1, 3, 5, 7);
boolean noneEven = numbers.stream().noneMatch(n -> n % 2 == 0);

46. Concatenating elements in a stream:

List<String> words = Arrays.asList("Hello", "World");
String concatenated = words.stream().collect(Collectors.joining(", "));
 
Converting a stream to an array:
 
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numbersArray = numbers.stream().toArray(Integer[]::new);
Converting a stream to a List:
 
Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
List<Integer> numbersList = numbers.collect(Collectors.toList());
Converting a stream to a Set:

Stream<String> words = Stream.of("Hello", "World", "Java");
Set<String> wordsSet = words.collect(Collectors.toSet());
Converting a stream to a Map:

Stream<Person> people = Stream.of(new Person("John", 25), new Person("Jane", 30));
Map<String, Integer> peopleMap = people.collect(Collectors.toMap(Person::getName, Person::getAge));
Filtering a stream using multiple conditions:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0).filter(n -> n > 2).collect(Collectors.toList());
Flattening a stream of streams:

Stream<Stream<Integer>> streamOfStreams = Stream.of(Stream.of(1, 2), Stream.of(3, 4), Stream.of(5, 6));
Stream<Integer> flatStream = streamOfStreams.flatMap(s -> s);
Peeking at elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream().peek(System.out::println).count();
Limiting the elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> firstThreeNumbers = numbers.stream().limit(3).collect(Collectors.toList());
Skipping elements in a stream:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> numbersWithoutFirstTwo = numbers.stream().skip(2).collect(Collectors.toList());
Sorting elements in a stream:

List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
List<Integer> sortedNumbers = numbers.stream().sorted().collect(Collectors.toList());
Using parallel streams:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();
Using streams with Optional values:

Optional<Integer> maybeNumber = Optional.of(5);
maybeNumber.stream().forEach(System.out::println);

 ``