java8 Stream

1 简介: 

java8引进的一种新特性,主要就是在操作数组,操作集合时候会方便很多,可以对批量的数据进行相关的操作,废话不多说,看案例,简单总结:

2 特点: 

转换操作：把Stream转换成另一个Stream(例如map方法)，该Stream会被标注为operated。

终止操作：对stream应用终止操作(例如count方法)，改Stream会被标注为closed。

3  创建Stream:

代码中赋有注释:

private static void createStream() {
        //Stream相关的学习
        //可变数组创建Stream
        Stream<Integer> integerStream = Stream.of(0, 1, 2, 3, 4, 5);
        //数组创建Stream
        String[] b = {"1", "2", "3", "4", "5"};
        Stream<String> stream1 = Arrays.stream(b);
        //集合创建Stream
        //单列集合
        Stream<String> stream = Arrays.asList("1", "2", "3").stream();
        //双列
        //其实就是根据键的集合或者值的集合创建的Stream
        //值的集合
        Stream<Map.Entry<String, String>> stream2 = new HashMap<String, String>().entrySet().stream();
        //键的集合
        Stream<String> stream3 = new HashMap<String, String>().keySet().stream();
    }

4 Stram的中间操作/转换操作:

/**
     * 这些操作并不会终结流,但是这些流的相关操作后会转换成新的流
     * 对流中元素进行操作;
     * filter：过滤流中的某些元素
     * limit(n)：获取n个元素
     * skip(n)：跳过n元素，配合limit(n)可实现分页
     * distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
     */
    private static void operation() {
        Stream<String> stream = Arrays.asList("1", "2", "3", "4", "5", "6", "3", "4", "6").stream();
        //stream.forEach(System.out::println);
        //stream.skip(1).forEach(System.out::println);
        //stream.limit(1).forEach(System.out::println);
        //stream.skip(2).forEach(System.out::println);
        //stream.distinct().forEach(System.out::println);
    }

5 将字符串切割为Stream:

private static void compileSplitString() {
        //使用正则表达式将字符串切割成流
        Pattern compile = Pattern.compile(",");
        String str = "我是一个小画家,粉刷本事强,啦啦啦";
        String[] split = compile.split(str);
        Stream<String> stringStream = compile.splitAsStream(str);
        //stringStream.forEach(System.out::println);这个动作会阻断流
        Object[] objects = stringStream.toArray();
        System.out.println(Arrays.toString(objects));
    }

6 Stream的典型终结:

/**
     * 典型的终结流的方法,这只是代表性的两个
     * foreach();
     * count();
     */
    private static void endStream() {
        Stream<String> stream = Arrays.asList("1", "3", "5", "7", "9").stream();
        stream.forEach(System.out::println);//这个操作会终结流
        final long count = stream.count();//会报出异常,上面已经对流做了终结的操作
    }

7 Stream的map操作:

/**
     * 接受Function表达式,对流中元素进行相关的操作,将返回的结果作作为新的流对象
     * map(Function ...);接受一个方法,将流中的每个元素都放在该方法中执行
     * flatmap(Function);接受一个方法,该方法返回一个流对象,然后将返回的所有的流对象组合成一个新的流
     */
    private static void mapStreamApi() {
        final Stream<String> stream = Arrays.asList("1aa", "3aa", "5aa", "1aa", "97").stream();
        //stream.map(e->e+"test").forEach(System.out::println);
        stream.flatMap(s -> {
            final String a = s.replaceAll("a", "");
            return Stream.of(a);
        }).forEach(System.out::println);
    }

8 Stream的peek操作:

    /**
     * peek:类似map操作,但是没有返回值,接受的是有一个构造表达式(Consumer)
     * 其实就是相当于将流中的对象复制了一份进行相关操作,但是并不改变原始的流对象属性
     */
    private static void peekStreamApi() {
        final Stream<String> stream = Arrays.asList("1aa", "3aa", "5aa", "1aa", "97").stream();
        stream.peek(s -> {
            if (s.contains("a")) {
                System.out.println(s);
                s = s + "bb";
            }
        }).forEach(System.out::println);//并没有改变原始的流对象属性

    }

9 Stream排序数组/集合:

/**
     * 通过流实现排序(若是流中的对象实现了比较器,就可以直接排序)
     * 一般都是在这块自定义比较器表达式实现排序
     * 通过集合也可以实现排序List<T>.sort()......
     */
    private static void sortStreamApi() {
        final Stream<Integer> stream = Stream.of(1, 55, 6, 78, 2, 79, 0, 34, 5, 7, 100, 2);
        // stream.sorted().forEach(System.out::println);//int类型会自动排序
        final Stream<Abb> steam = Stream.of(new Abb("1", 222), new Abb("2", 33), new Abb("3", 424));
        //steam.sorted().forEach(System.out::println);//按照实体类中实现的比较器排序
        steam.sorted(new Comparator<Abb>() {
            @Override
            public int compare(Abb o1, Abb o2) {
                return o1.getAge() - o2.getAge();
            }
        }).forEach(System.out::println);
    }

10 Stream的其他相关Api:

    /**
     * 其他相关的Api
     * findFirst()
     * findAny();
     * max(new Comparator)
     * min(new Comparator)
     */
    private static void othersStream() {
        final Stream<Integer> stream = Arrays.asList(1, 2, 34, 43, 5, 6, 7, 5, 6, 76, 8).stream();
        //stream.findFirst();
        //stream.findAny();
        //stream.max(new Comparator<Integer> )
        //stream.min(new Comparator<Integer> )
    }

11 stream检测集合中的数据:

/**
     * 常用于校验一组数据
     * 1.boolean anyMatch ： 任意一个元素满足条件，即返回true,否则返回false;
     * 2.boolean allMatch : 所有的元素都满足条件，才返回true,否则返回false;
     * 3.boolean noneMatch : 所有元素都不满足条件，才返回true,否则返回false;
     */
    private static void streamCheckDate() {
        final Stream<Integer> stream = Arrays.
                asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10).stream();
        //final boolean b = stream.anyMatch(s -> s > -1);
        //final boolean b = stream.noneMatch(s->s>100);
        final boolean b = stream.allMatch(s -> s < 100);
        System.out.println(b);
    }

12 Stream对集合进行分组收集操作:

    /**
     * Stream流相关操作集合(分组等....)
     */
    private static void streamCollectionOpertaion() {
        final Stream<Abb> stream = Arrays.asList(
                new Abb("111", 11), new Abb("2fv2", 11),
                new Abb("11ds", 33), new Abb("2vgf", 11),
                new Abb("1ce1", 11), new Abb("fgv2", 33),
                new Abb("111", 22), new Abb("2f0gv2", 33),
                new Abb("1cew1", 11), new Abb("22bg", 22)
        ).stream();
        final Map<Integer, List<Abb>> collect = stream.collect(Collectors.groupingBy(Abb::getAge));
        collect.forEach((k, v) -> {
            System.out.print(k);
            System.out.print("  ");
            System.out.println(v);
        });
    }

睡觉..