Cbb Admin

Appearance

On this page

Stream API 上 ​

使用流 ​

创建流 ​

在使用流之前，首先需要拥有一个数据源，并通过 StreamAPI 提供的一些方法获取该数据源的流对象。数据源可以有多种形式：

1. 集合

这种数据源较为常用，通过 stream()方法即可获取流对象：

java
List<Person> list = new ArrayList<Person>();
Stream<Person> stream = list.stream();

2. 数组

通过 Arrays 类提供的静态函数 stream()获取数组的流对象：

java
String[] names = {"chaimm","peter","john"};
Stream<String> stream = Arrays.stream(names);

3. 值

直接将几个值变成流对象：

java
Stream<String> stream = Stream.of("chaimm","peter","john");

4. 文件

java
try(Stream lines = Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){
    //可对lines做一些操作
}catch(IOException e){
}

5. iterator

创建无限流

java
Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

PS：Java7 简化了 IO 操作，把打开 IO 操作放在 try 后的括号中即可省略关闭 IO 的代码。

筛选 filter ​

filter 函数接收一个 Lambda 表达式作为参数，该表达式返回 boolean，在执行过程中，流将元素逐一输送给 filter，并筛选出执行结果为 true 的元素。 如，筛选出所有学生：

java
List<Person> result = list.stream()
                    .filter(Person::isStudent)
                    .collect(toList());

去重 distinct ​

去掉重复的结果：

java
List<Person> result = list.stream()
                    .distinct()
                    .collect(toList());

截取 ​

截取流的前 N 个元素：

java
List<Person> result = list.stream()
                    .limit(3)
                    .collect(toList());

跳过 ​

跳过流的前 n 个元素：

java
List<Person> result = list.stream()
                    .skip(3)
                    .collect(toList());

映射 ​

对流中的每个元素执行一个函数，使得元素转换成另一种类型输出。流会将每一个元素输送给 map 函数，并执行 map 中的 Lambda 表达式，最后将执行结果存入一个新的流中。 如，获取每个人的姓名(实则是将 Perosn 类型转换成 String 类型)：

java
List<Person> result = list.stream()
                    .map(Person::getName)
                    .collect(toList());

合并多个流 ​

例：列出 List 中各不相同的单词，List 集合如下：

java
List<String> list = new ArrayList<String>();
list.add("I am a boy");
list.add("I love the girl");
list.add("But the girl loves another girl");

思路如下：

首先将 list 变成流：

java
list.stream();

按空格分词：

java
list.stream()
            .map(line->line.split(" "));

分完词之后，每个元素变成了一个 String[]数组。

将每个 String[] 变成流：

java
list.stream()
            .map(line->line.split(" "))
            .map(Arrays::stream)

此时一个大流里面包含了一个个小流，我们需要将这些小流合并成一个流。

将小流合并成一个大流：用 flatMap 替换刚才的 map

java
list.stream()
    .map(line->line.split(" "))
    .flatMap(Arrays::stream)

去重

java
list.stream()
    .map(line->line.split(" "))
    .flatMap(Arrays::stream)
    .distinct()
    .collect(toList());

是否匹配任一元素：anyMatch ​

anyMatch 用于判断流中是否存在至少一个元素满足指定的条件，这个判断条件通过 Lambda 表达式传递给 anyMatch，执行结果为 boolean 类型。 如，判断 list 中是否有学生：

java
boolean result = list.stream()
            .anyMatch(Person::isStudent);

是否匹配所有元素：allMatch ​

allMatch 用于判断流中的所有元素是否都满足指定条件，这个判断条件通过 Lambda 表达式传递给 anyMatch，执行结果为 boolean 类型。 如，判断是否所有人都是学生：

java
boolean result = list.stream()
            .allMatch(Person::isStudent);

是否未匹配所有元素：noneMatch ​

noneMatch 与 allMatch 恰恰相反，它用于判断流中的所有元素是否都不满足指定条件：

java
boolean result = list.stream()
            .noneMatch(Person::isStudent);

获取任一元素 findAny ​

findAny 能够从流中随便选一个元素出来，它返回一个 Optional 类型的元素。

java
Optional<Person> person = list.stream().findAny();

获取第一个元素 findFirst ​

java
Optional<Person> person = list.stream().findFirst();

归约 ​

归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。

在流中，reduce 函数能实现归约。 reduce 函数接收两个参数：

  1. 初始值
  2. 进行归约操作的 Lambda 表达式

元素求和：自定义 Lambda 表达式实现求和

例：计算所有人的年龄总和

java
@Test
public void contextLoads() {
   List<Person> list = new ArrayList<>();
   list.add(new Person().setAge(20));
   list.add(new Person().setAge(25));
   int age = list.stream().map(Person::getAge).reduce(0, Integer::sum);
   System.out.println(age);
}
java
@Data
@Accessors(chain = true)
class Person {
   private int age;
}
  1. reduce 的第一个参数表示初试值为 0；
  2. reduce 的第二个参数为需要进行的归约操作，它接收一个拥有两个参数的 Lambda 表达式，reduce 会把流中的元素两两输给 Lambda 表达式，最后将计算出累加之和。

元素求和：使用 Integer.sum 函数求和

上面的方法中我们自己定义了 Lambda 表达式实现求和运算，如果当前流的元素为数值类型，那么可以使用 Integer 提供了 sum 函数代替自定义的 Lambda 表达式，如：

java
int age = list.stream().reduce(0, Integer::sum);

Integer 类还提供了 min、max 等一系列数值操作，当流中元素为数值类型时可以直接使用。

数值流的使用 ​

采用 reduce 进行数值操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作，因此效率较低。 当流操作为纯数值操作时，使用数值流能获得较高的效率。

将普通流转换成数值流

StreamAPI 提供了三种数值流：IntStream、DoubleStream、LongStream，也提供了将普通流转换成数值流的三种方法：mapToInt、mapToDouble、mapToLong。 如，将 Person 中的 age 转换成数值流：

java
IntStream stream = list.stream().mapToInt(Person::getAge);

数值计算

每种数值流都提供了数值计算函数，如 max、min、sum 等。如，找出最大的年龄：

java
OptionalInt maxAge = list.stream()
                                .mapToInt(Person::getAge)
                                .max();

由于数值流可能为空，并且给空的数值流计算最大值是没有意义的，因此 max 函数返回 OptionalInt，它是 Optional 的一个子类，能够判断流是否为空，并对流为空的情况作相应的处理。 此外，mapToInt、mapToDouble、mapToLong 进行数值操作后的返回结果分别为：OptionalInt、OptionalDouble、OptionalLong

中间操作和收集操作 ​

操作类型返回类型使用的类型/函数式接口函数描述符
filter中间Stream<T>Predicate<T>T -> boolean
distinct中间Stream<T>
skip中间Stream<T>long
map中间Stream<R>Function<T, R>T -> R
flatMap中间Stream<R>Function<T, Stream<R>>T -> Stream<R>
limit中间Stream<T>long
sorted中间Stream<T>Comparator<T>(T, T) -> int
anyMatch终端booleanPredicate<T>T -> boolean
noneMatch终端booleanPredicate<T>T -> boolean
allMatch终端booleanPredicate<T>T -> boolean
findAny终端Optional<T>
findFirst终端Optional<T>
forEach终端voidConsumer<T>T -> void
collect终端RCollector<T, A, R>
reduce终端Optional<T>BinaryOperator<T>(T, T) -> T
count终端long

Copyright © 2021-2023 Aeasoft