Java8 Stream学习（一）

1.什么是流

• java8提供的对集合数据进行处理的一种方式
• 流中的元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等

2. 流的特点

• 一个流只能使用一次
• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

3.串行流和并行流

• 创建串行流：stream()

• 创建并行流：parallelStream()

4. 串行流和并行流的性能差异

5.流的常用操作

package cyc.java.stream;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Java8StreamAPI
{
    public static void main(String[] args)
    {
        /****************** 获取流 ******************/

        // list
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        // 数组
        String[] arr = {"a", "b", "c"};
        String[] array2 = new String[] {};
        String[] array3 = new String[6];
        // 使用Arrays静态方法stream转换成流
        Arrays.stream(arr);

        // 值，直接将值转变成流对象
        Stream<String> stream = Stream.of("a", "b", "c");

        // Map，获取entrySet调用stream方法
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.entrySet().stream();

        // 文件
        /*
         * try(Stream lines =
         * Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){
         * //可对lines做一些操作 }catch(IOException e){ }
         */

        /****************** stream方法 ******************/

        /**
         * @decription 过滤器filter
         * @param 一个返回true或者false的lambda表达式
         * @return 筛选出返回结果为true的元素
         */

        int cout1 = (int)Arrays.stream(arr).filter(a ->
        {
            return a.equals("c");
        }).count();

        /**
         * @description 去重
         * @return 去除重复的元素后的流
         */
        Arrays.stream(arr).distinct();

        /**
         * @decription 截取前n个元素
         * @return 流
         */
        Arrays.stream(arr).limit(2);

        /**
         * @decription 跳过前n个元素
         */
        Arrays.stream(arr).skip(1l);

        /**
         * @decription 映射
         */

        int cout2 = (int)Arrays.stream(arr).map(a ->
        {
            List<String> li = new ArrayList<>();
            li.add(a);
            return li.toArray();
        }).flatMap(Arrays::stream).map(ar ->
        {
            System.out.println(ar);
            return ar;
        }).count();
        System.out.println(cout2);

        /**
         * @description 是否匹配任意元素
         */

        Arrays.stream(arr).anyMatch(a ->
        {
            return a.equals("b");
        });

        /**
         * @description 是否匹配所有元素
         */

        Arrays.stream(arr).allMatch(a ->
        {
            return a.equals("b");
        });

        /**
         * @description 是否所有元素都不匹配
         */

        Arrays.stream(arr).noneMatch(a ->
        {
            return a.equals("b");
        });

        /**
         * @description 从流中返回任意元素，返回结果放在Optional对象中(实测怎么感觉就是findFirst())
         */
        Optional<String> op1 = Arrays.stream(arr).findAny();

        /**
         * @description 返回第一个元素，返回结果放在Optional对象中
         */

        Optional<String> op2 = Arrays.stream(arr).findFirst();
        op2.ifPresent((a) ->
        {
            System.out.println(a);
        });
        op2.isPresent();
        op2.orElse("dd");

        /**
         * @description reduce 自定义lambda表达式求和 以
         *              identity为初始值，对流中的所有元素执行lambda表达式求和
         */

        String result = Arrays.stream(arr).reduce("begin:", (a, b) ->
        {
            return a + b;
        });

        /****************** stream数值流 ******************/
        // 将普通流转换成数值流

        Arrays.stream(arr).mapToInt(a ->
        {
            return Integer.valueOf(a);
        });
        Arrays.stream(arr).mapToDouble(a ->
        {
            return Double.valueOf(a);
        });
        Arrays.stream(arr).mapToLong(a ->
        {
            return Long.valueOf(a);
        });

        /**
         * @description 数值流计算方法 max min sum
         */

        /****************** stream收集器 ******************/
        // 规约： 求最值、求和、求平均值
        /**
         * @description:求数量
         */

        long num1 = Arrays.stream(arr).count(); // 使用收集器 long num2 =
        stream.collect(Collectors.counting());

        /**
         * @description:求最值,最大值最小值都类似，比较方法有comparingDouble、comparingInt、comparingLong、甚至自定义
         */
        Optional<String> res = Arrays.stream(arr).collect(Collectors.maxBy(Comparator.comparingDouble(a ->
        {
            String a1 = a;
            char[] ch = a1.toCharArray();
            return Double.valueOf((int)ch[0]);
        })));
        System.out.println(res.get());
        /**
         * @description:求和 方法也很多，类似求最值
         */

        int sum = Arrays.stream(arr).collect(Collectors.summingInt(a ->
        {
            String a1 = a;
            char[] ch = a1.toCharArray();
            return Integer.valueOf((int)ch[0]);
        }));

        /**
         * @description:求平均值,方法也很多，类似求最值
         */

        double avg = Arrays.stream(arr).collect(Collectors.averagingInt(a ->
        {
            String a1 = a;
            char[] ch = a1.toCharArray();
            return Integer.valueOf((int)ch[0]);
        }));

        /**
         * Collectors.summarizingInt函数能一次性将最值、均值、总和、元素个数全部计算出来，并存储在对象IntSummaryStatisics中。
         * 可以通过该对象的getXXX()函数获取这些值。
         */

        /****************** stream连接字符串 ******************/
        /**
         * @description:连接字符串，默认中间无连接符，可以在joining方法中加入连接符 joining("_")
         */
        String str = Arrays.stream(arr).collect(Collectors.joining());

        /**
         * @description:自定义规约操作
         * @param:1.初始值
         * @param:2.对流中的数据进行处理
         * @param:3.对处理后的元素进行自定义规约操作
         */
        Arrays.stream(arr).collect(Collectors.reducing("begin:", a ->
        {
            return a;
        }, (a, b) ->
        {
            return a + b;
        }));

        /****************** stream分组 ******************/
        /**
         * @description:将元素按指定规则分组
         */
        Map<String, List<String>> res1 = Arrays.stream(arr).collect(Collectors.groupingBy(a ->
        {
            if ("a".equals(a))
            {
                return "isA";
            }
            else if ("b".equals(a))
            {
                return "isB";

            }
            else
            {
                return "isOthers";
            }
        }));
        // 可以在collect方法中添加参数，如再次分组或者统计每个分组的数量
        Map<String, Long> res2 = Arrays.stream(arr).collect(Collectors.groupingBy((a) ->
        {
            if ("a".equals(a))
            {
                return "isA";
            }
            else if ("b".equals(a))
            {
                return "isB";

            }
            else
            {
                return "isOthers";
            }
        }, Collectors.counting()));

        System.out.println("s");
    }

}