java8-Stream

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

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

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

Stream对象的使用
Stream对象提供多个非常有用的方法，这些方法可以分成两类：
中间操作：将原始的Stream转换成另外一个Stream；如filter返回的是过滤后的Stream。
终端操作：产生的是一个结果或者其它的复合操作；如count或者forEach操作。

一. 创建 Stream

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）获取一个流非常简单，有以下几种常用的方式：
所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

   @Test
    public void test1(){
        //1. Collection 提供了两个方法  stream() 与 parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream(); //获取一个顺序流
        Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
        
        //2. 通过 Arrays 中的 stream() 获取一个数组流
        Integer[] nums = new Integer[10];
        Stream<Integer> stream1 = Arrays.stream(nums);
        
        //3. 通过 Stream 类中静态方法 of()
        Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
        
        //4. 创建无限流
        //迭代
        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
        stream3.forEach(System.out::println);
        
        //生成
        Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
        stream4.forEach(System.out::println);
    }

二.常用方法

些常用的API。这些方法可以被分成两种：
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。

1.迭代：forEach

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        stream.forEach(name-> System.out.println(name));
    }
}

2.过滤：fifilter

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

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        Stream<String> result = stream.filter(s-> s.startsWith("张"));
        result.forEach(s->System.out.println(s));
    }
}

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

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("10", "11","199","100");
        Stream<Integer> result = stream.map(str->Integer.parseInt(str));
        result.forEach(s->System.out.println(s));
    }
}

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

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        System.out.println(stream.count());
    }
}

5.取用前几个：limit
limit 方法可以对流进行截取，只取用前n个。

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        Stream<String> result = stream.limit(2);
        System.out.println(result.count()); 
    }
}

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

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        Stream<String> result = stream.skip(2);
        System.out.println(result.count()); 
    }
}

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

package com.test.web.service;
import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌", "张三丰","赵敏","周芷若");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
        result.forEach(s->System.out.println(s));
    }
}