Java8新特性之Stream详解一

写了Lambda表达式的博客，怎么能少了对Stream的学习呢！接下来就将我所理解的Stream分享给大家，欢迎指出不足之处...

一、为什么要使用Stream？Stream是什么？在Java中该怎么用呢？

       (1)为什么要使用Stream?

       Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。

      (2) Stream是什么？

      首先，Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

      Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

    (3) Stream在Java中如何用呢？

     当我们使用Stream流时，一般包含三个步骤：获取一个数据源（source）→  数据转换 → 执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

    有多种方式产生一个流：

   ① 从Collection和数组中产生一个流：Collection.stream()           Collection.parallelStream()     

                                                               Arrays.stream(T array)      Stream.of(元素)

   ② 从BufferedReader中产生一个流： Collection.parallelStream()

二、详解流的使用：

(1) map的详解：map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。

例1：将数组中的字符串转为大写，求平方数

    @Test
    public void mapTest(){
        //将数组的字符串转为大写
        String[] wordList = new String[]{"Java","Android","OS","IOS"};
        List output = Arrays.stream(wordList).
                map(String::toUpperCase).
                collect(Collectors.toList());
        System.out.println(output);

        //平方数
        List nums = Arrays.asList(1,2,3,4);
        List squareNums = nums.stream().
                map(n -> n * n).
                collect(Collectors.toList());
        System.out.println(squareNums);
    }

注意：map(String::toUpperCase)这样的写法，这就是我们上篇博客讲的Lambda表达式的方法引用！诶，大家会不会觉得toUpperCase()这个方法不是String类中的静态方法，为啥可以这样调用呢？    

         map((str) -> str.toUpperCase()) 还原之前的Lambda表达式，toUpperCase()是String的成员方法，但是str会作为参数原封不动的传递给表达式str.toUpperCase()，这样就可以使用String::toUpperCase改写。

(2) filter 的详解：filter对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。

例2：过滤数组中的奇数，留下偶数

    @Test
    public void filterTest(){
        //留下偶数
        Integer[] nums = {1,2,3,4,5,6};
        Integer[] evens = Stream.of(nums).
                filter(n -> n%2 == 0).
                toArray(Integer[]::new);
        for (Integer even : evens) {
            System.out.println(even);
        }
    }

例3：将文件中的单词挑出，转为小写，排序并保证不重复

    @Test
    public void testDistinct() {
        try {
            //
            BufferedReader br = new BufferedReader(new FileReader("src/main/resource/test.txt"));
            //获取不重复的单词集合
            List wordList = br.lines().
                    flatMap(line -> Stream.of(line.split(" "))).
                    filter(word -> word.length() > 0).
                    map(String::toLowerCase).
                    distinct().
                    sorted().
                    collect(Collectors.toList());
            System.out.println(wordList);
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

(3) reduce的详解：这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

例4：字符串拼接，求最小值、最大值、过滤字符串拼接

    @Test
    public void reduce(){
        //字符串连接
        String concat1 = Stream.of("A","B","C","D").reduce("", (x,y) -> x.concat(y));
        String concat2= Stream.of("A","B","C","D").reduce("", String::concat);
        System.out.println(concat1 + concat2);

        //求最小值
        double minValue1 = Stream.of(-1.5,1.0,-3.0,-2.0).reduce(Double.MAX_VALUE, (x,y) -> Double.min(x, y));
        double minValue2 = Stream.of(-1.5,1.0,-3.0,-2.0).reduce(Double.MAX_VALUE, Double::min);
        System.out.println(minValue1);
        System.out.println(minValue2);

        //求最和
        int sumValue1 = Stream.of(1,2,3,4).reduce(0, (x,y) -> x + y);
        //原因：Integer类中的sum()方法完全可以替代两个数求和，参数类型、个数、返回值相同
        int sumValue2 = Stream.of(1,2,3,4).reduce(0, Integer::sum);
        System.out.println(sumValue1);
        System.out.println(sumValue2);

        //过滤字符串并拼接
        String concat = Stream.of("a","D","c","B","C","A").
                filter(s -> s.compareTo("Z") > 0).
                reduce("", String::concat);
        System.out.println(concat);
    }

(4) limit/skip的详解：limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素。

例5：留下数组中的偶数，并扔掉前4 个元素。

    @Test
    public void testLimitAndSkip() {
        List list = new ArrayList();
        for (int i = 1; i <= 20; i++) {
            list.add(i);
        }
        //limit()返回前n个元素，skip则是扔掉前n个元素
        List list1 = list.stream().
                filter(x -> x % 2 == 0).limit(10).skip(3).collect(Collectors.toList());
        System.out.println(list1);
    }

(5) sorted的详解：对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

    @Test
    public void testLimitAndSkip1() {
        Integer[] arr = new Integer[]{2,5,3,4,7,8,5,12,13,16,18,19,20};
        List list = Arrays.asList(arr);
        //limit()返回前n个元素，skip则是扔掉前n个元素
        List list1 = list.stream().
                sorted().       //先排序，从I小到大输出
                filter(x -> x % 2 == 0).
                limit(10).
                skip(3).
                collect(Collectors.toList());
        System.out.println(list1);
    }

(6) max/min/distinct的详解：保证Stream流集合中元素不重复，找出最大值、最小值等

    @Test
    public void testMax() {
        Integer[] arr = new Integer[]{2,5,3,4,7,8,5,12,13,16,18,19,20};
        List list = Arrays.asList(arr);
        //求最大值
        Integer maxValue = list.stream().
                max(Integer::compare).get();
        System.out.println(maxValue);

        //求最小值
        Integer minValue = list.stream().
                min(Integer::compare).get();
        System.out.println(minValue);
    }

还有forEach()，peek()，allMatch()，anyMatch()，noMatch()方法，自行研究和举例，这里不在一一赘述！

三、Stream总结：

   (1) Stream不是数据结构；

   (2) 它没有内部存储，它只是用操作管道从 source（数据结构、数组、generator function、IO channel）抓取数据；

   (3) 它也绝不修改自己所封装的底层数据结构的数据。例如 Stream 的 filter 操作会产生一个不包含被过滤元素的新 Stream，而不          是从 source 删除那些元素；

   (4) 所有 Stream 的操作必须以 lambda 表达式为参数；

   (5) 不支持索引访问；使用forEach()遍历数组，不可使用break，continue等关键字跳出循环；

   (6) 你可以请求第一个元素findFirst()，但无法请求第二个，第三个，或最后一个。不过请参阅下一项。

   (7) 很容易生成数组或者 List。

简单的讲解了一下Java8新特性之Stream语法，希望大家看过后有所收获，共同进步......

欢迎续学：Java8新特性之Stream学习二