Java进阶- Stream流

Stream流

Stream流概述

Java中的Stream并不会存储元素，而是对数据进行计算操作

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

创建Stream流

Stream流的创建方式一

创建Stream方式1：通过集合创建
	集合.stream()；

所有的 Collection集合都可以通过 stream 默认方法获取流,
因为java.util.Collection 接口中加入了default方法 stream 用来获取流，
所以Collection其所有实现类均可获取流

Stream流的创建方式二

创建Stream方式2：通过数组创建
Arrays.stream()；

Stream流的创建方式三

创建Stream方式3：通过Stream中静态方法
Stream.of(T... values)
  

Stream流的创建方式四

创建Stream方式4：创建无限流
Stream.generate(Supplier<T> s)

Steam流的中间操作

常用的中间操作：
limit(long maxSize):获取Stream流中最多maxSize个数据
skip(long n):获取Stream流中n+1及之后的数据
filter(Predicate predicate):筛选stream中符合条件的数据
map(Function<? super T, ? extends R> mapper)：将数据流中的数据转换为另一个数据
Stream.concat(stream1,stream1): 将两个数据流合并

Steam流的终结操作

常用的终结操作：
count(): 获取数据流中数据的数量
forEach(Consumer consumer)：遍历数据流中的数据

代码实现

package com.tan.usestream;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/*
创建Stream方式1：通过集合创建
集合.stream()；

创建Stream方式2：通过数组创建
Arrays.stream()；

创建Stream方式3：通过Stream中静态方法
Stream.of(T... values)

创建Stream方式4：创建无限流
Stream.generate(Supplier<T> s)

常用的中间操作：
limit(long maxSize):获取Stream流中最多maxSize个数据
skip(long n):获取Stream流中n+1及之后的数据
filter(Predicate predicate):筛选stream中符合条件的数据
map(Function<? super T, ? extends R> mapper)：将数据流中的数据转换为另一个数据
Stream.concat(stream1,stream1): 将两个数据流合并

常用的终结操作：
count(): 获取数据流中数据的数量
forEach(Consumer consumer)：遍历数据流中的数据
 */
public class UseStream {

    @Test
    public void createStream(){
        /*
        创建Stream方式1：通过集合创建
        输出：
            1
            2
            3
         */
        List<Integer> list = Arrays.asList(1,2,3,5,6,7);
        Stream<Integer> stream1 = list.stream();
        //limit(long maxSize):获取Stream流中最多maxSize个数据
        stream1.limit(3).forEach(s -> System.out.println(s));
        System.out.println(" ====================================== " );

        /*
        创建Stream方式2：通过数组创建
        输出：
            c
            d
            e
         */
        String[] strArr = new String[]{"a","b","c","d","e"};
        Stream<String> stream2 = Arrays.stream(strArr);
        //skip(long n):获取Stream流中n+1及之后的数据
        stream2.skip(2).forEach(s -> System.out.println(s));
        System.out.println(" ====================================== " );

        /*
        创建Stream方式3：通过Stream中静态方法
        输出：
            2
            6
         */
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 5, 6, 7);
        stream3.filter(i -> i % 2 == 0).forEach(s -> System.out.println(s));
        System.out.println(" ====================================== " );

        //创建Stream方式4：创建无限流
//        Stream.generate(() ->Math.random()).forEach(s -> System.out.println(s));

        /*
        filter(Predicate predicate):筛选stream中符合条件的数据
        map(Function<? super T, ? extends R> mapper)：将数据流中的数据转换为另一个数据
        forEach(Consumer consumer)：遍历数据流中的数据
        输出：
            12
            16
         */
        Stream<Integer> stream5 = Stream.of(1, 2, 3, 5, 6, 7);
        stream5.filter(i -> i % 2 == 0).map(s -> s + 10).forEach(s -> System.out.println(s));
        System.out.println(" ====================================== " );

        /*
        count(): 获取数据流中数据的数量
        输出：
            2
         */
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 5, 6, 7);
        System.out.println(stream6.filter(i -> i % 2 == 0).map(s -> s + 10).count());
        System.out.println(" ====================================== " );


        /*
        Stream.concat(stream1,stream1): 将两个数据流合并
        输出：
            1
            2
            3
            5
            6
            7
         */
        Stream.concat(Stream.of(1, 2, 3),Stream.of(5,6,7)).forEach(System.out::println);
    }
}