Java8 新特性Stream 的学习和使用方法

流（Stream）

流是java 8 中新引入的特性，用来处理集合中的数据，Stream 是一个来自数据源的元素队列并支持聚合操作。

Java 中 Stream 不会存储元素。
数据源流的来源。可以是集合，数组，I/O channel，产生器generator 等。
聚合操作类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted等。

Stream操作还有几个特征：

只遍历一次。我们可以把流想象成一条流水线，流水线的源头是我们的数据源(一个集合)，数据源中的元素依次被输送到流水线上，我们可以在流水线上对元素进行各种操作。一旦元素走到了流水线的另一头，那么这些元素就被“消费掉了”，我们无法再对这个流进行操作。当然，我们可以从数据源那里再获得一个新的流重新遍历一遍。
Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，通过访问者模式(Visitor)实现。

流的使用

流的使用过程有三步：

获取流；
中间操作，得到一个新的流；
最终操作，获取结果。

获取流

流有两种：

stream() ：创建串行流。
parallelStream() ：创建并行流。

并行流的特点就是将一个大任务切分成多个小任务，无序一起执行，当然如果我们需要顺序输出的话可以使用forEachOrdered，速度会比串行流快一些。它通过默认的ForkJoinPool,可能提高你的多线程任务的速度。

从集合获取流

List<FarmEntity> list = service.getBySql(sql1);

Stream<FarmEntity> stream = list.stream();

从数组获取流

String[] arrays = {"你", "我", "她"};

Stream<String> stream = Arrays.stream(arrays);

从值获取流

Stream<String> stream = Stream.of("你", "我", "她");

从文件获取流

try {

    Stream<String> file =Files.lines(Paths.get("D:\\zhangkai\\WorkSpace\\Git\\hexo\\_config.yml"));

    file.forEach(System.out::println);

} catch (Exception e) {

}

使用NIO获取流，可以打印出文本文件的内容。

流的操作

filter 过滤

filter函数接收一个Lambda表达式作为参数，该表达式返回boolean，在执行过程中，流将元素逐一输送给filter，并筛选出执行结果为true的元素。

String[] strings = {"珊瑚", "阳光", "细腻", "冷暖", "阳光"};

Arrays.stream(strings).filter(n -> n.startsWith("冷")).forEach(System.out::print);

distinct 去重

Arrays.stream(strings).distinct().forEach(System.out::print);

limit 截取

截取前面两个单位：

Arrays.stream(strings).limit(2).forEach(System.out::print);

skip 跳过

和上面的limit 相反，跳过前面两个

map 映射

map 方法用于映射每个元素到对应的结果。

给每个词语后面加个 “兮”

        Arrays.stream(strings).map(s -> s + "兮").forEach(System.out::println);

输出：

珊瑚兮

阳光兮

细腻兮

冷暖兮

阳光兮

sorted 排序

//Arrays.stream(strings).sorted((x, y) -> x.compareTo(y)).forEach(System.out::println);

Arrays.stream(strings).sorted(String::compareTo).forEach(System.out::println);

输出：

冷暖

珊瑚

细腻

阳光

阳光

java8 以前排序：

 // Before Java 8 sorted

        System.out.println("java8以前排序：");

        List<String> list1 = Arrays.asList(strings);

        list1.sort(new Comparator<String>() {

            @Override

            public int compare(String o1, String o2) {

                return o1.compareTo(o2);

            }

        });

        System.out.printf("java8 以前的排序：%s%n", list1);

输出：

java8以前排序：

java8 以前的排序：[冷暖, 珊瑚, 细腻, 阳光, 阳光]

HashMap根据value值排序key：

Map<String, Integer> map = new HashMap<>();

map.put("spring", 1);

map.put("summer", 2);

map.put("autumn", 3);

map.put("winter", 4);

map.entrySet().stream()

    .sorted((a, b) -> b.getValue().compareTo(a.getValue()))

    .forEach(a -> System.out.println(a.getKey()));

输出结果：

winter

autumn

summer

spring

统计

//统计

        List<Integer> list4 = Arrays.asList(1, 2, 3, 4, 1);

        IntSummaryStatistics stats = list4.stream().mapToInt((x) -> x).summaryStatistics();

        System.out.println("Highest number in List : " + stats.getMax());

        System.out.println("Lowest  number in List : " + stats.getMin());

        System.out.println("Sum of all numbers : " + stats.getSum());

        System.out.println("Average of all numbers : " + stats.getAverage());

运行结果：

Highest number in List : 4

Lowest  number in List : 1

Sum of all numbers : 11

Average of all numbers : 2.2

match 匹配

anyMatch用于判断流中是否存在至少一个元素满足指定的条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。
noneMatch与allMatch恰恰相反，它用于判断流中的所有元素是否都不满足指定条件
findAny能够从流中随便选一个元素出来，它返回一个Optional类型的元素。

 Boolean result1 = Arrays.stream(strings).allMatch(s -> s.equals("java"));

        System.out.println(result1);

        Boolean reslut2 = Arrays.stream(strings).noneMatch(s -> s.equals("java"));

        System.out.println(reslut2);

        //随机读取一个

        Optional<String> getResult = Arrays.stream(strings).findAny();

        System.out.println(getResult);

        System.out.printf("获取Optional中的值：%s%n", getResult.get());

运行结果：

false

true

Optional[冷暖]

获取Optional中的值：冷暖

Optional是Java8新加入的一个容器，这个容器只存1个或0个元素，它用于防止出现NullpointException，它提供如下方法：

isPresent() 判断容器中是否有值。
ifPresent(Consume lambda) 容器若不为空则执行括号中的Lambda表达式。
T get() 获取容器中的元素，若容器为空则抛出NoSuchElement异常。
T orElse(T other) 获取容器中的元素，若容器为空则返回括号中的默认值。

reduce 归约

求和：

//归约

        //第一种方法求和

        String connectStrings = Arrays.stream(strings).reduce("", (x, y) -> x + y);

        System.out.println(connectStrings);

        // 第二种方法求和

        String connectStrings1 = Arrays.stream(strings).reduce("", TestStream::getConnectStrings);

        System.out.println(connectStrings1);

getConnectStrings方法：

/**

* Connect Strings

* @param s1 参数1

* @param s2 参数2

* @return java.lang.String

*/

private static String getConnectStrings(String s1, String s2) {

    return s1 + s2;

}

reduce中第一个参数是初始值，第二个参数是方法引用。

数据流

StreamAPI提供了三种数值流：IntStream、DoubleStream、LongStream，也提供了将普通流转换成数值流的三种方法：mapToInt、mapToDouble、mapToLong。

每种数值流都提供了数值计算函数，如max、min、sum等。

下面使用 mapToInt 为例：

        String[] numberStrings = {"1", "2", "3"};

        // mapToInt参数： 需要转换成相应的类型方法

        IntStream intStream = Arrays.stream(numberStrings).mapToInt(Integer::valueOf);

        //使用对应的 Optional 接收

        OptionalInt optionalNumber = intStream.max();

        // 取值，给默认值 0，为空结果为0

        System.out.printf("numberStrings's max number is: %s%n", optionalNumber.orElse(0));

打印结果：

numberStrings's max number is: 3

由于数值流可能为空，并且给空的数值流计算最大值是没有意义的，因此max函数返回OptionalInt，它是Optional的一个子类，能够判断流是否为空，并对流为空的情况作相应的处理。所以可以直接使用 OptionalInt.getAsInt()获取容器的值。

为空的话捕捉异常：

java.util.NoSuchElementException: No value present

	at java.util.OptionalInt.getAsInt(OptionalInt.java:118)

	at com.wuwii.test.TestStream.main(TestStream.java:105)

此外，mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为：OptionalInt、OptionalDouble、OptionalLong。

Collectors 集合归约

将流转换成集合和聚合元素。

 //Collectors 集合归约

        //  toList

        List<String> list2 = Arrays.stream(strings).collect(Collectors.toList());

        // Get String by connected

        String connectStrings2 = Arrays.stream(strings).collect(Collectors.joining(","));

        System.out.printf("Collectors toList: %s , Conlletors Join Strings: %s%n", list2, connectStrings2);

打印结果：

Collectors toList: [冷暖, 珊瑚, 细腻, 阳光, 阳光] , Conlletors Join Strings: 冷暖,珊瑚,细腻,阳光,阳光

后面补充: Collectors中还有一个groupingBy() 方法，比较实用，例子来源网上使用Java 8中的Stream

groupingBy()表示根据某一个字段或条件进行分组，返回一个Map，其中key为分组的字段或条件，value默认为list，groupingByConcurrent()是其并发版本：

Map<String, List<Locale>> countryToLocaleList = Stream.of(Locale.getAvailableLocales())

    .collect(Collectors.groupingBy(l -> l.getDisplayCountry()));

如果groupingBy()分组的依据是一个bool条件，则key的值为true/false，此时与partitioningBy()等价，且partitioningBy()的效率更高：

// predicate

Map<Boolean, List<Locale>> englishAndOtherLocales = Stream.of(Locale.getAvailableLocales())

    .collect(Collectors.groupingBy(l -> l.getDisplayLanguage().equalsIgnoreCase("English")));

// partitioningBy

Map<Boolean, List<Locale>> englishAndOtherLocales2 = Stream.of(Locale.getAvailableLocales())

    .collect(Collectors.partitioningBy(l -> l.getDisplayLanguage().equalsIgnoreCase("English")));

groupingBy()提供第二个参数，表示downstream，即对分组后的value作进一步的处理：

// 返回set，而不是list：

Map<String, Set<Locale>> countryToLocaleSet = Stream.of(Locale.getAvailableLocales())

          .collect(Collectors.groupingBy(l -> l.getDisplayCountry(), Collectors.toSet()));

// 返回value集合中元素的数量：

Map<String, Long> countryToLocaleCounts = Stream.of(Locale.getAvailableLocales())

          .collect(Collectors.groupingBy(l -> l.getDisplayCountry(), Collectors.counting()));

// 对value集合中的元素求和：

Map<String, Integer> cityToPopulationSum = Stream.of(cities)

        .collect(Collectors.groupingBy(City::getName, Collectors.summingInt(City::getPopulation)));

// 对value的某一个字段求最大值，注意value是Optional的：

Map<String, Optional<City>> cityToPopulationMax = Stream.of(cities)

        .collect(Collectors.groupingBy(City::getName,

            Collectors.maxBy(Comparator.comparing(City::getPopulation))));

// 使用mapping对value的字段进行map处理：

Map<String, Optional<String>> stateToNameMax = Stream.of(cities)

    .collect(Collectors.groupingBy(City::getState, Collectors.mapping(City::getName,

        Collectors.maxBy(Comparator.comparing(String::length)))));

Map<String, Set<String>> stateToNameSet = Stream.of(cities)

.collect(Collectors.groupingBy(City::getState,

    Collectors.mapping(City::getName, Collectors.toSet())));

// 通过summarizingXXX获取统计结果：

Map<String, IntSummaryStatistics> stateToPopulationSummary = Stream.of(cities)

    .collect(Collectors.groupingBy(City::getState, Collectors.summarizingInt(City::getPopulation)));

reducing()

// 可以对结果作更复杂的处理，但是reducing()却并不常用：

Map<String, String> stateToNameJoining = Stream.of(cities)

    .collect(Collectors.groupingBy(City::getState, Collectors.reducing("", City::getName,

        (s, t) -> s.length() == 0 ? t : s + ", " + t)));

// 比如上例可以通过mapping达到同样的效果：

Map<String, String> stateToNameJoining2 = Stream.of(cities)

        .collect(Collectors.groupingBy(City::getState,

            Collectors.mapping(City::getName, Collectors.joining(", ")

        )));

完整代码

package com.wuwii.test;

import java.nio.file.Files;

import java.nio.file.Paths;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.IntStream;

import java.util.stream.Stream;

public class TestStream {

    public static void main(String[] args) {

        // Get Stream from file

        System.out.println("读取文件：");

        try {

            Stream<String> file = Files.lines(Paths.get("D:\\zhangkai\\WorkSpace\\Git\\hexo\\_config.yml"));

            file.forEach(System.out::println);

        } catch (Exception e) {

        }

        // Get Stream by Filter

        String[] strings = {"珊瑚", "阳光", "细腻", "冷暖", "阳光"};

        Arrays.stream(strings).filter(n -> n.startsWith("冷")).forEach(System.out::print);

        // Get Stream by Distinct

        System.out.println("去重:");

        Arrays.stream(strings).distinct().forEach(System.out::print);

        // Get Stream by Limit

        System.out.println("截取:");

        Arrays.stream(strings).limit(2).forEach(System.out::print);

        // Get Stream by Skip

        System.out.println("跳过:");

        Arrays.stream(strings).skip(2).forEach(System.out::print);

        // Java 8 sorted

        System.out.println("排序：");

        //Arrays.stream(strings).sorted((x, y) -> x.compareTo(y)).forEach(System.out::println);

		Arrays.stream(strings).sorted(String::compareTo).forEach(System.out::println);

        // Before Java 8 sorted

        System.out.println("java8以前排序：");

        List<String> list1 = Arrays.asList(strings);

        list1.sort(new Comparator<String>() {

            @Override

            public int compare(String o1, String o2) {

                return o1.compareTo(o2);

            }

        });

        System.out.printf("java8 以前的排序：%s%n", list1);

        //Handle map

        System.out.println("map 映射：");

        Arrays.stream(strings).map(s -> s + "兮").forEach(System.out::println);

        //Match

        Boolean result1 = Arrays.stream(strings).allMatch(s -> s.equals("java"));

        System.out.println(result1);

        Boolean reslut2 = Arrays.stream(strings).noneMatch(s -> s.equals("java"));

        System.out.println(reslut2);

        //findAny to find anyone

        Optional<String> getResult = Arrays.stream(strings).findAny();

        System.out.println(getResult);

        System.out.printf("获取Optional中的值：%s%n", getResult.get());

        //统计

        List<Integer> list4 = Arrays.asList(1, 2, 3, 4, 1);

        IntSummaryStatistics stats = list4.stream().mapToInt((x) -> x).summaryStatistics();

        System.out.println("Highest number in List : " + stats.getMax());

        System.out.println("Lowest  number in List : " + stats.getMin());

        System.out.println("Sum of all numbers : " + stats.getSum());

        System.out.println("Average of all numbers : " + stats.getAverage());

        //归约

        //第一种方法求和

        String connectStrings = Arrays.stream(strings).reduce("", (x, y) -> x + y);

        System.out.println(connectStrings);

        // 第二种方法求和

        String connectStrings1 = Arrays.stream(strings).reduce("", TestStream::getConnectStrings);

        System.out.println(connectStrings1);

        //Collectors 集合归约

        //  toList

        List<String> list2 = Arrays.stream(strings).collect(Collectors.toList());

        // Get String by connected

        String connectStrings2 = Arrays.stream(strings).collect(Collectors.joining(","));

        System.out.printf("Collectors toList: %s , Conlletors Join Strings: %s%n", list2, connectStrings2);

        String[] numberStrings = {"1", "2", "3"};

        // mapToInt参数： 需要转换成相应的类型方法

        IntStream intStream = Arrays.stream(numberStrings).mapToInt(Integer::valueOf);

        //使用对应的 Optional 接收

        OptionalInt optionalNumber = intStream.max();

        // 取值，给默认值 0，为空结果为0

        System.out.printf("numberStrings's max number is: %s%n", optionalNumber.orElse(0));

    }

    /**

     * 拼接字符串

     *

     * @param s1 参数1

     * @param s2 参数2

     * @return java.lang.String

     */

    private static String getConnectStrings(String s1, String s2) {

        return s1 + s2;

    }

}