Stream流创建及使用

• Stream流提供流式方式处理数据源，它并不是一种数据结构，为函数式编程而生，他只是数据原基础上的一个视图操作，不会改变数据源本身的内容，使用完了之后就会失效，和集合的迭代器一样。
• Stream流是Java 8引入的一个新特性，它允许我们以声明性方式处理数据集合（如列表、集合等）。通过使用Stream API，我们可以对集合进行复杂的查询和转换操作，而无需使用显式的for-each循环或其他迭代方法。

Stream流的使用分三个过程 创建和中间处理 还有结果汇总

stream流创建

通过Stream类提供的of()方法创建流

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> stream2 = Stream.of(new Integer[]{1,5,5,3,4,52,});

通过集合创建Stream

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Stream<Integer> stream3 = list.stream();

中间过程

中间过程是流式处理每个元素的时候对元素应该做什么

filter 过滤

对元素进行过滤，filter方法参数是一个函数式接口可以通过lambda表达式书写。返回true元素保留，返回false进行元素删除。

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer != 3;
            }
        }).collect(Collectors.toList());
        System.out.println(list1);
        /**
         * result
         * [1, 2, 4]
         */
    }
}

等价于

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.filter( a -> a != 3 ).collect(Collectors.toList());
        System.out.println(list1);
        /**
         * result
         * [1, 2, 4]
         */
    }
}

map 映射

映射元素到对应的结果中，用的最多的方式就是通过现有的元素信息构建出一个新的元素集合流

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Stream<Integer> stream3 = list.stream();
        List<String> list1 = stream3.map(a -> a + "aaa").collect(Collectors.toList());
        System.out.println(list1);
        /**
         * result
         * [1aaa, 2aaa, 3aaa, 4aaa]
         */
    }
}

limit 和 skip  截取

其中limit负责 截取前面的n个元素，skip是截取n个后面的元素

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.limit(2L).collect(Collectors.toList());
        System.out.println(list1);
        /**
         * result
         * [1, 2]
         */
    }
}

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.skip(
                2L).collect(Collectors.toList());
        System.out.println(list1);
        /**
         * result
         * [3, 4, 5]
         */
    }
}

sorted 排序

这个方法参数依旧是需要实现一个函数式接口 可以通过lambda表达式简化

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,7,4,5);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.sorted((a, b) -> b - a).collect(Collectors.toList());
        System.out.println(list1); // [7, 5, 4, 2, 1]
    }
}

distinct 去重

去重方法没有参数，直接使用即可

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,7,6,6,6,6,6,6,4,5);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.distinct().collect(Collectors.toList());
        System.out.println(list1); // [1, 2, 7, 6, 4, 5]
    }
}

remark 

这里需要注意的是，中间过程不是只能使用一种，在处理的过程中是可以使用多种过程处理的

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,7,6,6,6,6,6,6,4,5);
        Stream<Integer> stream3 = list.stream();
        List<Integer> list1 = stream3.distinct().sorted().collect(Collectors.toList());
        System.out.println(list1); // [1, 2, 4, 5, 6, 7]
    }
}

结果汇总

处理过程结束之后肯定是需要使用处理过程中产生的结果的， 像我上面其实已经用到了一个过程汇总的方法，也就是collect 这个方法，这是一个归约操作，将结果归约成所需要的数据格式，并且结果汇总是最后一个操作，进行了结果汇总之后就不能再进行其他操作了。其实也就是这个流已经失效了。

collect 归约 

这个就不举例了前面用过很多次

foreach 遍历

见名知意，也就是一个遍历的操作

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,7,6,6,6,6,6,6,4,5);
        Stream<Integer> stream3 = list.stream();
        stream3.distinct().sorted().forEach(a -> System.out.print(a + "\t")); // 1	2	4	5	6	7
    }
}

cout 统计

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,7,6,6,6,6,6,6,4,5);
        Stream<Integer> stream3 = list.stream();
        System.out.println(stream3.distinct().sorted().count()); // 6
    }
}

总的来说，通过Stream流处理数据还是十分方便、直观并且高效的。