# 提高生产力！这10个Lambda表达式必须掌握，开发效率嘎嘎上升！

### 集合遍历

List<String> list = Arrays.asList("a", "b", "c");
for (String s : list) {
System.out.println(s);
}


list.forEach(System.out::println);


### 集合排序

Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
});


List<String> sortedList = list.sort(Comparator.comparingInt(String::length));

// 或者
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());

// 或者
Collections.sort(list, Comparator.comparingInt(String::length));


### 集合过滤

List<String> filterList = new ArrayList<>();
for (String s : list){
if (s.length() >= 4){
}
}


List<String> filterList = list.stream().filter(e -> e.length() >= 4).collect(Collectors.toList());


### 映射操作

List<String> upperCaseList = new ArrayList<>();
for (String str : words) {
}


List<String> upperList = list.stream().map(e -> e.toUpperCase()).collect(Collectors.toList());
upperList = list.stream().map(String::toUpperCase).collect(Collectors.toList());

List<Integer> lengthList = list.stream().map(e -> e.length()).collect(Collectors.toList());
lengthList = list.stream().map(String::length).collect(Collectors.toList());


### 规约操作

int sum = 0;
for (int num : numbers) {
sum += num;
}


int sum = numbers.stream().mapToInt(Integer::intValue).sum();
int sum = numbers.stream().reduce(0, (n1, n2) -> n1 + n2);
int sum = numbers.stream().reduce(0, Integr::sum);

List<Person> peoples = new ArrayList<>();
int ages = peoples.stream().mapToInt(Person::getAge).sum();


### 分组操作

List<Person> personList = new ArrayList<>();
Map<String, List<Person>> groupMap = new HashMap<>();
for (Person person : personList) {
Integer age = person.getAge();
if (!groupMap.containsKey(age)) {
groupMap.put(age, new ArrayList<>());
}
}


Map<String, List<Person>> groupMap = words.stream()
.collect(Collectors.groupingBy(Person::age));


List<Person> personList = new ArrayList<>();
Map<Long, Person> personMap = new HashMap<>();
for (Person person : personList) {
personMap.put(person.getId(), person);
}


Map<String, Person> groupMap = words.stream()
.collect(Collectors.toMap(Person::id, Function.identity(), (e1, e2) -> e1));


### 使用函数式接口

@FunctionalInterface
interface MyInterface{
void doSomething(String s);
}


MyInterface myInterface = new MyInterface() {
@Override
public void doSomething(String s) {
System.out.println(s);
}
};



MyInterface myInterface = s -> System.out.println(s);


### 线程创建

Thread thread = new Thread(new Runnable() {
@Override
public void run() {
}
});


Thread thread = new Thread(() -> System.out.println("Hello, 码农Academy!"));

// 或者使用线程池方式


### Optional

Optional可以避免空指针异常。

Optional<String> optional = ...;
if (optional.isPresent()) {
String value = optional.get();
// 处理value
}


Optional<String> optional = ...;
optional.ifPresent(value -> handleValue(value));


### Stream的流水操作



List<Integer> result = new ArrayList<>();
for (String str : list) {
if (str.matches("\\d+")) {
}
}


List<Integer> result = list.stream()
.filter(str -> str.matches("\\d+"))
.map(Integer::parseInt)
.collect(Collectors.toList());


/**
* 根据学生姓名查询除重复元素
* @param students
*/
private static void repeatStudentsTest(List<Student> students){
// list 对应的 Stream
List<String> repeatStudents =   students.stream()
// 获得元素出现频率的 Map，键为元素，值为元素出现的次数
.collect(Collectors.toMap(e -> e.getName(), e -> 1, Integer::sum))
// 所有 entry 对应的 Stream
.entrySet().stream()
// 过滤出元素出现次数大于 1 的 entry（过滤出来的是重复的，若这里条件是等于，即可达到去重的目的）
.filter(entry -> entry.getValue()>1)
// 获得 entry 的键（重复元素）对应的 Stream
.map(entry -> entry.getKey())
// 转化为 List
.collect(Collectors.toList());

repeatStudents.forEach(repeatStudent -> {
System.out.println(repeatStudent);
});
}
`

### Lambda易读

1. 匿名性：Lambda表达式本质上是匿名函数，没有显式的方法名称，因此，初次接触或不熟悉其语法的读者可能难以快速理解其意图，尤其是在较复杂的上下文中。

2. 简洁性：Lambda表达式的目的是为了简化代码，它往往非常紧凑，可能会把原本分散在多个行或方法中的逻辑压缩到一行甚至一部分内。这样的代码密度可能导致理解上的难度，特别是当逻辑较为复杂时。

3. 抽象层次：Lambda表达式常与函数式接口一起使用，这意味着理解Lambda表达式需要知道它所对应接口的行为约定。如果读者不了解接口的具体功能，那么Lambda表达式就可能变得难以解读。

4. 函数式编程范式：对于习惯于命令式编程风格的开发者来说，函数式编程的思维方式和Lambda表达式的使用可能需要一定适应期。尤其是涉及到闭包、高阶函数等概念时，如果不熟悉这些概念，理解Lambda表达式的逻辑会更加困难。

5. 依赖上下文：Lambda表达式经常用于流(Stream)操作、事件监听、回调函数等场景，其含义高度依赖于上下文环境。在缺少充分注释或文档的情况下，阅读者可能需要花费更多精力去推理其作用。

### 总结

posted @ 2024-04-03 09:35  码农Academy  阅读(1150)  评论(1编辑  收藏  举报