lambda学习小记

1，Lambda语法特性

1. 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
4. 可选的返回关键字：如果主体只有一个表达式则编译器会自动返回值，有多个表达式则需指明return语句。

针对Lambda语法，我们能够替代使用的都是函数式接口，Lambda语法是函数式接口的实现。什么是函数式接口？函数式接口指的是只包含一个方法的接口。接口上使用@FunctionalInterface注解进行声明，可以不声明，但是为了防止后续有其他人员添加方法，最好加上。

2，常见的stream流操作与optional对象

package com.qoros.activity.provider.service.impl;

import com.qoros.activity.api.entity.Student;

import java.util.*;
import java.util.stream.Collectors;

public class StreamTest {
    public static void main(String[] args) {
        List<Student> stuList = new ArrayList<>(10);
        stuList.add(new Student("刘一", 85));
        stuList.add(new Student("陈二", 90));
        stuList.add(new Student("张三", 98));
        stuList.add(new Student("李四", 88));
        stuList.add(new Student("王五", 83));
        stuList.add(new Student("赵六", 95));
        stuList.add(new Student("孙七", 87));
        stuList.add(new Student("周八", 84));
        stuList.add(new Student("吴九", 100));
        stuList.add(new Student("郑十", 95));
        //传统写法
        //需求：列出90分以上的学生姓名，并按照分数降序排序
        ArrayList<Student> students = new ArrayList<>(10);
        for (Student student : stuList) {
            if(student.getScore() > 90){
                stuList.add(student);
            }
        }
        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o2.getScore(), o1.getScore());
            }
        });

        //lambda写法
        //需求：列出90分以上的学生姓名，并按照分数降序排序
        //sorted方法，排序方法，默认升序，通过比较器的方法Comparator.comparing可降序
        List<Student> collect = stuList.stream().filter(student -> student.getScore() > 90).sorted(Comparator.comparing(Student::getScore).reversed()).collect(Collectors.toList());
        List<Student> collect4 = stuList.stream().filter(student -> student.getScore() > 90).sorted().collect(Collectors.toList());
        //使用map方法获取list数据中的name
        List<String> collect1 = stuList.stream().map(student -> student.getName()).collect(Collectors.toList());
        //使用map方法获取list数据中的name的长度
        List<Integer> collect2 = stuList.stream().map(student -> student.getName().length()).collect(Collectors.toList());
        //将每人的分数-10
        List<Integer> collect3 = stuList.stream().map(student -> student.getScore() - 10).collect(Collectors.toList());
        //计算学生总分,注：reduce方法可以有1or2or3个参数，此处为2个参数的reduce方法，参数1为计算初始值，参数2为两个数字运算的逻辑
        Integer reduce = stuList.stream().map(Student::getScore).reduce(0, (a, b) -> a + b);
        //将学生姓名拼接
        stuList.stream().map(Student::getName).reduce((s1,s2) ->s1.concat(s2));
        //计算学生总分，返回Optional类型的数据，改类型是java8中新增的，主要用来避免空指针异常
        Optional<Integer> reduce1 = stuList.stream().map(Student::getScore).reduce((a, b) -> a + b);
        //计算最高分和最低分
        stuList.stream().map(Student::getScore).reduce(Integer::max);
        stuList.stream().map(Student::getScore).reduce(Integer::min);
        //关于和值，平均值，在java8中新增了三个原始类型流（IntStream、DoubleStream、LongStream）来解决这类问题

        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        // 获取对应的平方数
        //distinct方法 ：去重
        List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        // 获取空字符串的数量
        long count = strings.stream().filter(s -> s.isEmpty()).count();
        /*limit
        limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：*/
        Random random = new Random();
        random.ints().limit(10).forEach(System.out::println);

        /*并行（parallel）程序:在某些可以支持并行处理的情况下，并行可以提高执行效率
        parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：*/
        List<String> strings1 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        // 获取空字符串的数量
        long count1 = strings.parallelStream().filter(string -> string.isEmpty()).count();
        //我们可以很容易的在顺序运行和并行直接切换。

        //Collectors.toList()转换成集合
        List<String> strings2 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
        System.out.println("筛选列表: " + filtered);
        //Collectors.joining(", ")转换成聚合元素
        String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
        System.out.println("合并字符串: " + mergedString);

		Stream流的Collectors.toMap参数介绍
		参数介绍
		参数1：将对象的getPropkey作为map的key值
		参数2：将对象的getPropvalue作为map的value值
		参数3：当出现key值相同时，选取前面的作为value值，就是出现相同key时，后面的不覆盖前面的
		参数4：默认返回的map类型为hashMap，可以自己返回不同的map实现
		Map<String,BzDealer> dealerMap  = dealerList.stream().collect(Collectors.toMap(BzDealer::getDealerCode, 			      BzDealer->BzDealer, (value1, value2 )->{
                value2;
            }));
            
        //Optional对象
        //计算分数在60分以下的分数总和
        Optional<Integer> reduce2 = stuList.stream().filter(student -> student.getScore() < 60).map(Student::getScore).reduce((a, b) -> a + b);
        //orElse方法：Value不为空则返回Value，否则返回传入的值；
        System.out.println(reduce2.orElse(0));

        Map<Integer,String> map = new HashMap<>();
        map.put(20180001,"章子");
        map.put(20180002,"小米");
        map.put(20180003,"大黄");
        map.put(20180004,"靓妹");

        /*Optional.ofNullable方法：根据传入值构建一个Optional对象，
        传入的值可以是空值，如果传入的值是空值，则与Optional.empty返回的结果是一样，为一个空的Optional对象。*/
        String name = Optional.ofNullable(map.get(20180005)).orElse("无");
        System.out.println(name);  //无

        /*几种判空的情况：
         1，函数--返回是否为空，不为空则使用
         2，变量--是否为空，为空使用默认值
                          为空抛出异常，否则使用
         使用思路;
            1,函数--把函数的返回值使用Optional.ofNullable封装为optional对象，然后对optional做判空
            2,变量--把变量使用Optional.ofNullable封装为optional对象，然后对optional做操作
        */
    }
}

注：本文内容为结合多篇文章整理，主要参考以下文章：
https://blog.csdn.net/zl_StepByStep/article/details/82729657