stream 流

/*
Stream流
    体验Stream流
        可以简化集合和数组操作的代码

    Stream流流式思想
        Stream流是JDK8的新特性
        思想类似于工厂里面的生产流水线
        流水线只能从前往后，不能回头
        Stream流在使用的时候也是只能从前往后，不能回头（不能对一个流多次操作）

    Stream流的操作步骤
        1、获取流       源数据(集合和数组) ->流
        2、操作流
            中间方法
            终结方法
        3、收集流       流 ->源数据(集合和数组)

    获取流
        源数据(集合和数组) ->流

        集合
            default Stream<E> stream()

            单列集合
                直接调用stream()方法
            双列集合
                不能直接转换为Stream流，只能间接先转为单列集合然后再转为流

        数组
            Arrays.stream(T[] arr);
            Stream.of(T...)

            如何选择：
                如果是引用类型的数组
                    可以任意选择一个
                如果是基本类型的数组(int[])，
                    选择第一个，
                    或者选择第二个的时候，不要传递数组名，而是传递多个数组元素
    操作流
        Stream流（接口）中的方法

        中间方法：返回值为Stream类型，可以继续使用Stream中的方法操作流
            Stream filter(Predicate predicate)  用于对流中的数据进行过滤
            Stream limit(long maxSize)          返回此流中的元素组成的流，截取前指定参数个数的数据
            Stream skip(long n)                 跳过指定参数个数的数据，返回由该流的剩余元素组成的流
            static Stream concat(Stream a,Stream b) 合并a和b两个流为一个流
            Stream distinct()                   返回由该流的不同元素（根据Object.equals(Object) ）组成的流
        终结方法：返回值不是Stream类型，不能继续使用Stream中的方法操作流
            void forEach(Consumer action)   对此流的每个元素执行操作
            long count()                    返回此流中的元素数


        注：一个stream流对象只能使用一次

 */
public class StreamDemo3 {
    public static void main(String[] args) {
//        method1();
//        method2();
//        method3();

        // 获取流
        Stream<String> stream = Stream.of("hello", "java","php","abc","java","java");
//        Stream<String> stream = Set.of("hello", "java","php","abc").stream();
        // 操作流
        Stream<String> stream2 = stream.distinct();
        // 查看流中的数据
        stream2.forEach(s-> System.out.println(s));
    }

    private static void method3() {
        // 获取两个流
        Stream<String> stream1 = Stream.of("hello", "world");
        Stream<String> stream2 = Stream.of("hello", "java","php","abc");
        Stream<String> stream3 = Stream.of("hello", "java","php","abc");
        // 合并两个流
        Stream<String> concatStream = Stream.concat(stream1, stream2);
//        concatStream = Stream.concat(concatStream, stream3);
        // 查看流中的数据
        concatStream.forEach(s-> System.out.println(s));
    }

    private static void method2() {
        // Stream limit(long maxSize)
        // Stream skip(long n)
        // 获取流
        Stream<String> stream = List.of("aaa", "abc", "d", "hello", "java").stream();
        // 操作流
//        Stream<String> stream2 = stream.limit(3);
        Stream<String> stream2 = stream.skip(2);
        // 查看流中的数据
        stream2.forEach(s-> System.out.println(s));
    }

    private static void method1() {
        // Stream filter(Predicate predicate)  用于对流中的数据进行过滤
        /*Stream<String> stream = Stream.of("hello", "world", "java", "php");
        Stream<String> stream2 = stream.filter(new Predicate<String>() {
            // filter内部会对流中的数据进行遍历
            // 然后将遍历得到的每一个数据传递test方法
            // test方法中就可以对数据进行操作，这个操作是一种判断
            // 如果结果为true，则保留，如果为false则不保留
            @Override
            public boolean test(String s) {
                return s.length() == 5;
            }
        });
        stream2.forEach(s-> System.out.println(s));*/


        Stream.of("hello", "world", "java", "php")
                .filter(s ->s.length() == 5)
                .forEach(s-> System.out.println(s));
    }
}