一、函数式编程思想

1 概念

面向对象思想需要关注用什么对象完成什么时期，而函数式编程思想更类似于我们数学中的函数，它主要关注的是对数据进行了什么操作

2 优点

• 代码简洁，开发快速
• 接近自然语言，易于理解
• 易于"并发编程"

二、lambda表达式

1 概述

lambda是JDK8中的一个语法糖，他可以对某些匿名内部类的写法进行简化。它是函数式编程的一个重要体现，让我们不用关注是什么对象，而是关注我们对数据进行了什么操作

2 核心原则

可推导可省略

3 基本格式

(参数列表)->{代码}
例一： 我们在创建现场并启动时可以使用匿名内部类的写法

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱java");
            }
        }).start();

使用lambda进行修改

new Thread(()-> System.out.println("我爱java")).start();

例二：

    public static int caclutareNum(IntBinaryOperator operator) {
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }

    public static void main(String[] args) {
        //匿名内部类写法
        final int res = caclutareNum(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });
        System.out.println(res);
        //lambda表达式写法
        final int i = caclutareNum((int left, int right) -> left+right);
        System.out.println(i);
    }

例三：

    public static void printNum(IntPredicate intPredicate){
        int[] arr={1,2,3,4,5,6,7};
        for(int i:arr){
            if(intPredicate.test(i)){
                System.out.println(i);
            }
        }
    }

    public static void main(String[] args) {
        //匿名内部类写法
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value%2==0;
            }
        });
        //lambda表达式写法
        printNum((int value)-> value%2==0);
    }

例四

    public static void main(String[] args) {
        //匿名内部类写法
        final Integer integer = tryConver(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });
        System.out.println(integer);
        //lambda写法
        final Integer integer1 = tryConver(Integer::valueOf);
        System.out.println(integer1);
    }

    public static <R> R tryConver(Function<String,R> function){
        String str="123456";
         R result = function.apply(str);
        return result;
    }

例五

    public static void main(String[] args) {
        //匿名内部类写法
        foreachArray(new IntConsumer() {
            @Override
            public void accept(int value) {
                System.out.println("value"+value);
            }
        });
        //lambda写法
        foreachArray((int value)-> System.out.println("value"+value));
    }

    public static void foreachArray(IntConsumer intConsumer){
        int[] arr={1,2,3,4,5,6,7};
        for(int i:arr){
            intConsumer.accept(i);
        }
    }

三、lambda省略规则

• 参数类型可以省略
• 方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
• 方法只有一个参数时小括号可以省略
• 以上规则都记不住也可以省略不记

四、Stream流

1 概述

java 中的Stream使用的是函数式编程模式，，如同它的名字一样，它可以被用来对集合或数组进行链状流式的操作，可以更方便的让我们对集合或者数组进行操作

2 数据准备

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode//用于后期的去重操作
@Builder
public class Author {
    private Long id;
    private String name;
    private Integer age;
    //作品
    private List<Book> book;

    public static class Book{

    }

    public static List<Author> getAuthors(){
        List<Book> book=new ArrayList<>();
        book.add(Book.builder().name("西游记").category("哲学,爱情").build());
        book.add(Book.builder().name("红楼梦").category("哲学,爱情").build());

        List<Book> book2=new ArrayList<>();
        book2.add(Book.builder().name("三国演义").category("哲学,爱情").build());
        book2.add(Book.builder().name("水浒传").category("哲学,爱情").build());

        List<Book> book3=new ArrayList<>();
        book3.add(Book.builder().name("白娘子").category("哲学,爱情").build());
        book3.add(Book.builder().name("水浒传").category("哲学,爱情").build());

        List<Author> list=new ArrayList<>();
        list.add(Author.builder().id(1L).name("张三").age(33).book(book).build());
        list.add(Author.builder().id(2L).name("李四").age(15).book(book2).build());
        list.add(Author.builder().id(3L).name("王五").age(14).book(book3).build());
        list.add(Author.builder().id(3L).name("王五").age(14).book(book3).build());
        return list;
    }
}

3 快速入门

    public static void main(String[] args) {
        List<Author> authors=Author.getAuthors();
        //打印所有年龄小于18的作家的名字，并去重
        authors.stream()//把集合转换成流
                .distinct()//去除重复的作家
                .filter(author -> author.getAge()<18)//筛选年龄小于18的
                .forEach(item-> System.out.println(item));//遍历打印作家
    }

4 常用操作

4.1 创建流

• 单例集合 集合对象.stream()

List<Author> authors=Author.getAuthors();
Stream<Author> stream = authors.stream();

• 数组：Arrays.stream(数组) 或者使用Stream.of 来创建

Integer[] arr={1,2,3};
Stream<Integer> stream1 = Arrays.stream(arr);
Stream<Integer> arr1 = Stream.of(arr);

• 双列集合：转换为单列集合后在创建

Map<String,Object> map=new HashMap<>();
map.put("aa",1);
Stream<Map.Entry<String, Object>> stream1 = map.entrySet().stream();

5 中间操作

5.1 filter

可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中

List<Author> authors = Author.getAuthors();
//打印年龄大于18的作家
authors.stream().filter(item->item.getAge()>18).forEach(item-> System.out.println(item));

5.2 map

把流中的元素进行计算或转换

        //map 转换
         List<Author> authors = Author.getAuthors();
        //打印所有作家的名字
        authors.stream()
                .map(author -> author.getName())
                .forEach(item-> System.out.println(item));
       
       //map age计算
        authors.stream()
                .map(author -> author.getAge()+100)
                .forEach(item-> System.out.println(item));
       //多个map,先转换在计算
       authors.stream()
                .map(item->item.getAge())
                .map(item->item+10)
                .forEach(item-> System.out.println(item));

5.3 distinct

去除流中的重复原因

         List<Author> authors = Author.getAuthors();
         //打印所有的作家的名字，并且要求不能有重复的元素
         authors.stream()
                 .distinct()
                 .forEach(item-> System.out.println(item.getName()));

注意：distinct方法是依赖Object的equals方法来判断是否是相同对象的，所以在注意重写equals方法

5.4 sort

可以对流中的元素进行排序
无参数的sort方法使用需要类实现Comparable接口

         List<Author> authors = Author.getAuthors();
         //对流中的所有元素进行降序排序，并且要求不能有重复的元素
        //无参数的sort方法使用需要类实现Comparable接口
         authors.stream().distinct().sorted()
                 .forEach(item-> System.out.println(item));
        //有参的sort方法
         authors.stream().distinct()
                 .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                 .forEach(item-> System.out.println(item));

注意：如果调用空的sort()方法，需要流中的元素实现Comparable

5.5 limit

可以设置流的最大长度，超出的部分将被抛弃

         List<Author> authors = Author.getAuthors();
         //对流中的所有元素进行降序排序，并且要求不能有重复的元素,打印出其中年龄最大的两个作家
         authors.stream().distinct()
                 .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                 .limit(2)
                 .forEach(item-> System.out.println(item));

5.6 skip

跳过流中的前n个元素，返回剩下的元素

         List<Author> authors = Author.getAuthors();
         //打印除了年龄最大的作家外的其他作家，要求不能有重复的元素，并且按照年龄降序排序
         authors.stream().distinct()
                 .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                 .skip(1)
                 .forEach(item-> System.out.println(item));

5.7 flatMap

map只能把一个对象转换成另一个对象来作为流中的元素，而flatMap可以把一个对象转换为多个对象作为流中的元素

         List<Author> authors = Author.getAuthors();
        //打印所有的书籍的名字，要求对重复的元素进行去重
        authors.stream()
                .flatMap(author -> author.getBook().stream())
                .distinct()
                .forEach(item-> System.out.println(item));
        //打印所有数据的所有分类，需要对分类进行去重，不能出现这种格式 哲学,爱情
        authors.stream()
                .flatMap(author -> author.getBook().stream())
                .flatMap(book -> Arrays.stream(book.getCategory().split(",").clone()))
                .distinct()
                .forEach(item-> System.out.println(item));

6 终结操作

6.1 forEach

对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体操作

   List<Author> authors = Author.getAuthors();
        //输出所有作家的名字
        authors.stream().forEach(item-> System.out.println(item.getName()));

6.2 count

获取当前流中的元素的个数

  List<Author> authors = Author.getAuthors();
        //打印作家所有书籍的个数，注意删除重复元素
        final long count = authors.stream().flatMap(author -> author.getBook().stream())
                .distinct().count();
        System.out.println(count);

6.3 max&min

计算流中的最值

         List<Author> authors = Author.getAuthors();
        //作家年龄的最大值和最小值
        final Optional<Integer> max = authors.stream()
                .map(author -> author.getAge())
                .min(Comparator.comparingInt(o -> o));
        System.out.println(max.get());

6.4 collect

把当前流转换成一个集合

         List<Author> authors = Author.getAuthors();
        //获取一个存放所有作者名字的list集合
        final List<String> list = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toList());
        System.out.println(list);
        //获取所有作者名字的set
         Set<String> set = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toSet());
        System.out.println(set);
        //获取一个map集合
        final List<Map<String, Object>> collect = authors.stream().map(author -> {
            Map<String, Object> map = new HashMap<>();
            map.put(author.getName(), author.getAge());
            return map;
        }).collect(Collectors.toList());
        System.out.println(collect);

6.5 查找与匹配

• anyMatch: 用来判断流中的元素是否有任意符合匹配条件的元素，结果为boolean类型

 List<Author> authors = Author.getAuthors();
 //判断是否有年龄29以上的作家 anyMatch
 final boolean b = authors.stream().anyMatch(item -> item.getAge() > 10);

• allMatch: 判断流中的元素是否都符合条件，结果为boolean类型，如果都符合结果为true,否则结果为false

//判断是否所有的作家都是成年人 allMatch age>=18
List<Author> authors = Author.getAuthors();
final boolean b = authors.stream().allMatch(item -> item.getAge() >= 18);

• noneMatch:判断流中的元素是否都不符合条件，如果都不符合结果为true,否则结果为false

//判断是否作家都没有超过100岁 noneMatch
List<Author> authors = Author.getAuthors();
final boolean b = authors.stream().allMatch(item -> item.getAge() < 100);

• findAny:获取流中的任意一样个元素，该方法没有办法保证获取的一定是流中的第一个元素

List<Author> authors = Author.getAuthors();
//获取任意一个年龄大于18的作家，如果存在就输出名字 findAny
final Optional<Author> any = authors.stream().filter(item -> item.getAge() > 18).findAny();
//ifPresent 存在就会执行相关消费操作，不存在不会执行任何消费操作
any.ifPresent(item-> System.out.println(item.getName()));

• findFirst:获取流中的第一个元素

 List<Author> authors = Author.getAuthors();
//获取一个年龄最小的作家，并输出它的名字
final Optional<Author> first =authors.stream().sorted(Comparator.comparingInt(Author::getAge)).findFirst();
first.ifPresent(item-> System.out.println(item.getName()));

6.6 reduce 归并

对流中的数据按照你指定的计算方式计算出一个结果（缩减操作），reduce作用是把stream中的元素组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始值进行计算，计算结果在和后面的元素计算
reduce两个参数的重载新式内部的计算逻辑如下

       T result=identity;
       for(T element:this.stream){
           result=accumulator.apply(result,element);
       }
       return result;

其中identity就是我们可以通过方法参数传入的初始值，accumulator的apply具体进行什么计算也是我们方法参数来确定的

• 使用reduce求所有作者年龄的和

List<Author> authors = Author.getAuthors();
        final Integer reduce1 = authors.stream().map(item -> item.getAge())
                .reduce(0, (integer, integer2) -> integer + integer2);

• 使用reduce求所有作者用年龄的最大值

   List<Author> authors = Author.getAuthors();
   //年龄最小值取相反操作
        final Integer reduce1 = authors.stream().map(item -> item.getAge())
                .reduce(Integer.MIN_VALUE, (integer, integer2) -> integer>integer2?integer:integer2);

• reduce 一个参数的重载形式内部的计算

 boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();

• 注意事项

1、惰性求值(如果没有终结操作，中间操作是不会得到执行的)
2、流是一次性的（一旦一个流对象经过一个终结操作后，这个流就不能在被使用）
3、不会影响原数据（我们在流中可以多数据做很多处理，但是正常情况下是不会影响原来集合中的元素的，这也是我们期望的）

五、Optional

5.1 概述

我们在编写代码的时候出现最多的就是空指针异常，所以在很多情况下我们需要做各种非空判断，尤其对象中的属性还是一个对象的情况下，这种判断会更多，而过多的判断会让我们的代码显得臃肿不堪，所以在JDK8中引入Optional,养成使用Optional的习惯后，你可以写出更优雅的代码来避免空指针异常。并且在很多函数式编程相关的API中也都用到啦Optional,如果不会使用Optional也会对函数式编程的学习造成影响

5.2 创建对象

Optional就好像是包装类，可以把我们的具体数据封装Optional对象内部，然后我们去使用Optional中封装好的方法操作封装进去的数据就可以非常优雅的避免空指针异常
我们一般使用Optional的静态方法ofNullable来把数据封装成一个Optional对象，无论传入的参数是否为null都不会出现问题

  List<Author> authors = Author.getAuthors();
  Optional<List<Author>> authors1 = Optional.ofNullable(authors);

你可能会觉得还要加一行代码来封装数据比较麻烦，但是如果改造下getAuthors方法，让其返回值就是封装好的Optional的话，我们在使用时就会方便很多。
而且在实际开发中我们的数据很多是从数据库获取的，Mybatis 3.5版本已经支持Optional啦，我们可以直接把dao方法的返回值类型定义为Optional类型，mybatis会自己把数据封装成Optional对象返回，封装的过程也不需要我们自己操作

如果你确定一个对象不是空的则可以使用Optional的静态方法of把数据封装成Optional对象

Author author=new Author();
Optional<Author> author1 = Optional.of(author);

但一定注意，如果使用of的时候传入的参数必须不为null
如果一个方法的返回值类型是Optional类型，而我们经常判断发现某次计算得到的返回值为null，这个时候就需要把null封装成Optional对象返回，这时则可以使用Optional的静态方法empty来进行封装

Optional.empty()

5.3 安全消费值

我们获取到一个Optional对象后需要对其中的数据进行使用，这时候我们可以使用ifPresent方法来消费其中的值，这个方法会判断其内封装的数据是否为空，不为空才会执行具体的消费代码，这样使用起来就更加安全，
以下写法就优雅的避免了空指针异常

Author author=new Author();
Optional<Author> author1 = Optional.ofNullable(author);
author1.ifPresent(item-> System.out.println(item.getName()));

5.4 获取值

我们想要获取值自己进行处理可以使用get方法进行获取，但是不推荐，因为当Optional内的数据为空时会发生异常

5.5 安全获取值

如果期望完全的获取值不推荐使用get方法，而是使用Optional的以下方法

• orElseGet
  获取数据并设置数据为空时的默认值，如果数据不为空就能获取到该数据，如果为空则根据你传入的参数来创建对象并作为默认值返回

  Optional<Author> optional = Optional.ofNullable(author);
  System.out.println(optional.orElseGet(()->new Author()));

• orElseThrow
  获取数据并设置数据为空时的默认值，如果数据不为空就能获取到该数据，如果为空则根据你传入的参数来创建异常抛出

Optional<Author> optional = Optional.ofNullable(author);
 optional.orElseThrow(() -> new CustomException("dddd"));

5.6 过滤

我们可以使用filter方法对数据进行过滤，如果原本是有数据的，但是不符合判断，也会变成一个无数据的Optional对象

Optional<Author> optional = Optional.of(author);
optional.filter(item->item.getAge()>18).ifPresent(item-> System.out.println(item.getAge()));

5.7 判断

我们可以使用isPresent方法进行是否存在数据的判断，如果为空返回值为false,如果不为空，返回值为true,但这种方式并不能提醒Optional的好处，更推荐使用ifPresent方法

        Optional<Author> optional = Optional.of(author);
        if(optional.isPresent()){
            System.out.println(optional.get().getAge());
        }

5.8 数据转换

Optional还提供map方法让我们对数据进行转换，并且转换得到的数据也是被Optional包装好的，保证了我们的使用安全

Optional<Author> optional = Optional.of(author);
optional.map(item->item.getAge()).ifPresent(age-> System.out.println(age));

六、函数式接口

6.1 概述

只有一个抽象方法的接口我们称为函数接口
JDK的函数式接口都加上啦@FunctionalInterface注解进行标识。但是无论是否加上该注解只要接口中只有一个抽象方法，都是函数式接口

6.2 常见函数式接口

• Consumer 消费接口
  根据其中抽象方法的参数列表和返回值类型知道，我们可以对方法中传入的参数进行消费

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

• Function 计算转换接口
  根据其中抽象方法的参数列表和返回值类型知道，我们可以对方法中传入的参数计算或转换，然后把结果返回

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

• Predicate 判断接口
  根据其中抽象方法的参数列表和返回值类型知道，我们可以对方法中传入的参数条件判断，返回判断结果

@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);
}

• Supplier 生产型接口
  根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中创建对象，把创建好的对象返回

@FunctionalInterface
public interface Supplier<T>  {
   T get();
}

6.3 常用的默认方法

• and
  我们在使用Predicate接口时可以需要进行判断条件的拼接，而and方法相当于是使用&& 来拼接两个判断条件

final List<Author> authors = Author.getAuthors();
        //打印年龄大于18并且姓名长度为1的作家
        authors.stream().filter(((Predicate<Author>) author -> author.getAge() > 18)
                .and(author -> author.getName().length()==1))
                .forEach(item-> System.out.println(item));

• or

我们在使用Predicate接口时可以需要进行判断条件的拼接，而or 方法相当于是使用|| 来拼接两个判断条件

        final List<Author> authors = Author.getAuthors();
        //打印年龄大于18或者姓名长度为1的作家
        authors.stream().filter(((Predicate<Author>) author -> author.getAge() > 18)
                .or(author -> author.getName().length()==1))
                .forEach(item-> System.out.println(item));

• negate
  Predicate 接口中的方法，negate 相当于是在判断添加前面加了！表示取反

  final List<Author> authors = Author.getAuthors();
        //打印年龄不大于18的作家
        authors.stream().filter(((Predicate<Author>) author -> author.getAge()>18).negate())
                .forEach(item-> System.out.println(item.getAge()));

  public static void main(String[] args) {
        printNum(value -> value>2, value -> value%2==0);
    }

    public static void printNum(IntPredicate predicate1,IntPredicate predicate2){
       int[] array={1,2,3,4,5,6};
       for(int i:array){
           final boolean test = predicate1.and(predicate2).test(i);
           System.out.println(test);
       }
    }

七、方法引用

在使用lambda时，如果方法体中只有一个方法的调用的话（包括构造方法）,我们可以用方法引用来进一步简化代码

7.1 推荐用法

在使用lambda时不需要考虑什么时候用方法引用，用哪种方法引用，方法引用的格式是什么，我们只需要写完lambda方法发现方法体只有一行代码，并且是方法的调用时使用快捷键尝试是否能够转换成方法引用即可。当我们方法引用使用的多了慢慢也可以直接写出方法引用

7.2 基本格式

类名或者对象名::方法名

7.3语法详解（了解）

7.3.1 引用静态方法

其实就是引用类的静态方法 ；格式 ： 类名::方法名
使用前提
我们在重写方法的时候，方法体中只有一行代码，并且这行代码时调用了某个类的静态方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们可以引用类的静态方法
以下代码可以使用方法引用来优化

 final List<Author> authors = Author.getAuthors();
        authors.stream().map(item->item.getAge())
                .map(age->String.valueOf(age));

注意：我们所重写的方法是没有参数的，调用的方法也是没有参数的，也相当于服务以上规则，优化后如下

final List<Author> authors = Author.getAuthors();
        authors.stream().map(item->item.getAge())
                .map(String::valueOf);

7.3.2 引用对象的实例方法

格式 ： 对象名::方法名
使用前提
我们在重写方法的时候，方法体中只有一行代码，并且这行代码时调用了某个对象的成员方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们可以对象的实例方法

 final List<Author> authors = Author.getAuthors();
        StringBuilder sb=new StringBuilder();
        authors.stream().map(item->item.getName())
                .map(name->sb.append(name));

优化后

 final List<Author> authors = Author.getAuthors();
        StringBuilder sb=new StringBuilder();
        authors.stream().map(item->item.getName())
                .map(sb::append);

7.3.3 引用类的实例方法

格式 ： 类名::方法名

使用前提
我们在重写方法的时候，方法体中只有一行代码，并且这行代码时调用了第一个参数的成员方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们可以对象的实例方法

    public static void main(String[] args) {
        final String res = subAuthorName("琵琶行", (str, start, length) -> str.substring(start,length));
        //对象的实例方法使用
        subAuthorName("琵琶行", String::substring);
        System.out.println(res);
    }

    public static String subAuthorName(String str,UseString useString){
        int start=0;
        int length=1;
        return useString.use(str,start,length);
    }

    interface UseString {
        String use(String str,int start,int length);
    }

7.3.4 构造器的引用

如果方法体中的一行代码时构造器的话就可以使用构造器的引用
格式 ： 类名::new

使用前提
我们在重写方法的时候，方法体中只有一行代码，并且这行代码时调用了某个类的构造方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个构造方法中，这个时候我们可以引用构造器

final List<Author> authors = Author.getAuthors();
        authors.stream().map(author->author.getName())
                 .map(name->new StringBuilder(name))
                .map(sb->sb.append("琵琶行"))
                .forEach(res-> System.out.println(res));

优化后

final List<Author> authors = Author.getAuthors();
        authors.stream().map(Author::getName)
                 .map(StringBuilder::new)
                .map(sb->sb.append("琵琶行"))
                .forEach(System.out::println);

八、高级用法

8.1 基本数据类型优化

我们之前用到的很多Stream的方法由于都使用了泛型，所以涉及到参数和返回值都是引用数据类型。
即使我们操作的是整数小数，但是实际用的都是他们的包装类。JDK5中引入的自动装箱和自动拆箱让我们在使用对应的包装类时就好像使用基本数据类型一样方便。但是你一定要知道装箱和拆箱肯定是要消耗时间的。虽然这个时间消耗很短，但是在大量的数据不断的重复装箱和拆箱的时候，你就不能无视这个时间损耗啦。
所以为了让我们能够对这部分的时间消耗进行优化。Stream还提供了很多专门针对基本数据类型的优化。
eg:mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToLong,flatMapToDouble

       final List<Author> authors = Author.getAuthors();
        authors.stream().mapToInt(Author::getAge)
                 .filter(age->age>18)
                .forEach(System.out::println);

8.2 并行流

当流中有大量元素时，我们可以使用并行流去提高操作的效率。其实并行流就是把任务分配多个线程去完成。如果我们自己去用代码实现的话会非常复杂，并且要求你对并发编程有足够的理解和认识。而如果我们使用stream流的话，我们只需要修改一个方法的调用就可以用并行流来帮我们实现，从而提高效率

• parallel方法可以把串行流转换为并行流

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
         Integer sum = integerStream.parallel().peek(num -> {
            System.out.println(num + Thread.currentThread().getName());
        }).filter(num -> num > 5).reduce(((result, ele) -> result + ele)).get();

• 也可以通过parallelStream直接获取并行流对象

        List<Author> authors = Author.getAuthors();
        authors.parallelStream()
                .map(item -> item.getAge())
                .map(age -> age + 10)
                .filter(age -> age > 28).forEach(System.out::println);