JAVA8，常用Lambda总结。

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

public class TestMain {
    
    

    public static void main(String[] args) {
    
    
        List<User> userList = new ArrayList<>();

        userList.add(new User(1,"张三",12,1));
        userList.add(new User(2,"王五",22,2));
        userList.add(new User(3,"李四",23,3));
        userList.add(new User(4,"赵六",24,4));
        userList.add(new User(5,"李前",52,5));
    }
}    

list ，字段排序

单个字段排序，根据年龄升序排序

userList = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList())

根据年龄降序排序

//方法1：先对年龄进行升序，结果进行反转
userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

//方法2：直接对年龄进行降序
userList = userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder())).collect(Collectors.toList());
userList.forEach(System.out::println);

多个字段排序,年龄升序，班级升序

userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getClassNo)).collect(Collectors.toList());
userList.forEach(System.out::println);

年龄降序，班级升序

//方法1：先对年龄进行升序，升序结果进行反转，再进行班级升序
userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getClassNo)).collect(Collectors.toList());


//方法2：直接对年龄进行降序，再对班级进行升序
userList = userList.stream().sorted(Comparator.comparing(User::getAge,Comparator.reverseOrder()).thenComparing(User::getClassNo)).collect(Collectors.toList());

年龄降序，班级降序

//方法1：先对年龄进行升序，升序结果进行反转，再对班级进行降序
userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getClassNo, Comparator.reverseOrder())).collect(Collectors.toList());

//方法2：直接对年龄进行降序，再对班级进行降序
userList = userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getClassNo, Comparator.reverseOrder())).collect(Collectors.toList());

//方式3：先对年龄进行升序，再对班级进行升序，最后对结果进行反转
userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getClassNo).reversed()).collect(Collectors.toList());

年龄升序，班级降序

//方法1：先对年龄进行升序，升序结果进行反转，再进行班级升序，结果进行反转(有点绕，年龄被排了三次升-降-升)
userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getClassNo).reversed()).collect(Collectors.toList());

//方法2：直接对年龄进行升序，再对班级进行降序
userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getClassNo, Comparator.reverseOrder())).collect(Collectors.toList());

总结：

• 如果只进行单个字段的升序降序排列，我们使用reversed()或者Comparator.reverseOrder()都可以，

• 如果要进行多个字段的升序降序排列，我们还是使用Comparator.reverseOrder()会更优雅、更好理解一些

list 转 map

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

filter（）过滤

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

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

foreach 遍历

foreach 遍历list，遍历map

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

        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("1", "张三");
        hashMap.put("2", "李四");
        hashMap.put("3", "王五");

        /**
         *  forEach 遍历集合Map
         */
        hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v));

groupingBy 分组

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

Map<Integer, List<User>> result = userList.stream().collect(Collectors.groupingBy(User::getClassNo));

result.forEach((k, v) -> System.out.println(k + ":\t" + v));

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);

findFirst 返回第一个

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

anyMatch 是否至少匹配一个元素

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

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

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方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性

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

Reduce

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

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

peek 打印个日志

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

List<String> result = Stream.of("张三", "李四", "王五")
            .filter(a -> a.contains("张三"))
            .peek(a -> System.out.println("姓名:" + a)).collect(Collectors.toList());
System.out.println(result);
//运行结果
姓名:张三

[张三]

Max，Min 最大最小

求最大，最小值

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

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

count 统计

获取流数据元素总数

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