关于java:java8函数式编程之Stream流处理的方法和案例讲解

6次阅读

共计 8671 个字符，预计需要花费 22 分钟才能阅读完成。

函数式编程最早是数学家阿隆佐·邱奇钻研的一套函数变换逻辑，又称 Lambda Calculus（λ-Calculus），所以也常常把函数式编程称为 Lambda 计算。

为什么 Java 须要 Lambda 表达式进行函数式编程呢？在我看来，有以下益处：

1、面向对象编程是对数据进行形象，而函数式编程是对行为进行形象；
2、减少 Lambda 表达式，让代码在多核服务器上更高效运行；
3、始终以来，Java 始终被诟病的中央，就是代码写得比拟啰嗦，简略的 CURD 都要写好几行代码，Java8 推出函数式编程后，啰嗦且简短的代码失去极大改观，用 Java 也能写出简洁柔美的代码。

不多啰嗦，上面开始函数式编程之 Stream 流解决的办法和案例解说。

Streams API 已在 Java 8 中引入，并且曾经是 Java 语言标准的一部分多年了。尽管如此，平时的工作中，还是有很多我的项目还停留在 java1.7 中的应用中，而且 java8 的很多新个性都是革命性的，尤其是 stream 流解决。因而，这篇文章里，将介绍 Streams 的基本概念，并通过一些示例对其进行解释。

本文参考自官网 Java 文档 java-stream 流解决。与汇合相比，Streams 的一些特色（取自官网文档）如下：

流不存储数据。相同，它们是数据的起源。
流实质上是功能性的，这可能就是为什么流对大多数人来说很难了解的起因。它们产生一个后果，例如，像一个总和或一个新的流。
流的许多操作都是惰性求值的（laziness-seeking）。操作能够是两头操作，也能够是终止操作。咱们将在下一节中介绍这两者。惰性求值是指该操作只是对 stream 的一个形容，并不会马上执行。这类惰性的操作在 stream 中被称为两头操作（intermediate operations）。例如，查找流中元素的第一个匹配项。不用查看流的所有元素。找到第一个匹配项后，能够完结搜寻。
可能是有限的。只有流生成数据，流就不会完结。
流的元素只能拜访一次，和迭代器 Iterator 类似，当须要反复拜访某个元素时，须要从新生成一个新的 stream。

在接下来的局部中，咱们将介绍如何创立 Streams，介绍一些两头操作，最初咱们将介绍一些终止操作。这些源代码能够在结尾的 github 源码里提供，不须要本人复制粘贴。

有几种办法能够创立流。它们能够从汇合，数组，文件等创立。在本节中，咱们将创立一些测试，向您展现如何以不同的形式创立流。咱们将创立并应用终止操作，以便将生产到 . 咱们不对执行任何其余操作，咱们将它留给其余局部。最初，咱们断言是否与咱们冀望的雷同。测试位于单元测试中。

应用 java.util.Collection.stream() 办法

private static final List<String> stringsList = Arrays.asList("a", "b", "c");

@Test
public void createStreamsFromCollection() {List<String> streamedStrings = stringsList.stream().collect(Collectors.toList());
    assertLinesMatch(stringsList, streamedStrings);
}

应用 java.util.Arrays.stream(T[]array)办法

@Test
public void createStreamsFromArrays() {List<String> streamedStrings = Arrays.stream(new String[]{"a", "b", "c"}).collect(Collectors.toList());
    assertLinesMatch(stringsList, streamedStrings);
}

应用 Stream 的静态方法：of()、iterate()、generate()

@Test
public void createStreamsFromStreamOf() {List<String> streamedStrings = Stream.of("a", "b", "c").collect(Collectors.toList());
    assertLinesMatch(stringsList, streamedStrings);
}

应用将 int 值作为参数来创立。

@Test
public void createStreamsFromIntStream() {int[] streamedInts = IntStream.of(1, 2, 3).toArray();
    assertArrayEquals(new int[]{1, 2, 3}, streamedInts);
}

从文件中读取进行创立。

    @Test
    public void createStreamsFromFile() {
        try {List<String> expectedLines = Arrays.asList("file1", "file2", "file3","file4");
            BufferedReader reader = new BufferedReader(new FileReader(new File(System.getProperty("user.dir")+"/src/main/resources/file.txt")));
            List<String> streamedLines = reader.lines().collect(Collectors.toList());
            assertLinesMatch(expectedLines, streamedLines);
        } catch (FileNotFoundException e) {e.printStackTrace();
        }
    }

两头操作（intermediate operations）指的是将一个 stream 转换为另一个 stream 的操作，譬如 filter 和 map 操作。这些操作返回新的，但不返回最终后果。两头操作能够分为无状态操作（不保留无关先前解决的元素的信息）和有状态操作（可能须要在生成两头后果之前解决所有元素）。

能够在 Streams API 中找到可调用的操作的残缺列表。

public class Shoe {
    private int id;
    private String brand;
    private String size;
    private String color;

    public Shoe(int id, String brand, String size, String color) {
        this.id = id;
        this.brand = brand;
        this.size = size;
        this.color = color;
    }

    ...

}

在单元测试中，咱们定义了四个对象，咱们将在下一个示例中应用：shoe

    private static final Shoe volkswagenGolf = new Shoe(0, "Volkswagen", "L", "blue");
    private static final Shoe skodaOctavia = new Shoe(1, "Skoda", "XL", "green");
    private static final Shoe renaultKadjar = new Shoe(2, "Renault", "XXL", "red");
    private static final Shoe volkswagenTiguan = new Shoe(3, "Volkswagen", "M", "red");

3.1.1 filter 操作

该操作容许咱们基于给定的. 在示例中，咱们首先创立 4 双鞋子中的一双，而后创立一双仅蕴含 Volkswagen 鞋子的新鞋子。

@Test
public void filterStream() {List<Shoe> expectedShoes = Arrays.asList(volkswagenGolf, volkswagenTiguan);
    List<Shoe> filteredShoes = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                   .filter(shoe -> shoe.getBrand().equals("Volkswagen"))
                                   .collect(Collectors.toList());
    assertIterableEquals(expectedShoes, filteredShoes);
}

3.1.2 map 操作

在后面的所有示例中，源中的类型和后果始终雷同。通常，您心愿对每个元素利用一个函数。例如，如果咱们心愿后果仅蕴含品牌而不是对象，咱们能够应用该操作并将该办法利用于每个元素，从而产生仅具备品牌名称的新元素。

@Test
public void mapStream() {List<String> expectedBrands = Arrays.asList("Volkswagen", "Skoda", "Renault", "Volkswagen");
    List<String> brands = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                .map(Shoe::getBrand)
                                .collect(Collectors.toList());
    assertIterableEquals(expectedBrands, brands);
}

3.1.3 组合过滤和映射操作 (filter+map)

当然，将操作组合并将它们链接在管道中是齐全无效的。在下一个示例中，咱们进行筛选以检索 Volkswagen 鞋子，而后应用该操作仅检索色彩。这样，咱们最终会失去一个蕴含 Volkswagen 鞋子色彩的列表。

@Test
public void filterMapStream() {List<String> expectedColors = Arrays.asList("blue", "red");
    List<String> volkswagenColors = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                          .filter(shoe -> shoe.getBrand().equals("Volkswagen"))
                                          .map(Shoe::getColor)
                                          .collect(Collectors.toList());
    assertIterableEquals(expectedColors, volkswagenColors);
}

3.2.1 distinct 操作

不同操作将返回仅蕴含基于元素的办法实现的不同元素的。在下一个示例中，咱们首先检索一个品牌，而后对其执行操作。这就产生了咱们应用的三个不同品牌的列表。

@Test
public void distinctStream() {List<String> expectedBrands = Arrays.asList("Volkswagen", "Skoda", "Renault");
    List<String> brands = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                .map(Shoe::getBrand)
                                .distinct()
                                .collect(Collectors.toList());
    assertIterableEquals(expectedBrands, brands);
}

3.2.2 sorted 操作

该操作将依据其天然程序对元素进行排序。也能够应用 a 作为参数，以便进行更自定义的排序。下一个示例将从中检索品牌并按字母程序对其进行排序。

@Test
public void sortedStream() {List<String> expectedSortedBrands = Arrays.asList("Renault", "Skoda", "Volkswagen", "Volkswagen");
    List<String> brands = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                .map(Shoe::getBrand)
                                .sorted()
                                .collect(Collectors.toList());
    assertIterableEquals(expectedSortedBrands, brands);
}

咱们将探讨的最初一个两头操作是操作。这是一个非凡的，次要用于调试目标。将在应用元素时对其执行操作。让咱们以组合的过滤器和地图为例，并向其增加一些操作，以便打印正在应用的元素。

@Test
public void peekStream() {List<String> expectedColors = Arrays.asList("blue", "red");
    List<String> volkswagenColors = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                          .filter(shoe -> shoe.getBrand().equals("Volkswagen"))
                                          .peek(e -> System.out.println("Filtered value:" + e))
                                          .map(Shoe::getColor)
                                          .peek(e -> System.out.println("Mapped value:" + e))
                                          .collect(Collectors.toList());
    assertIterableEquals(expectedColors, volkswagenColors);
}

此测试的输入为：

Filtered value: Shoe{id=0, brand='Volkswagen', type='Golf', color='blue'}

Mapped value: blue

Filtered value: Shoe{id=3, brand='Volkswagen', type='Tiguan', color='red'}

Mapped value: red

终止操作（terminal operations）则指的是那些会产生一个新值或副作用（side-effect）的操作，例如 count 和 forEach 操作。

咱们曾经在后面的所有示例中应用了终止操作。咱们总是在操作中应用参数。不过还有更多选项能够应用。咱们将在下一个示例中介绍一些内容。残缺的列表能够在 JavaDoc 中找到。

办法 collect 里应用，咱们能够应用办法 Collectors.joining 进行分隔符分隔。

@Test
public void collectJoinStream() {
    String expectedBrands = "Volkswagen;Skoda;Renault;Volkswagen";
    String joinedBrands = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                .map(Shoe::getBrand)
                                .collect(Collectors.joining(";"));
    assertEquals(expectedBrands, joinedBrands);
}

Collectors.summingInt应用，咱们能够计算元素的属性之和。在咱们的示例中，咱们只计算鞋子 id 的总和。

@Test
public void collectSummingIntStream() {int sumIds = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                       .collect(Collectors.summingInt(Shoe::getId));
   assertEquals(6, sumIds);
}

Collectors.groupingBy应用，咱们能够将元素分组到 . 在咱们的示例中，咱们依据品牌对元素进行分组。

@Test
public void collectGroupingByStream() {Map<String, List<Shoe>> expectedShoes = new HashMap<>();
    expectedShoes.put("Skoda", Arrays.asList(skodaOctavia));
    expectedShoes.put("Renault", Arrays.asList(renaultKadjar));
    expectedShoes.put("Volkswagen", Arrays.asList(volkswagenGolf, volkswagenTiguan));
 
    Map<String, List<Shoe>> groupedShoes = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                                               .collect(Collectors.groupingBy(Shoe::getBrand));
    assertTrue(expectedShoes.equals(groupedShoes));
}

reduce，该操作对的元素执行减量。它应用恒等式（即起始值）和执行归约的累积函数。在咱们的示例中，咱们对元素的 id 执行求和，就像咱们应用该操作时所做的那样。

@Test
public void reduceStream() {int sumIds = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                       .map(Shoe::getId)
                       .reduce(0, Integer::sum);
    assertEquals(6, sumIds);
}

该操作对每个元素执行一个函数。它与两头操作十分类似。

@Test
public void forEachStream() {Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
          .forEach(System.out::println);
}

该测试的后果如下：

Shoe{id=0, brand='Volkswagen', type='Golf', color='blue'}

Shoe{id=1, brand='Skoda', type='Octavia', color='green'}

Shoe{id=2, brand='Renault', type='Kadjar', color='red'}

Shoe{id=3, brand='Volkswagen', type='Tiguan', color='red'}

该操作对流中的元素数进行计数。

@Test
public void countStream() {long count = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan).count();
    assertEquals(4, count);
}

该操作返回基于给定的的最大元素。在咱们的示例中，咱们创立一个 id 并检索具备最高 id 的元素。请留神，这将返回一个 . 当无奈确定最高 id 时，咱们只是提供了一个代替值。

@Test
public void maxStream() {int maxId = Stream.of(volkswagenGolf, skodaOctavia, renaultKadjar, volkswagenTiguan)
                      .map(Shoe::getId)
                      .max((o1, o2) -> o1.compareTo(o2))
                      .orElse(-1);
    assertEquals(3, maxId);
}

Java Streams API 十分弱小，学习起来并不难。stream 流解决可读性还是很不错的，想让本人代码变得更加简洁好看，那就来跟着本文学习吧，还有源码跟着调试。
如果您还不相熟 Streams API，能够装置 IDEA 的插件工具，调试 Java 流的杰出 IntelliJ 性能。

本文案例的源码地址：beierzsj/javaStreamDemo (github.com)

java-stream 流解决
汇合
Streams API
JavaDoc
调试 Java 流的 IDEA 工具装置插件

博主集体博客网站：奇想派

本文原创作者：奇想派、一名致力分享的程序员。

文章首发平台：微信公众号【编程达人】

原创不易！各位小伙伴感觉文章不错的话，无妨关注公众号，进行 点赞（在看）、转发 三连走起！谢谢大家！

正文完

java

发表至： java

2022-07-22

0

React简介和使用

Spring-Cloud开发人员如何解决服务冲突和实例乱窜

关于java:桥接模式

刚写完排序算法，就被开除了…

关于html:2022升级慕慕到家家政小程序组件化进阶实战

关于java:java8函数式编程之Stream流处理的方法和案例讲解

1. 引言

2. 创立流源

2.1 从汇合创立流

2.2 从数组创立流

2.3 从流创立流。

2.4 从 IntStream 创立流

2.5 从文件创建流

3. 两头操作（intermediate operations）

3.1 无状态操作

3.1.1 filter 操作

3.1.2 map 操作

3.1.3 组合过滤和映射操作 (filter+map)

3.2 有状态操作

3.2.1 distinct 操作

3.2.2 sorted 操作

3.3 用于调试目标的 peek

4. 终止操作（terminal operations）

4.1 collecti 操作

4.2 reduce 操作

4.3 forEach 操作

4.4 count 操作

4.5 max 操作

5. 论断

参考文档

站内搜索