Java中使用Lambda表达式写代码，实在是优雅

Java中使用Lambda表达式写代码，实在是优雅

前言

日常开发中，我们很多时候需要用到Java 8的Lambda表达式，它允许把函数作为一个方法的参数，让我们的代码更优雅、更简洁。所以整理了一波工作中，我常用的，有哪些Lambda表达式。看完一定会有帮助的

List 转 Map

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

public void test1() {
    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::getId, userinfo -> userinfo, (k1, k2) -> k1));
    userInfoMap.values().forEach(item -> System.out.println(item.getUsername()));
}

结果：

木子腾
程序员木子腾

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

filter 过滤

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

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(userInfo -> userInfo.getAge() > 18).collect(Collectors.toList());
userInfoResultList.forEach(item -> System.out.println(item.getUsername()));

结果：

程序员木子腾
打代码的木子腾

foreach 遍历

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

/**
 * forEach 遍历集合List列表
 */
List<String> userNameList = Arrays.asList("木子腾", "程序员木子腾", "打代码的木子腾");
userNameList.forEach(System.out::println);

HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("姓名", "木子腾");
hashMap.put("职业", "程序员");
hashMap.put("昵称", "LiLi");
/**
 * forEach 遍历集合Map
 */
hashMap.forEach((k, v) -> System.out.println(k + "：\t" + v));

结果：

木子腾
程序员木子腾
打代码的木子腾
姓名：	木子腾
职业：	程序员
昵称：	LiLi

groupingBy 分组

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

List<UserInfo> originUserInfoList = new ArrayList<>();
originUserInfoList.add(new UserInfo(1L, "木子腾", 18, "深圳"));
originUserInfoList.add(new UserInfo(2L, "程序员木子腾", 27, "深圳"));
originUserInfoList.add(new UserInfo(3L, "打代码的木子腾", 26, "河南"));
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));
result.forEach((k, v) -> System.out.println(k + ":\t" + v));

结果：

河南:	[UserInfo(id=3, username=打代码的木子腾, age=26, city=河南)]
深圳:	[UserInfo(id=1, username=木子腾, age=18, city=深圳), UserInfo(id=2, username=程序员木子腾, age=27, city=深圳)]

sorted+Comparator 排序

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

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "木子腾", 18));
userInfoList.add(new UserInfo(2L, "程序员木子腾", 27));
userInfoList.add(new UserInfo(3L, "打代码的木子腾", 26));
/**
 * sorted + Comparator.comparing 排序列表，
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
userInfoList.forEach(item -> System.out.println(item.toString()));
System.out.println("开始降序排序");
/**
 * 如果想降序排序，则可以使用加reversed()
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
userInfoList.forEach(item -> System.out.println(item.toString()));

结果：

UserInfo(id=1, username=木子腾, age=18, city=null)
UserInfo(id=3, username=打代码的木子腾, age=26, city=null)
UserInfo(id=2, username=程序员木子腾, age=27, city=null)
开始降序排序
UserInfo(id=2, username=程序员木子腾, age=27, city=null)
UserInfo(id=3, username=打代码的木子腾, age=26, city=null)
UserInfo(id=1, username=木子腾, age=18, city=null)

distinct 去重

distinct可以去除重复的元素:

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

结果：

A
B
F
C

findFirst 返回第一个

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

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

结果：

A

anyMatch 是否至少匹配一个元素

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

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

结果：

true

allMatch 匹配所有元素

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

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

结果：

false

map 转换

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

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

结果：

JAY
TIANLUO

Reduce

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

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

结果：

10

peek 打印个日志

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

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "木子腾", 18));
userInfoList.add(new UserInfo(2L, "程序员木子腾", 27));
userInfoList.add(new UserInfo(3L, "打代码的木子腾", 26));

List<UserInfo> result = userInfoList.stream()
    .filter(userInfo -> userInfo.getAge() > 18)
    .peek(userInfo -> System.out.println("打印：" + userInfo))
    .collect(Collectors.toList());
System.out.println(result);

结果：

打印：UserInfo(id=2, username=程序员木子腾, age=27, city=null)
打印：UserInfo(id=3, username=打代码的木子腾, age=26, city=null)
[UserInfo(id=2, username=程序员木子腾, age=27, city=null), UserInfo(id=3, username=打代码的木子腾, age=26, city=null)]

Max，Min 最大最小

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

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "木子腾", 18));
userInfoList.add(new UserInfo(2L, "程序员木子腾", 27));
userInfoList.add(new UserInfo(3L, "打代码的木子腾", 26));

userInfoList.stream()
    .max(Comparator.comparing(UserInfo::getAge))
    .ifPresent(userInfo -> System.out.println("最大年龄为：" + userInfo.getAge()));
userInfoList.stream()
    .min(Comparator.comparing(UserInfo::getAge))
    .ifPresent(userInfo -> System.out.println("最小年龄为：" + userInfo.getAge()));

结果：

最大年龄为：27
最小年龄为：18

count 统计

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

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "木子腾", 18));
userInfoList.add(new UserInfo(2L, "程序员木子腾", 27));
userInfoList.add(new UserInfo(3L, "打代码的木子腾", 26));

long count = userInfoList.stream().filter(userInfo -> userInfo.getAge() > 18).count();
System.out.println(count);

结果：

2

常用函数式接口

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

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

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

public void testFunction() {
    // 获取每个字符串的长度，并且返回
    Function<String, Integer> function = String::length;
    Stream<String> stream = Stream.of("木子腾", "程序员木子腾", "打代码的木子腾");
    Stream<Integer> integerStream = stream.map(function);
    integerStream.forEach(System.out::println);
}

结果：

3
6
7

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

public void testConsumer() {
    // 获取每个字符串的长度，并且返回
    Consumer<String> consumer = System.out::println;
    Stream<String> stream = Stream.of("木子腾", "程序员木子腾", "打代码的木子腾");
    stream.forEach(consumer);
}

结果：

木子腾
程序员木子腾
打代码的木子腾

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

public void testPredicate() {
    // 获取每个字符串的长度，并且返回
    Predicate<Integer> predicate = a -> a > 18;
    UserInfo userInfo = new UserInfo(2L, "木子腾", 27);
    System.out.println(predicate.test(userInfo.getAge()));
}

结果：

true

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

public void testSupplier() {
    Supplier<Integer> supplier = () -> Integer.valueOf("666");
    System.out.println(supplier.get());

}

结果：

666

更多文章在我的语雀平台：https://www.yuque.com/ambition-bcpii/muziteng