Stream流

Stream流属于管道流，只能被消费（使用）一次，第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这时第一个Stream流已经使用完毕，就会关闭，所以第一个Stream流就不能再调用方法了
1、使用Stream流遍历集合

    public static void main(String[] args) {
        /*
            创建一个集合，对集合中的任务姓名进行筛选，只输出名字姓张且只有三位的名字
         */
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张三");
        list.add("周芷若");
        list.add("灭绝师太");
        // 传统遍历
        for (String s : list) {
            if (s.startsWith("张") && s.length() == 3) {
                System.out.println(s);
            }
        }

        // 使用Stream流方式遍历集合
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 3;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        // 简化使用Stream流方式遍历集合
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

    }

2、 获取Stream流的方式
java.util.stream.Stream是java 8 新加入的最常用的流接口（非函数式接口）
2.1 第一种：
所有的Collection集合都可以通过调用stream默认方法获取流对象
default Stream stream()
2.2 第二种：
Stream接口的静态方法of可以获取数组对应的流
static Stream of (T… values)
参数是一个可变参数，所以需要传递一个数组

    public static void main(String[] args) {
        // 把集合转换为流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

        Map<String, String> map = new HashMap<>();
        Set<String> s = map.keySet();
        Stream<String> stream3 = s.stream();

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

        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        // 把数组转换为流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        int[] arr = {1, 2, 3, 4, 5};
        Stream<int[]> stream7 = Stream.of(arr);
    }

3、 常用方法
3.1 、延迟方法：
返回值类型仍然是Stream接口自身类型的方法，支持链式调用
3.1.1 filter方法：
Stream filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口，可以传递Lambda表达式，对数据进行过滤
Predicate中的抽象方法：
boolean test(T t);

        Stream<String> stream = Stream.of("张三丰", "张无忌", "张翠山", "赵敏", "周芷若");
        Stream<String> filterStream = stream.filter(name -> name.startsWith("张"));
        filterStream.forEach(name -> System.out.println(name));

3.1.2 map方法：
Stream map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换成为另一种R类型的流。
Function中的抽象方法：
R apply(T t);

        // 将字符串整型转换为Integer类型
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Stream<Integer> integerStream = stream.map(s -> Integer.parseInt(s));
        integerStream.forEach(i -> System.out.println(i));

3.1.3 limit方法：
limit方法用于截取流中的元素
limit方法可以对流进行截取，只取前n个
Stream limit(long maxSize);
参数是一个long类型，如果集合当前长度大于参数则进行截取，否则不进行操作

        // 截取
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Stream<String> limit = stream.limit(3);
        limit.forEach(s -> System.out.println(s));

3.1.4 skip方法：
skip方法用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流
Stream skip(long n);
如果流的长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

        // 跳过元素
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Stream<String> skip = stream.skip(3);
        skip.forEach(s -> System.out.println(s));

3.1.5 concat方法：
aoncat方法用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static Stream concat(Stream<? extends T> a, Stream<? extends T> b);

        // 合并两个流
        Stream<String> stream1 = Stream.of("1", "2", "3", "4", "5");
        Stream<String> stream2 = Stream.of("6", "7", "8", "9");
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(s -> System.out.println(s));

3.2、 终结方法：
返回值类型不再是Stream接口自身类型的方法，不支持链式调用
3.2.1 forEach方法：
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口，会将每一个流元素交给该函数进行处理。
Consumer接口是一个消费型的函数式接口，可以传递lambda表达式消费数据
简单来说forEach方法就是用来遍历数据的

        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        stream6.forEach(i -> System.out.println(i));

3.2.2 count方法：
count方法用于统计Stream流中元素的个数
long count();

        // 统计Stream流中元素的个数
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        long num = stream.count();
        System.out.println(num);