Java Stream的用法

操作符

什么是操作符呢？操作符就是对数据进行的一种处理工作，一道加工程序；就好像工厂的工人对流水线上的产品进行一道加工程序一样。

Stream的操作符大体上分为两种：中间操作符和终止操作符

中间操作符

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符。

中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作)：

 1. map(mapToInt,mapToLong,mapToDouble) 转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。
 2. flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平 变成 2，3，4 
	也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。
 3. limit 限流操作，比如数据流中有10个 我只要出前3个就可以使用。
 4. distint 去重操作，对重复元素去重，底层使用了equals方法。
 5. filter 过滤操作，把不想要的数据过滤。
 6. peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。
 7. skip 跳过操作，跳过某些元素。
 8. sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

终止操作符

数据经过中间加工操作，就轮到终止操作符上场了；终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。

collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，
可以说Stream 的核心在于Collectors。
count 统计操作，统计最终的数据个数。
findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。
noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素 返回值为bool 值。
min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。
reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。
forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。
toArray 数组操作，将数据流的元素转换成数组。

这里只介绍了Stream，并没有涉及到IntStream、LongStream、DoubleStream，这三个流实现了一些特有的操作符，我将在后续文章中介绍到。

说了这么多，只介绍这些操作符还远远不够；俗话说，实践出真知。那么，Let‘s go。

代码演练

Stream 的一系列操作必须要使用终止操作，否者整个数据流是不会流动起来的，即处理操作不会执行。

全局变量

  	List<String> l = Lists.newArrayList("aa","bbb","cccc");
    List<String> l1 = Lists.newArrayList("a-b-c-d","e-f-i-g-h");
    List<Integer> l2 = Lists.newArrayList(1,2,3,4,5,6);
    List<Integer> l3 = Lists.newArrayList(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1);

map

将每一个元素进行操作，然后转给下一个

    @Test
     void test1() {
        l.stream().map(e->e.length()).forEach(e -> System.out.println(e));
        l.stream().map(e-> {
            System.out.println(e);
            return e.length();
        }).forEach(System.out::println);
    }

limit

取前n个

	@Test
    void test4(){
        l2.stream().limit(3).map(e->e*e).forEach(e-> System.out.println(e));
    }

distinct

去重

 	@Test
    void test5(){
        l3.stream().distinct().forEach(e-> System.out.println(e));
    }

filter

过滤

 	@Test
    void test6(){
        l3.stream().filter(e->e<=5).forEach(e-> System.out.println(e));
    }

peek

peek 没有返回值，不改变原来值，可以通过对象来改变

    @Test
    void test7(){
        User w = new User("w",10);
        User x = new User("x",11);
        User y = new User("y",12);

        Stream.of(w,x,y)
                .peek(e->{e.setName(e.getAge()+e.getName());}) //重新设置名字 变成 年龄+名字
                .forEach(e->System.out.println(e.toString()));
    }

skip

跳过前n个

  @Test
    void test8(){
        Stream.of(1,2,3,4,5,6,7,8,9)
                .skip(4) //跳过前四个
                .forEach(e->System.out.println(e)); //输出的结果应该只有5，6，7，8，9
    }

sorted

排序

  @Test
    void test9(){
        Stream.of(2,1,3,6,4,9,6,8,0)
                .sorted()
                .forEach(e->System.out.println(e));
        User w = new User("w",10);
        User x = new User("x",13);
        User y = new User("y",12);
        Stream.of(w,x,y)
                .sorted(Comparator.comparing(User::getAge)).forEach(e-> System.out.println(e));
    }

parallel 并行流

在并行（parallel）流下每次返回的结果可能一样也可能不一样

    @Test
    void test10(){
//            Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
//                    .parallel()
//                    .findAny(); 
            stringOptional.ifPresent(e->System.out.println(e));
        Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .parallel().forEach(System.out::println);
    }

noneMatch

正则匹配判断无

  @Test
    void test11(){
        boolean result = Stream.of("aba","bb","cc","aba")
                .noneMatch(e->e.equals("aa"));
        System.out.println(result);
    }

min

取最小值

    @Test
    void test12(){
        Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)
                .min((e1,e2)->e1.compareTo(e2));
        integerOptional.ifPresent(e->System.out.println(e));
    }

reduce

聚合

   @Test
    void test13(){
        int sum = Stream.of(1,9,8,4)
                .reduce(100,(e1,e2)->e1*e2);
        System.out.println(sum);
    }