函数式编程-Stream流

1.示例

//查询未成年作家的评分在70以上的书籍 由于洋流影响所以作家和书籍可能出现重复，需要进行去重
List<Book> bookList = new ArrayList<>();
Set<Book> uniqueBookValues = new HashSet<>();
Set<Author> uniqueAuthorValues = new HashSet<>();
for (Author author : authors) {
   
    if (uniqueAuthorValues.add(author)) {
   
        if (author.getAge() < 18) {
   
            List<Book> books = author.getBooks();
            for (Book book : books) {
   
                if (book.getScore() > 70) {
   
                    if (uniqueBookValues.add(book)) {
   
                        bookList.add(book);
                    }
                }
            }
        }
    }
}
System.out.println(bookList);

List<Book> collect = authors.stream()
    .distinct()
    .filter(author -> author.getAge() < 18)
    .map(author -> author.getBooks())
    .flatMap(Collection::stream)
    .filter(book -> book.getScore() > 70)
    .distinct()
    .collect(Collectors.toList());
System.out.println(collect);

2. Lambda表达式

2.1 概述

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

注意：以下示例传的都是函数式接口，只有一个抽象方法的接口就是函数式接口。

2. 3 基本格式

(参数列表)->{
   代码}

例一：

我们在创建线程并启动时可以使用匿名内部类的写法：

new Thread(new Runnable() {
   
    @Override
    public void run() {
   
        System.out.println("你知道吗 我比你想象的 更想在你身边");
    }
}).start();

可以使用Lambda的格式对其进行修改。修改后如下：

new Thread(()->{
   
    System.out.println("你知道吗 我比你想象的 更想在你身边");
}).start();

最终省略后：

new Thread(()-> System.out.println("你知道吗 我比你想象的 更想在你身边")
).start();

例二：

现有方法定义如下，其中IntBinaryOperator是一个接口。先使用匿名内部类的写法调用该方法。

 public static int calculateNum(IntBinaryOperator operator){
   
      int a = 10;
      int b = 20;
      return operator.applyAsInt(a, b);
  }
public static void main(String[] args) {
   
    int i = calculateNum(new IntBinaryOperator() {
   
        @Override
        public int applyAsInt(int left, int right) {
   
            return left + right;
        }
    });
    System.out.println(i);
}

Lambda写法：

public static void main(String[] args) {
   
    int i = calculateNum((int left, int right)->{
   
        return left + right;
    });
    System.out.println(i);
}

最终省略后：

public static void main(String[] args) {
   
    int i = calculateNum((left, right)-> left + right);
    System.out.println(i);
}

例三：

现有方法定义如下，其中IntPredicate是一个接口。先使用匿名内部类的写法调用该方法。

public static void printNum(IntPredicate predicate){
   
    int[] arr = {
   1,2,3,4,5,6,7,8,9,10};
    for (int i : arr) {
   
        if(predicate.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写法：

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

最终省略后：

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

例四：

现有方法定义如下，其中Function是一个接口。先使用匿名内部类的写法调用该方法。

public static <R> R typeConver(Function<String,R> function){
   
    String str = "1235";
    R result = function.apply(str);
    return result;
}
public static void main(String[] args) {
   
    Integer result = typeConver(new Function<String, Integer>() {
   
        @Override
        public Integer apply(String s) {
   
            return Integer.valueOf(s);
        }
    });
    System.out.println(result);
}

Lambda写法：

Integer result = typeConver((String s)->{
   
    return Integer.valueOf(s);
});
System.out.println(result);

最终省略后：

public static void main(String[] args) {
   
    Integer result = typeConver(s-> Integer.valueOf(s));
    System.out.println(result);
}

2.4 省略规则

• 参数类型可以省略，如果一个参数的类型可以被推导出来，则可以省略参数类型（注：参数类型可以不同）
• 方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
• 方法只有一个参数时小括号可以省略

3. Stream流

3.1 概述

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

3.2 案例数据准备

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.16</version>
    </dependency>
</dependencies>

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
public class Author {
   
    //id
    private Long id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //简介
    private String intro;
    //作品
    private List<Book> books;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
public class Book {
   
    //id
    private Long id;
    //书名
    private String name;

    //分类
    private String category;

    //评分
    private Integer score;

    //简介
    private String intro;

}

private static List<Author> getAuthors() {
   
    //数据初始化
    Author author = new Author(1L,"蒙多",33,"一个从菜刀中明悟哲理的祖安人",null);
    Author author2 = new Author(2L,"亚拉索",15,"狂风也追逐不上他的思考速度",null);
    Author author3 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);
    Author author4 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);

    //书籍列表
    List<Book> books1 = new ArrayList<>();
    List<Book> books2 = new ArrayList<>();
    List<Book> books3 = new ArrayList<>();

    books1.add(new Book(1L,"刀的两侧是光明与黑暗","哲学,爱情",88,"用一把刀划分了爱恨"));
    books1.add(new Book(2L,"一个人不能死在同一把刀下","个人成长,爱情",99,"讲述如何从失败中明悟真理"));

    books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
    books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
    books2.add(new Book(4L<