我用Lambda表达式写代码，开发速度提高了10倍！Lambda表达式基础详讲

最新推荐文章于 2023-12-08 15:27:41 发布

包先森

最新推荐文章于 2023-12-08 15:27:41 发布

阅读量264

点赞数

文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/weixin_44606690/article/details/128188904

版权

1. list 转 map

工作中，我们经常遇到list转map的案例。Collectors.toMap就可以把一个list数组转成一个Map。代码如下：

public static void main(String[] args) {

    List<UserInfo> userInfoList = new ArrayList<>();
    userInfoList.add(new UserInfo(1L, "卡里比", 18));
    userInfoList.add(new UserInfo(2L, "不开心", 27));
    userInfoList.add(new UserInfo(2L, "没头脑", 26));

    /**
     *  list 转 map
     *  使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1, k2) -> k1
     *  (k1, k2) -> k1 表示，如果有重复的key,则保留第一个，舍弃第二个
     */
    Map<Long, UserInfo> userInfoMap = userInfoList.stream().collect(Collectors.toMap(UserInfo::getUserId, userInfo -> userInfo, (k1, k2) -> k1));
    userInfoMap.values().forEach(a->System.out.println(a.getUserName()));
}

运行结果
卡里比
不开心

类似的，还有Collectors.toList()、Collectors.toSet()，表示把对应的流转化为list或者Set。

2. filter（）过滤

从数组集合中，过滤掉不符合条件的元素，留下符合条件的元素。

public static void main(String[] args) {

    List<UserInfo> userInfoList = new ArrayList<>();
    userInfoList.add(new UserInfo(1L, "卡里比", 18));
    userInfoList.add(new UserInfo(2L, "不开心", 27));
    userInfoList.add(new UserInfo(2L, "没头脑", 26));

    /**
     * filter 过滤，留下超过18岁的用户
     */
    List<UserInfo> userInfoResultList = userInfoList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
    userInfoResultList.forEach(a -> System.out.println(a.getUserName()));

}
运行结果
不开心
没头脑

3. foreach 遍历

foreach 遍历list，遍历map，真的很丝滑。

public static void main(String[] args) {

    List<String> userNameList = Arrays.asList("卡里比", "不开心", "没头脑");
    userNameList.forEach(System.out::println);

    HashMap<String, String> hashMap = new HashMap<>();
    hashMap.put("游戏名", "卡里比");
    hashMap.put("小明", "不开心");
    hashMap.put("抖音名", "没头脑");
    /**
     *  forEach 遍历集合Map
     */
    hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v));
}
卡里比
不开心
没头脑
小明:	不开心
抖音名:	没头脑
游戏名:	卡里比

4. groupingBy 分组

提到分组，相信大家都会想起SQL的group by。我们经常需要一个List做分组操作。比如，按城市分组用户。在Java8之前，是这么实现的：

List<UserInfo> originUserInfoList = new ArrayList<>();
originUserInfoList.add(new UserInfo(1L, "卡里比", 18,"深圳"));

originUserInfoList.add(new UserInfo(3L, "不开心", 26,"湛江"));
originUserInfoList.add(new UserInfo(2L, "没头脑", 27,"深圳"));
Map<String, List<UserInfo>> result = new HashMap<>();
for (UserInfo userInfo : originUserInfoList) {
  String city = userInfo.getCity();
  List<UserInfo> userInfos = result.get(city);
  if (userInfos == null) {
      userInfos = new ArrayList<>();
      result.put(city, userInfos);
    }
  userInfos.add(userInfo);
}

而使用Java8的groupingBy分组器，清爽无比:

Map<String, List<UserInfo>> result = originUserInfoList.stream()
.collect(Collectors.groupingBy(UserInfo::getCity));

5. sorted+Comparator 排序

工作中，排序的需求比较多，使用sorted+Comparator排序，真的很香。

public static void main(String[] args) {

    List<UserInfo> userInfoList = new ArrayList<>();
    userInfoList.add(new UserInfo(1L, "卡里比", 18));
    userInfoList.add(new UserInfo(3L, "不开心", 26));
    userInfoList.add(new UserInfo(2L, "没头脑", 27));

    /**
     *  sorted + Comparator.comparing 排序列表，
     */
    userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
    userInfoList.forEach(a -> System.out.println(a.toString()));

    System.out.println("开始降序排序");

    /**
     * 如果想降序排序，则可以使用加reversed()
     */
    userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
    userInfoList.forEach(a -> System.out.println(a.toString()));

}

运行结果
UserInfo(userId=1, userName=卡里比, age=18)
UserInfo(userId=3, userName=不开心, age=26)
UserInfo(userId=2, userName=没头脑, age=27)
开始降序排序
UserInfo(userId=2, userName=没头脑, age=27)
UserInfo(userId=3, userName=不开心, age=26)
UserInfo(userId=1, userName=卡里比, age=18)

6.distinct 去重

distinct可以去除重复的元素:

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
List<String> temp = list.stream().distinct().collect(Collectors.toList());
temp.forEach(System.out::println);

7. findFirst 返回第一个

findFirst 很多业务场景，我们只需要返回集合的第一个元素即可：

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
list.stream().findFirst().ifPresent(System.out::println);

8. anyMatch 是否至少匹配一个元素

anyMatch 检查流是否包含至少一个满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.anyMatch(s -> s.contains("C"));
System.out.println(match);
//输出
true

9. allMatch 匹配所有元素

allMatch 检查流是否所有都满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.allMatch(s -> s.contains("C"));
System.out.println(match);
//输出
false

10. map 转换

map方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性，demo如下：

List<String> list = Arrays.asList("jay", "tianluo");
//转化为大写
List<String> upperCaselist = list.stream().map(String::toUpperCase).collect(Collectors.toList());
upperCaselist.forEach(System.out::println);

11. Reduce

Reduce可以合并流的元素，并生成一个值

int sum = Stream.of(1, 2, 3, 4).reduce(0, (a, b) -> a + b);
System.out.println(sum);

12.peek 打印个日志

peek()方法是一个中间Stream操作，有时候我们可以使用peek来打印日志。

public static void main(String[] args) {

    List<UserInfo> userInfoList = new ArrayList<>();
    userInfoList.add(new UserInfo(1L, "卡里比", 18));
    userInfoList.add(new UserInfo(3L, "不开心", 26));
    userInfoList.add(new UserInfo(2L, "没头脑", 27));
    List<String> result = Stream.of("卡里比", "卡里比不开心", "没头脑")
            .filter(a -> a.contains("卡里比"))
            .peek(a -> System.out.println("输出文本" + a)).collect(Collectors.toList());
    System.out.println(result);
}

输出数据：
输出文本卡里比
输出文本卡里比不开心
[卡里比, 卡里比不开心]

13. Max，Min 最大最小

使用lambda流求最大，最小值，非常方便。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "卡里比", 18));
userInfoList.add(new UserInfo(3L, "不开心", 26));
userInfoList.add(new UserInfo(2L, "没头脑", 27));

Optional<UserInfo> maxAgeUserInfoOpt = userInfoList.stream().max(Comparator.comparing(UserInfo::getAge));
maxAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("max age user:" + userInfo));

Optional<UserInfo> minAgeUserInfoOpt = userInfoList.stream().min(Comparator.comparing(UserInfo::getAge));
minAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("min age user:" + userInfo));

//运行结果
max age user:UserInfo(userId=2, userName=没头脑, age=27)
min age user:UserInfo(userId=1, userName=卡里比, age=18)

14. count 统计

一般count()表示获取流数据元素总数。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "卡里比", 18));
userInfoList.add(new UserInfo(3L, "不开心", 26));
userInfoList.add(new UserInfo(2L, "没头脑", 27));

long count = userInfoList.stream().filter(user -> user.getAge() > 18).count();
System.out.println("大于18岁的用户:" + count);
//输出
大于18岁的用户:2

15. 常用函数式接口

其实lambda离不开函数式接口，我们来看下JDK8常用的几个函数式接口：

Function<T, R>（转换型）: 接受一个输入参数，返回一个结果
Consumer （消费型）: 接收一个输入参数，并且无返回操作
Predicate （判断型）: 接收一个输入参数，并且返回布尔值结果
Supplier （供给型）: 无参数，返回结果

Function<T, R> 是一个功能转换型的接口，可以把将一种类型的数据转化为另外一种类型的数据

Function<String, Integer> function = String::length;
Stream<String> stream = Stream.of("卡里比", "没头脑", "不开心");
Stream<Integer> resultStream = stream.map(function);
resultStream.forEach(System.out::println);
输出：
5
4
6

Consumer是一个消费性接口，通过传入参数，并且无返回的操作

Consumer<String> comsumer = System.out::println;
Stream<String> stream = Stream.of("卡里比", "没头脑", "不开心");
stream.forEach(comsumer);
输出：
卡里比
没头脑
不开心

Function<T, R> Predicate是一个判断型接口,并且返回布尔值结果.

Predicate<Integer> predicate = a -> a > 18;
UserInfo userInfo = new UserInfo(2L, "卡里比", 18);
System.out.println(predicate.test(userInfo.getAge()));
输出：
false

Supplier是一个供给型接口,无参数，有返回结果。

Supplier<Integer> supplier = () -> Integer.valueOf("666");
System.out.println(supplier.get());
输出：
666

这几个函数在日常开发中，也是可以灵活应用的，比如我们DAO操作完数据库，是会有个result的整型结果返回。我们就可以用Supplier来统一判断是否操作成功。如下：

private void saveDb(Supplier<Integer> supplier) {
        if (supplier.get() > 0) {
        System.out.println("插入数据库成功");
        }else{
        System.out.println("插入数据库失败");
        }
        }

@Test
public void add() throws Exception {
        Course course=new Course();
        course.setCname("java");
        course.setUserId(100L);
        course.setCstatus("Normal");
        saveDb(() -> courseMapper.insert(course));
        }