Lambda expressions are an increasingly common feature in modern programming languages that simplify code and increase productivity. This article will introduce 10 Lambda expressions that must be mastered. These expressions cover common scenarios that are often used in actual programming, such as list operations, function composition, and conditional filtering. By learning these Lambda expressions, you will gain a deeper understanding of functional programming ideas and be able to write code more efficiently.
1. Use Lambda expression for collection traversal
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); for (String fruit : list) { System.out.println(fruit); }
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); list.forEach(fruit -> System.out.println(fruit));
2. Sorting using Lambda expressions
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); Collections.sort(list, new Comparator<String>() { public int compare(String s1, String s2) { return s1.compareTo(s2); } });
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); Collections.sort(list, (s1, s2) -> s1.compareTo(s2));
3. Filter using Lambda expressions
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<String> filteredList = new ArrayList<String>(); for (String fruit : list) { if (fruit.startsWith("a")) { filteredList.add(fruit); } }
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).collect(Collectors.toList());
4. Mapping with Lambda Expressions
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<Integer> lengths = new ArrayList<Integer>(); for (String fruit : list) { lengths.add(fruit.length()); }
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<Integer> lengths = list.stream().map(fruit -> fruit.length()) .collect(Collectors.toList());
5. Reduction using Lambda expressions
Lambda expressions are not used:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); int sum = 0; for (int i : list) { sum += i; }
Use lambda expressions:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); int sum = list.stream().reduce(0, (a, b) -> a + b);
6. Grouping with Lambda Expressions
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>(); for (String fruit : list) { int length = fruit.length(); if (!grouped.containsKey(length)) { grouped.put(length, new ArrayList<String>()); } grouped.get(length).add(fruit); }
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); Map<Integer, List<String>> grouped = list.stream().collect(Collectors.groupingBy(fruit -> fruit.length()));
7. Use Lambda expressions to implement functional interfaces
Lambda expressions are not used:
public interface MyInterface { public void doSomething(String input); } MyInterface myObject = new MyInterface() { public void doSomething(String input) { System.out.println(input); } }; myObject.doSomething("Hello World");
Use lambda expressions:
MyInterface myObject = input -> System.out.println(input); myObject.doSomething("Hello World");
8. Use Lambda expressions to create threads
Lambda expressions are not used:
Thread thread = new Thread(new Runnable() { public void run() { System.out.println("Thread is running."); } }); thread.start();
Use lambda expressions:
Thread thread = new Thread(() -> System.out.println("Thread is running.")); thread.start();
9. Use Lambda expressions for Optional operations
Lambda expressions are not used:
String str = "Hello World"; if (str != null) { System.out.println(str.toUpperCase()); }
Use lambda expressions:
Optional<String> str = Optional.ofNullable("Hello World"); str.map(String::toUpperCase).ifPresent(System.out::println);
10. Use Lambda expression to perform Stream pipeline operation
Lambda expressions are not used:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<String> filteredList = new ArrayList<String>(); for (String fruit : list) { if (fruit.startsWith("a")) { filteredList.add(fruit.toUpperCase()); } } Collections.sort(filteredList);
Use lambda expressions:
List<String> list = Arrays.asList("apple", "banana", "orange"); List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).map(String::toUpperCase).sorted().collect(Collectors.toList());