函数式编程包含三部分

1、流 -- 针对集合操作

1.1 流获取

单列集合获取流： Collection.stream()
数组创建stream流：Array.stream()
map创建stream流: map->转为单列集合 entrySet/keySet/valueSet -> 生成流 .stream()

1.2 中间操作

filter -- 过滤
map -- 对元素进行计算或者转换一转一
distinct -- 去重需要注意要重写equals方法
sorted -- 无参待比较类必须实现Comparable接口有参重写比较器逻辑
limit -- 获取流里指定个数的元素
skip -- 跳过流中的前n个元素
flatMap -- 将一个对象转换成多个对象作为流中的元素 (一般用来从对象中获取集合类型的元素列表并转换成流塞进新流里)

1.3 终结操作

forEach -- 遍历操作
count -- 流中元素个数
max/min - 最大最小
collect - 流转换为集合 list/set/map集合 -- Collectors工具类
anyMatch - 任意一个符合条件返回true
allMatch - 所有元素都满足条件返回true
noneMatch - 都不符合返回true
findAny - 获取流中满足条件的任意一个元素返回Optional
findFirst - 获取流中满足条件的第一个元素返回Optional
reduce - 通过计算将数据做汇总计算输出 reduce和map搭配使用根据给定的初始值再和流里面的每个元素进行计算获取最后的输出值最大值/最小值或者求和或者除法或者乘法等

1.4 使用流操作注意事项

惰性求值 (没有终结操作，中间操作是不会得到执行的)
流是一次性的
流操作不会影响原始数据

2、函数式接口

2.1 Optional

ofNullAble -- 创建Optional对象
orElseGet -- 安全获取Optional对象里面的值没有值返回默认值
orElseThrow -- 数据不为空则获取数据否则抛出异常可以自定义异常
filter -- 过滤没有符合条件的数据返回新的空Optional
ifPresent -- 存在就消费数据不存在不消费数据
isPresent -- 存在数据返回true 可以做他消费操作，不一定只是对Optional持有数据操作也可以是其他逻辑
map -- 对数据进行转换

2.2 函数式接口粗略概论

接口只有一个抽象方法就为函数式接口
可以实例化可以在程序其他地方调用从面相对象编程转换思维到面向方法编程

3、方法引用

使用场景 -- lambda表达式场景下写法简化
哪些写法可以被简化 -- 只有一行代码而且这一行代码只调用一个方法就可以简化为方法引用(lambda表达式)
基本格式-- 类名或者对象名::方法名
静态方法重写的抽象方法把静态方法的参数都按顺序传入静态方法就可简化为方法引用 -- 类名::方法名

4、demo

authors.stream()
                .distinct()
                .filter(author -> author.getAge() > 20)
                .forEach(System.out::println);
        Map<String, Author> name2Author = authors.stream().collect(Collectors.toMap(Author::getName, author -> author));
        System.out.println(name2Author);
        name2Author.entrySet()
                .stream()
                .filter(stringAuthorEntry -> Objects.equals("kola", stringAuthorEntry.getKey()))
                .forEach(stringAuthorEntry -> {
                    System.out.println(stringAuthorEntry.getKey());
        });
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .forEach(author -> System.out.println(author.getAge()));

        authors.stream()
                .distinct()
                .sorted()
                .skip(1)
                .forEach(author -> System.out.println(author.getAddress() ));
        authors.stream()
                .flatMap((Function<Author, Stream<Book>>) author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> System.out.println(book.getBookName()));
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .flatMap(book -> Arrays.stream(book.getBookName().split(",")))
                .distinct()
                .forEach(bookName -> System.out.println(bookName));
		Optional<Integer> max = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .map(book -> book.getTotalNum())
                .max(Comparator.comparingInt(num -> num));
        System.out.println(max.get());

        Optional<Integer> min = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .map(book -> book.getTotalNum())
                .min(Comparator.comparingInt(num -> num));
        System.out.println(min.get());

秒客网

函数式编程学习笔记