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

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

Map<String, List<Locale>> countryToLocaleList = Stream.of(Locale.getAvailableLocales())
    .collect(Collectors.groupingBy(l -> l.getDisplayCountry()));

2. 如果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")));

3. 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;
    }

}