Stream流式编程

Stream流式编程

 

Stream流

• 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
• 当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。
• 诸如filter 、 map、 skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 类似于count,forEach执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。就相当于现将流水线硬件先建立好，然后再启动流水线！

“Stream流”其实是一个集合元素的函数模型(处理的步骤方法)，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列

• 元素是特定类型的对象，形成一个队列，Java中的Stream并不会存储元素，而是按需计算。
• 数据源流的来源，可以使集合、数组等。

和以前的Collection操作不同， Stream操作还有两个基础的特征

• Pipelining:中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluentstyle）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)
• 内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

通常使用流的三个基本步骤

1. 获取一个数据源(Source)
2. 数据转换
3. 执行操作获取险要的结果

每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道

一、获取流

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。【这并不是一个函数式接口。】，获取流有一下几种方式

• 所有的Collection集合都可以通过stream默认方法获取流
• Stream接口的静态方法of可以获取数组对应的流

1.根据Collection获取流

java.util.Collection 接口中加入了默认方法default stream 用来获取流，所以其所有实现类均可获取流

List<String> list = new ArrayList<>();
Stream<String> st1 = list.stream();

Set<String> set = new HashSet<>();
Stream<String> st2 = set.stream();

Vector<String> vector = new Vector<>();
Stream<String> st3 = vector.stream();

2.根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况

Map<String,String> map = new HashMap<>();

Stream<String> keyStream = map.keySet().stream();

Stream<String> valueStream = map.values().stream();

Stream<Map.Entry<String,String>> entryStream = map.entrySet().stream();

3.根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream接口中提供了静态方法of ，使用很简单
of方法的签名是可变长参数

String[] array = {"张三","李四","王二","麻子"};
Stream<String> st1 = Stream.of(array);

二、常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

• 延迟方法：返回值任然是Stream接口自身类型的方法，因此支持链式调用(除了终结方法外，其他都是方法均为延迟方法)
• 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder【add的链式调用】那样的链式调用，这里介绍count和forEach方法其他终结方法请参考API

1.逐一处理:forEach

虽然方法名字叫forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

java.util.function.Consumer<T>接口是一个消费型接口。Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

基本使用：

Stream<String> st1 = Stream.of("张三","李四","王二","麻子");
st1.forEach(System.out::println);
// 等同于如下代码
// st1.forEach(s -> System.out.println(s));

2.过滤:filter

可以通过filter方法将一个流转换成另一个子集流。方法签名

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

java.util.stream.Predicate 函数式接口唯一的抽象方法为boolean test(T t);,该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

基本使用：

Stream.of("张三","李四","王二","麻子","张三丰","张无忌")
        .filter(s -> s.startsWith("张"))
        .forEach(System.out::println);

3.映射:map

如果需要将流中的元素映射到另一个流中，可以使用map方法，方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个Function函数式接口，可以将当前流中的T类型数据转换为另一种R类型的流

此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：R apply(T t);,这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。

Stream.of("1","2","3","4","5","6")
        .map(Integer::parseInt)
        .forEach(s -> System.out.println(s*10));

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。

4.统计个数:count

正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

System.out.println(Stream.of("1", "2", "3", "4", "5", "6")
        .map(Integer::parseInt)
        .count());

5.取前几个:limit

limit方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用

Stream.of("1", "2", "3", "4", "5", "6")
        .limit(1)
        .forEach(System.out::println);

6.跳过前几个:skip

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流；

Stream<T> skip(long n);

如果流的当前长度大于n,则跳过前n个；否则将会得到一个长度为0的空流。

Stream.of("1", "2", "3", "4", "5", "6")
        .skip(5)
        .forEach(System.out::println);

7.组合:count

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

static <T> Stream<T> concat(Stream<? extend T> a, Stream<? extends T> b)

这是一个静态方法，与java.lang.String当中的concat方法是不同的。

Stream.concat(
        Stream.of("1", "2", "3", "4", "5", "6"),
        Stream.of("7")
).forEach(System.out::println);

8.验证流的工作方式

流的工作方式为：先建立流水线[Lambda表达式的延迟执行]，然后通过内部迭代迭代一个走一个，。。。

ArrayList<String> arr = new ArrayList<>();
arr.add("张翠山");
arr.add("张无忌");
arr.add("张大侠");
arr.add("张三丰");
arr.add("张傻屌");

arr.stream().filter(s -> {
    System.out.println("@1");
    return s.startsWith("张");
}).filter(s -> {
    System.out.println("#2");
    return s.length() == 3;
}).forEach(System.out::println);

运行结果

@1
#2
张翠山
@1
#2
张无忌
@1
#2
张大侠
@1
#2
张三丰
@1
#2
张傻屌

9.并发流的两种获取方式

并发流就是把多扩展几个流水线，将数据成几段交给这些流水线执行。每个流水线拿到上每次只有一个数据在跑。

并发流的两种获取方式：

Collection<String> coll = new ArrayList<>();

Stream<String> parallelStream1 = coll.parallelStream();
Stream<Integer> parallelStram2 = Stream.of(100,200,300,400,500).parallel();

单线程流和并发流的案例

        int n = 100000000;
        Integer[] arr = new Integer[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }

        ArrayList<Integer> first = new ArrayList<>();
        ArrayList<Integer> second = new ArrayList<>();

        long start1 = System.currentTimeMillis();
        Stream.of(arr)
                .filter(a -> a % 2 == 0)
                .filter(b -> b % 3 == 0)
                .filter(c -> c % 5 == 0)
                .filter(d -> d % 7 == 0)
                .forEach(first::add);
        long end1 = System.currentTimeMillis();
        System.out.println("单线程流：" + (end1 - start1) + "ms");

        long start2 = System.currentTimeMillis();
        Stream.of(arr).parallel()
                .filter(a -> a % 2 == 0)
                .filter(b -> b % 3 == 0)
                .filter(c -> c % 5 == 0)
                .filter(d -> d % 7 == 0)
                .forEach(second::add);
        long end2 = System.currentTimeMillis();
        System.out.println("并发流耗时：" + (end2 - start2) + "ms");

执行结果

单线程流：1890ms
并发流耗时：828ms

三、综合应用

1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
5. 将两个队伍合并为一个队伍；存储到一个新集合中。
6. 根据姓名创建 Person 对象；存储到一个新集合中。
7. 打印整个队伍的Person对象信息。

import java.util.*;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {

        List<String> one = new ArrayList<>();

        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        Stream.concat(
                one.stream().filter(s -> s.length() == 3).limit(3),
                two.stream().filter(s -> s.startsWith("张")).skip(2)
        ).map(Person::new).forEach(System.out::println);

    }
}

class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                '}';
    }
}

原创：https://www.jianshu.com/p/5b97e86aa1ee