Java8 Stream（聚合操作）的常用api以及它和parallelStream的主要区别

        /**
         * 构造Stream流的几种方式
         */
        //数组
        String[] arr = new String[]{"a", "b", "c"};
        Stream stream = Arrays.stream(arr);
        Stream stream3 = Stream.of(arr);
        //集合
        List list = Arrays.asList("a", "b", "c");
        Stream stream1 = list.stream();
        //值
        Stream stream2 = Stream.of("a", "b", "c");

        boolean flag = false;
        ArrayList userList = new ArrayList<>();
        userList.add(new User(3, "wangwu"));
        userList.add(new User(2, "lisi"));
        userList.add(new User(4, "zhaoliu"));
        userList.add(new User(1, "zhangsan"));

        /**
         * Streams常用api接口
         */
        userList.forEach(user -> System.out.println(user));

        System.out.println("=======================forEach() 遍历集合=======================");
        userList.stream().forEach(user -> System.out.println(user));

        System.out.println("=======================sorted() 排序=======================");
        userList.stream().sorted(Comparator.comparing(User::getId)).forEach(user -> System.out.println(user));

        System.out.println("=======================filter() 过滤条件=======================");
        userList.stream().filter((User user) -> user.getId() != 2).forEach(user -> System.out.println(user));

        System.out.println("=======================limit() 只取前n位 下标从1开始，包括n=======================");
        userList.stream().limit(1).forEach(user -> System.out.println(user));

        System.out.println("=======================skip()  只取n位之后的，不包括n，下标从1开始=======================");
        userList.stream().skip(1).limit(1).forEach(user -> System.out.println(user));

        if (flag) {
            userList.add(new User(1, "zhangsan"));
            userList.add(new User(1, "zhangsan"));
            userList.add(new User(1, "zhangsan"));
            System.out.println("=======================distinct() 去重 必要时需要重写equals和hashCode方法=======================");
            userList.stream().distinct().forEach(user -> System.out.println(user));
        }

        System.out.println("=======================summaryStatistics() 用来计算avg/sum/count/max/min=======================");
        IntSummaryStatistics intSummaryStatistics = userList.stream().mapToInt(user -> user.getId()).summaryStatistics();
        System.out.println("平均值：" + intSummaryStatistics.getAverage());
        System.out.println("总和：" + intSummaryStatistics.getSum());
        System.out.println("个数：" + intSummaryStatistics.getCount());
        System.out.println("最大值：" + intSummaryStatistics.getMax());
        System.out.println("最小值：" + intSummaryStatistics.getMin());

        System.out.println("=======================map() 将一个方法的返回值作为参数，并将它映射成一个新的元素=======================");
        List collect = userList.stream().map(user -> user.getUsername()).collect(Collectors.toList());
        collect.stream().forEach(name -> System.out.println(name));
        System.out.println("=======================双冒号的写法：String:toUpperCase表示类名调用方法=======================");
        List collect4 = list.stream().map(String::toUpperCase).collect(Collectors.toList());
        collect4.stream().forEach(s -> System.out.println(s));

        System.out.println("=======================flatMap() 将Stream流中的元素重新组装成一个新的Stream流=======================");
        //创建一个装有两个泛型为Integer集合的流
        Stream> listStream = Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5));
        //返回一个新的Stream
        Stream rStream = listStream.flatMap((Function, Stream>) i -> i.stream());
        //将Stream流转换成List集合
        List collect1 = rStream.collect(Collectors.toList());
        System.out.println("集合大小：" + collect1.size());
        collect1.stream().forEach(i -> System.out.println(i));

        System.out.println("findFirst() 获取到第一个元素");
        User user = userList.stream().limit(1).collect(Collectors.toList()).get(0);
        System.out.println(user);
        User user1 = userList.stream().findFirst().get();
        System.out.println(user1);

        /**
         * 数值类型流
         */
        IntStream.of(new int[]{1, 2, 3, 4}).forEach(i -> System.out.println(i));
        IntStream.range(1, 3).forEach(i -> System.out.println(i));//包前不包后
        IntStream.rangeClosed(1, 3).forEach(i -> System.out.println(i));

        /**
         * Stream流转换成其他类型
         */
        //转String
        String s = Arrays.stream(arr).collect(Collectors.joining()).toString();
        System.out.println("转String:" + s);
        //转String数组
        String[] objects = Arrays.stream(arr).toArray(String[]::new);
        System.out.println("转String数组:" + Arrays.toString(objects));
        //转list
        List collect2 = Arrays.stream(arr).collect(Collectors.toList());
        System.out.println("转list：");
        collect2.forEach(s1 -> System.out.println(s1));
        //转set
        Set collect3 = Arrays.stream(arr).collect(Collectors.toSet());
        System.out.println("转set:");
        collect3.forEach(s1 -> System.out.println(s1));

        /**
         *  stream和parallelStream的区别：
         *  stream是串行化执行，parallelStream是并行执行的（可以替代多线程）
         *  stream是顺序执行的，parallelStream是乱序执行的
         *  parallelStream.forEachOrdered则是顺序执行的
         *  parallelStream的处理效率要高于stream
         */
        String a[] = {"1","2","3","4","5","6"};
        List ints = Arrays.asList(a);
        System.out.println("stream排序");
        ints.stream().forEach(x -> System.out.print(x));// 有序
        System.out.println("parallelStream排序");
        ints.parallelStream().forEach(x -> System.out.print(x));// 无序
        System.out.println("parallelStream.forEachOrdered排序");
        ints.parallelStream().forEachOrdered(x -> System.out.print(x));// 有序

注意：

1.stream的forEach不同于普通的for循环是前者不能在循环体内部使用continue和break，但是可以使用return，它的功能等同于普通for循环的continue