函数式编程[Lambda 表达式,Optional,Stream流]从入门到精通(一)

兔老大-RabbitBoss

已于 2022-10-24 23:19:22 修改

阅读量330

点赞数

分类专栏： Java Java基础文章标签： 1024程序员节

于 2022-10-24 23:18:05 首次发布

本文链接：https://blog.csdn.net/darling_qi/article/details/127504312

版权

Java基础同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

Java

2 篇文章 0 订阅

订阅专栏

文章目录

- 函数式编程、stream流

函数式编程、stream流

1.概述

1.1 学习目的

代码可读性
避免过分嵌套
看懂别人写的代码
大数据量下集合处理效率
底层使用多线程处理并线程安全可以保障？

1.2 函数式编程思想

面向对象思想主要是关注对象能完成什么事情，函数式编程思想就像函数式，主要是针对数据操作；
代码简洁容易理解，方便于并发编程，不需要过分关注线程安全问题

2.lambda表达式

2.1 概述

lambda是JDK8中的一个语法糖，可以对某些匿名内部类的写法进行优化，让函数式编程只关注数据而不是对象。
基本格式：(参数列表)->{方法体}

2.2 省略规则

参数类型可以省略
方法体只有一句代码时,大括号和 return 以及唯一代码的分号可以省略
方法只有一个参数时[即,参数列表只有一个参数时] 小括号可以省略
如果上面这些记不住,可以不省略也行

3. stream流

3.1 概述

stream使用的是函数式编程模式，可以被用来对集合或数组进行链状流式的操作
有别于其他输入输出流，这里是针对集合操作数据的流哦

创建流实战：com.jonny.stream.StreamDemo

练习一:

打印年龄小于18岁的作者名字,并去重

  /*
   *  练习一: 打印年龄小于18的作者姓名,并且去重
   */
  getAuthors().stream().distinct().filter(new Predicate<Author>() {
      @Override
      public boolean test(Author author) {
          return author.getAge() < 18;
      }
  }).forEach(new Consumer<Author>() {
      @Override
      public void accept(Author author) {
          System.out.println(author.getName());
      }
  });

3.2 功能

流不存储元素。它只是通过计算操作的流水线从数据结构, 数组或I/O通道等源中传递元素。
流本质上是功能性的。对流执行的操作不会修改其源。例如, 对从集合中获取的流进行过滤会产生一个新的不带过滤元素的流, 而不是从源集合中删除元素。
Stream是惰性的, 仅在需要时才评估代码。
在流的生存期内, 流的元素只能访问一次。像Iterator一样, 必须生成新的流以重新访问源中的相同元素。

3.3 常用方法说明 com/jonny/stream/StreamDemo.java

抽取方法快捷键: Mac:[⌘ + ⌥ + M] Win: ctrl + alt + M

显示方法参数提示快捷键 : ⌘ + P

map:相当于对数据进行一个操作，可以自定义返回值等
distinct:可以去除流中的相同元素，注意（该方法依赖的Object的equals方法来判断是否是相同对象，所以要重写equals方法，否则只有对象地址一样时才会被认为是重复）
sorted:可以对流中的元素进行排序，传入空参时使用的是实体类的比较方法
limit:设置流的最大长度，超出部分将被抛弃
skip:跳过流中的前n个元素，返回剩下的元素
flatMap:map能把一个对象转换成另外一个对象来作为流中的元素，而flatMap可以把一个对象转换成多个对象作为流中的元素
中间操作（filter,map,distinct,sorted,limit,skip,flatMap）
终结操作（forEach,collect,count,max,min,reduce归并,查找与匹配）
forEach:遍历所有元素
count:计算元素数量
min&max:返回的是option对象，这里和sorted一样，得指定比较规则
collect:把当前流转换成一个集合（list, set, map）
- Collectors.toList()
- Collectors.toSet()
- Collectors.toMap(key, value)
anyMatch:可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型
allMatch:可以用来判断是否都匹配条件，结果也是boolean类型，都符合则为true
noneMatch:是否都不符合，都不符合则为true
findAny:获取流中的任意一个元素，该方法无法保证获取的是流中的第一个元素，只是匹配到
findFirst:获取流中的第一个元素

reduce:对流中的数据按照你制定的计算方式计算出一个结果，并返回一个Optional描述归约值（如果有）

T result = identity;
for(T element : this stream) {
    result = accumulator.apply(result, element); // 执行具体数据操作
}
return result;
// 还有一种三个方法的重载方法，后面还需要补充

3.4 常用操作

3.4.1 创建流

单列集合:集合对象.stream()

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

数组: Arrays.stream(数组)或者Stream.of(数组)

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

双列集合:转换成单列集合再创建

    Map<String, Integer> map = new HashMap<>();
    map.put("蜡笔小新",19);
    map.put("黑子",17);
    map.put("日向翔阳",16);
    Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

3.4.2 中间操作

filter

对流中元素进行过滤,符合条件的元素才可以留在流中

// 例如打印作家姓名长度小于 3 的作家名
authors
        .stream()
        .filter(author -> author.getName().length() < 3)
        .forEach(author -> System.out.println("作家名: " + author.getName()));

map

可以对流中的元素进行计算或者转换

// 例如:打印所有作家的姓名
    List<Author> authors = getAuthors();
    authors.stream()
      .map(author -> author.getName())
      .forEach(name -> System.out.println(name));
 // 将所有的作家年龄➕10并输出
    authors.stream()
            .map(author -> author.getAge())
            .map(age -> age+10 )
            .forEach(age -> System.out.println(age));

distinct
- 可以去除流中的重复元素
  - 注意:
    - distinct方法是依赖于Object 方法的equals 方法来判断是否相同对象的
    - 而 Object 的equals 方法是 == 判断的是两个对象的地址是否相同
    - 所以要看传入类型是否有重写 equals 方法,
    - 没有重写则是继承 Object 的 equals 方法,需要手动重写
- ```
   // 打印所有作家的姓名,并且不能有重复元素
   List<Author> authors = getAuthors();
    authors.stream()
            .distinct()
            .forEach(author -> System.out.println(author.getName()));
```

sorted

可以对流中的元素进行排序

  // 对流中的元素按年龄进行排序,并且去除重复项
List<Author> authors = getAuthors();
    authors.stream()
            .distinct()
            .sorted((o1, o2) -> {
  //  return o1.getAge() - o2.getAge(); // 升序
    return o2.getAge() - o1.getAge(); // 降序
    })
    .forEach(author -> System.out.println(author.getAge()));

注意
- 如果调用空参的 sorted 的方法,需要流中的元素实现 Comparable接口

limit

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

例如：
对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素，然后打印其中年龄最大的两个作家的姓名。

  List<Author> authors = getAuthors();
  authors.stream()
          .distinct()
          .sorted((o1, o2) -> o2.getAge() - o1.getAge())
          .limit(2)
          .forEach(author -> System.out.println(author.getName()));
  }

skip

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

例如：
打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。

  List<Author> authors = getAuthors();
  authors.stream()
          .distinct()
          .sorted((o1, o2) -> o2.getAge() - o1.getAge())
          .skip(1)
          .forEach(author -> System.out.println(author.getName()));

flatMap

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

例一：
打印所有书籍的名字。要求对重复的元素进行去重。

  List<Author> authors = getAuthors();
  authors.stream()
          .flatMap(author -> author.getBookList().stream()) // 将Author流转换成Book流
          .distinct() // 去重
          .forEach(book -> System.out.println(book.getName()));

例二：
打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学，爱情

   List<Author> authors = getAuthors();
   authors.stream()
          .flatMap(author -> author.getBookList().stream())
          .distinct()
          .flatMap(book -> Arrays.stream(book.getCategory().split(",")))
          .distinct()
          .filter(category -> "哲学".equals(category) || "爱情".equals(category) ? false : true)
          .forEach(category -> System.out.println(category));

3.4.3 终结操作

forEach

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

例子:输出所有作家的名字

    List<Author> authors = getAuthors();
    authors.stream()
            .map(author -> author.getName())
            .distinct()
            .forEach(name -> System.out.println(name));

count

可以用来获取当前流中元素的个数。

例子：
打印这些作家的所出书籍的数目，注意删除重复元素。

   List<Author> authors = getAuthors();
   long count = authors.stream()
          .flatMap(author -> author.getBookList().stream())
          .distinct()
          .count();
   System.out.println(count);

max & min

可以用来或者流中的最值。

例子：
分别获取这些作家的所出书籍的最高分和最低分并打印。

 // 分别获取这些作家的所出书籍的最高分和最低分并打印。
  List<Author> authors = getAuthors();
  Optional<Integer> max = authors.stream()
          .flatMap(author -> author.getBookList().stream())
          .map(book -> book.getScore())
          .max((score1, score2) -> { return score1 - score2; });

  Optional<Integer> min = authors.stream()
          .flatMap(author -> author.getBookList().stream())
          .map(book -> book.getScore())
          .min((score1, score2) -> { return score1 - score2; });

  System.out.println(max.get());
  System.out.println(min.get());

collectr

把当前流转换成一个集合。

例子:

获取一个存放所有作者名字的List集合。

  // 获取一个存放所有作者名字的List集合。
  List<Author> authors = getAuthors();
  List<String> list = authors.stream()
          .distinct() // 去重
          .map(author -> author.getName())    // 获得所有作家的名字
          .collect(Collectors.toList());  // 转换成List
  System.out.println(list);

获取一个所有书名的Set集合。

   // 获取一个所有书名的Set集合。
  List<Author> authors = getAuthors();
  Set<Book> set = authors.stream()
          .flatMap(author -> author.getBookList().stream())
          .collect(Collectors.toSet());// 转换成Set 集合
  System.out.println(set);

获取一个map集合，map的key为作者名，value为List

  // 获取一个map集合，map的key为作者名，value为List<Book>
  List<Author> authors = getAuthors();
  Map<String, List<Book>> collect = authors.stream()
          .distinct() // 去重
          .collect(Collectors.toMap(author -> author.getName(), author -> author.getBookList())); // 转换成Map 集合
  System.out.println(collect);

查找与匹配

anyMatch

可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型。
例子：
判断是否有年龄在17以上的作家

  List<Author> authors = getAuthors();
  boolean match = authors.stream()
          .anyMatch(author -> author.getAge() > 17);
  System.out.println(match);

allMatch

可以用来判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。
例子：
判断是否所有的作家都是成年人

  List<Author> authors = getAuthors();
  boolean match = authors.stream()
          .allMatch(author -> author.getAge() >= 18);
  System.out.println(match);

noneMatch

可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false
例子：
判断作家是否都没有超过100岁的。

  List<Author> authors = getAuthors();
  boolean match = authors.stream()
          .noneMatch(author -> author.getAge() > 100);
  System.out.println(match);

findAny

获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。
例子：
获取任意一个年龄大于18的作家，如果存在就输出他的名字

  List<Author> authors = getAuthors();
  Optional<Author> optionalAuthor = authors.stream()
          .filter(author -> author.getAge() > 18)
          .findAny();
  optionalAuthor.ifPresent(author -> System.out.println(author.getName()));

findFirst

获取流中的第一个元素。
例子：
获取一个年龄最小的作家,并且输出他的名字

  List<Author> authors = getAuthors();
  Optional<Author> optionalAuthor = authors.stream()
          .sorted((o1, o2) -> o1.getAge() - o2.getAge())
          .findFirst();
  optionalAuthor.ifPresent(author -> System.out.println(author.getName()));

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 = getAuthors();
Integer sum = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(0, (result, element) -> result + element);
System.out.println(sum);

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

List<Author> authors = getAuthors();
Integer max = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(Integer.MIN_VALUE, (result, element) -> result < element ? element : result);
System.out.println(max);

使用reduce求所有作者中年龄的最小值

List<Author> authors = getAuthors();
Integer min = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(Integer.MAX_VALUE, (result, element) -> result < element ? result : element);
System.out.println(min);

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

如果用 reduce 一个参数重载形式,求所有作家年龄的最小值和最大值代码如下

List<Author> authors = getAuthors();
// 使用reduce求所有作者中年龄的最小值
Optional<Integer> minOptional = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce((result, element) -> result < element ? result : element);
minOptional.ifPresent(age -> System.out.println(age));
// 使用reduce求所有作者中年龄的最大值
Optional<Integer> maxOptional = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce((result, element) -> result > element ? result : element);
maxOptional.ifPresent(age -> System.out.println(age));

3.5 注意事项

惰性求值(如果没有终结操作没有中间操作是不会得到执行的)
流是一次性的(一旦一个流对象经过终结操作之后,这个流对象就不能再被使用)
- 如果再次被使用回报以下异常
- Exception in thread "main〞 java. 1ang. IllegalStateException: stream has already been operated upon or closed

不会影响元数据(我们在流中可以多数据做很多处理。但是正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的)

示例代码验证

正常情况下,不会影响原来元素如下:

  List<Author> authors = getAuthors();
  // 正常情况下,不会影响原来元素如下:
  authors.stream()
          .map(author -> author.getAge())
          .map(age -> age += 10)
          .forEach(age -> System.out.println(age));
  authors.forEach(author -> System.out.println(author.getAge()));

非正常情况下会影响原来的元素如下:

  List<Author> authors = getAuthors();
  // 非正常情况下会影响原来的元素如下:
  authors.stream()
          .map(author -> {
              author.setAge(author.getAge() + 10);
              return author;
          }).forEach(author -> System.out.println(author.getAge()));
  authors.forEach(author -> System.out.println(author.getAge()));

只要不主动修改元素的堆栈地址,就不会改变原数据

兔老大-RabbitBoss

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
函数式编程[Lambda 表达式,Optional,Stream流]从入门到精通(一)

不会Lambda表达式、函数式编程？你确定能看懂公司代码？-java8函数式编程(Lambda表达式，Optional，Stream流)从入门到精通-最通俗易
复制链接

扫一扫