[开发测试]jdk8新特性Stream流

Stream流开始操作

通过集合创建

    /**
     * 通过集合创建
     */
    @Test
    public void test1(){
        List<String> stream1 = Arrays.asList("java", "h5", "python", "php", "c");
        stream1.stream().forEach(s -> System.out.println(s));
    }

通过数组创建

    /**
     *通过数组创建
     */
    @Test
    public void test2(){
        String [] str={"春","夏","球","冬"};
        Arrays.stream(str).forEach(System.out::println);
    }

通过Stream的of创建

    /**
     * 通过Stream的of创建
     */
    @Test
    public void test3(){
        Stream.of("小明","小王","小李","小杨").forEach(System.out::println);
    }

Stream流中间操作

filter过滤

 /**
     *stream过滤操作
     */
    @Test
    public void test1(){
        //创建stream
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

        //filter过滤操作
        stream = stream.filter(a -> a % 2 == 0);

        //输出保留偶数值
        stream.forEach(System.out::println);

        //创建字符串数据，过滤李四
        List<String> list = Arrays.asList("张三", "李四", "王五");
        Stream<String> name = list.stream().filter(str -> !"李四".equals(str));
        name.forEach(s-> System.out.println(s));

        list.stream().filter(s->!"王五".equals(s)).forEach(System.out::println);
    }

distinct去重

    /**
     *distinct去重操作
     */
    @Test
    public void test2(){
        Stream<Integer> stream = Stream.of(1, 1, 8, 2, 5, 4, 4, 2, 9, 8, 3);
        stream.distinct().forEach(System.out::println);
    }

limit截断，只保留前几位

    /**
     *limit截断操作
     */
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
        stream.limit(5).forEach(System.out::println);
    }

skip跳过，跳过几位，与limit相反

    /**
     *skip跳过
     */
    @Test
    public void test4(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
        stream.skip(5).forEach(System.out::println);
    }

peek对每个元素进行Lambda操作

    /**
     *peek
     */
    @Test
    public void test5(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
        stream.peek(c->System.out.println(c)).count();
    }

sorted排序按自然顺序排序

    /**
     *sorted自然排序
     */
    @Test
    public void test6(){
        Stream<Integer> stream = Stream.of(11, 23, 53, 4, 4, 55, 76, 7, 83, 29, 60);
        stream.distinct().sorted().forEach(System.out::println);
    }

map映射成新元素

    /**
     *map映射
     */
    @Test
    public void test7(){
        Stream<Integer> stream = Stream.of(11, 23, 53, 4, 4, 55, 76, 7, 83, 29, 60);
        stream.distinct().map(m->m+1).forEach(System.out::println);

        Stream<String> list = Stream.of("mi", "jd", "taobao", "baidu");
        list.map(t->t.toUpperCase()).forEach(System.out::println);
    }

所有中间操作方法列表

Stream终结操作

forEach迭代遍历

count返回流中元素总数

allMatch检查是否匹配所有元素

    /**
     * allMatch检查是否匹配所有元素
     */
    @Test
    public void test1(){
        boolean b = Stream.of(2, 4, 6, 8).allMatch(t -> t % 2 == 0);
        System.out.println(b);
    }

anyMatch检查是否至少匹配一个元素

    /**
     * anyMatch检查是否至少匹配一个元素
     */
    @Test
    public void test2(){
        boolean b = Stream.of(2, 3, 7, 5).anyMatch(t -> t % 2 == 0);
        System.out.println(b);
    }

findFirst返回第一个元素

    /**
     * findFirst返回第一个元素
     */
    @Test
    public void test3(){
        Optional<Integer> first = Stream.of(2, 3, 7, 5).findFirst();
        System.out.println(first.get());
    }

max返回最大值

    /**
     * max返回最大值
     */
    @Test
    public void test4(){
        Optional<Integer> max = Stream.of(2, 3, 7, 5).max(Integer::compareTo);
        System.out.println(max.get());
    }

reduce可以将流中元素反复结合操作起来，得到一个值

    /**
     * reduce
     */
    @Test
    public void test5(){
        String reduce = Stream.of("a", "b", "c", "d").reduce("hhh", String::concat);
        System.out.println("recoed:"+reduce);
    }

collect将流转换为其他形式

    /**
     * collect
     */
    @Test
    public void test6(){
        List<String> collect = Stream.of("a", "b", "c", "d").collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

所有总结操作的方法列表