-Java8 Stream简介

Stream是Java 8新增的重要特性, 它提供函数式编程支持并允许以管道方式操作集合. 流操作会遍历数据源, 使用管道式操作处理数据后生成结果集合, 这个过程通常不会对数据源造成影响.

lambda表达式

使用Stream进行函数式编程时经常需要将操作作为参数传入流方法中, lambda表达式是最适合完成这一任务的工具.

import java.util.stream.Collectors;
List list = Arrays.asList(-1,0,1,2,3).stream()
                .filter(x -> x>0)
                .collect(Collectors.toList());

上述示例中filter的参数x -> x>0即为一个lambda表达式.

lambda表达式语法通常为(args)->{body}, 返回值的类型自动推定:

(int a, int b) -> { 
    if (a>b) {
        return a+b;
    } 
    else {
        return a * b;
    }
}

参数的类型也可以自动推定:

(a, b) -> {
  return a+b;
}

在只有一条语句的情况下{}可省略, 返回值类型与语句主体表达式一致.

(a, b) -> a+b

允许使用空参数:

() -> {System.out.println("Hello World!")}

lambda表达式可以作为Runable接口的实现:

Runnable r = () -> System.out.println("Hello World");

流的创建

可以使用集合类的stream()或者parallelStream()方法创建流:

import java.util.stream.Stream;
Stream<String> s1 = Arrays.asList("a","b","c").stream();
Stream<String> s2 = Arrays.asList("a","b","c").parallelStream();

java.util.stream.Stream是一个interface, 各种管道中间操作的返回值都是它的实现类, 这允许我们方便地进行参数传递.

Stream的静态方法of()也可以用来创建流:

Stream.of(new int[]{1,2,3});

Arrays也提供了创建流的静态方法stream():

Arrays.stream(new int[]{1,2,3})

一些类也提供了创建流的方法:

IntStream.range(start, stop);
BufferedReader.lines();
Random.ints();

中间操作

流操作是惰性执行的, 中间操作会返回一个新的流对象, 当执行终点操作时才会真正进行计算.下面介绍流的中间操作. 除非传入的操作函数有副作用, 函数本身不会对数据源进行任何修改.

distinct

distinct保证数据源中的重复元素在结果中只出现一次, 它使用equals()方法判断两个元素是否相等.

List<String> list = Stream.of("a","b","c","b")
        .distinct()
        .collect(Collectors.toList());

filter

filter根据传入的断言函数对所有元素进行检查, 只有使断言函数返回真的元素才会出现在结果中. filter不会对数据源进行修改.

List<Integer> list = IntStream.range(1,10).boxed()
        .filter( i -> i % 2 == 0)
        .collect(Collectors.toList());

java.util.Objects提供了空元素过滤的工具:

List<MyItem> list = items.stream()
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

map

map方法根据传入的mapper函数对元素进行一对一映射, 即数据源中的每一个元素都会在结果中被替换(映射)为mapper函数的返回值.

List<String> list = Stream.of('a','b','c')
        .map( s -> s.hashCode())
        .collect(Collectors.toList());

flatMap

与map不同flatMap进行多对一映射, 它要求若数据源的元素类型为R, 则mapper函数的返回值必须为Stream<R>.

flatMap会使用mapper函数将数据源中的元素一一映射为Stream对象, 然后把这些Stream拼装成一个流.因此我们可以使用flatMap进行合并列表之类的操作:

List<Integer> list = Stream.of(
        Arrays.asList(1),
        Arrays.asList(2, 3),
        Arrays.asList(4, 5, 6)
    )
    .flatMap(l -> l.stream())
    .collect(Collectors.toList());

peek

peek方法会对数据源中所有元素进行给定操作, 但在结果中仍然是数据源中的元素. 通常我们利用操作的副作用, 修改其它数据或进行输入输出.

List<String> list = Stream.of('a','b','c')
        .map(s -> System.out.println(s))
        .collect(Collectors.toList());

sorted

sorted方法用于对数据源进行排序:

List<Integer> list = Arrays.asList(1,2,3,4,5,6).stream()
        .sorted((a, b) -> a-b)
        .collect(Collectors.toList());

使用java.util.Comparator是更方便的方法, 默认进行升序排序:

class Item {
    int val;
    public Item(int val) { this.val = val; }
    public int getVal() { return val; }
}

List<Item> list = Stream.of(
        new Item(1),
        new Item(2), 
        new Item(3)
    )
    .sorted(Comparator.comparingInt(Item::getVal))
    .collect(Collectors.toList());

使用reversed()方法进行降序排序:

List<Item> list = Stream.of(
        new Item(1),
        new Item(2), 
        new Item(3)
    )
    .sorted(Comparator.comparingInt(Item::getVal).reversed())
    .collect(Collectors.toList());

limit

limit(int n)当流中元素数大于n时丢弃超出的元素, 否则不进行处理, 达到限制流长度的目的.

skip

skip(int)返回丢弃了前n个元素的流. 如果流中的元素小于或者等于n，则返回空的流

终点操作

reduce

reduce(accumulator)是最基本的终点操作之一, 操作函数accumulator接受两个参数x,y返回r.

reduce首先将数据源中的两个元素x1和x2传给accumulator得到r1, 然后将r1和x3传入得到r2. 如此进行直到处理完整个数据流.

reduce方法还可以接受一个参数代替x1作为起始值:

Integer sum = Stream.of(1,2,3,4,5).reduce(0, (x, y) -> x +y);
String concat = Stream.of("a", "b", "c", "d").reduce("", String::concat); 
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0)
    .reduce(Double.MAX_VALUE, Double::min); 

collect

collect是使用最广泛的终点操作, 也上文中多次出现:

List<String> list = Stream.of("a","b","c","b")
        .distinct()
        .collect(Collectors.toList())

toList()将流转换为List实例, 是最常见的用法, java.util.Collectors类中还有求和, 计算均值, 取最值, 字符串连接等多种收集方法.

forEach

forEach方法对流中所有元素执行给定操作, 没有返回值.

Stream.of(1,2,3,4,5).forEach(System.out::println);

其它

• count() 返回流中的元素数

• toArray(): 转换为数组

并发问题

除非显式地创建并行流, 否则默认创建的都是串行流.Collection.stream()为集合创建串行流,而Collection.parallelStream()创建并行流.

stream.parallel()方法可以将串行流转换成并行流,stream.sequential()方法将流转换成串行流.

流可以在非线程安全的集合上创建, 流操作不应该对非线程安全的数据源产生任何副作用, 否则将发生java.util.ConcurrentModificationException异常.

List<String> list = new ArrayList(Arrays.asList("a", "b"));
list = list.stream().forEach(s -> l.add("c")); // cause exception

对于线程安全的容器不会存在这个问题:

List<String> list = new CopyOnWriteArrayList<>(Arrays.asList("a", "b"));
list = list.stream().forEach(s -> l.add("c")); // safe operation

当然作者建议Stream操作不要对数据源进行任何修改. 当然, 修改其它数据或者输入输出是允许的:

list.stream().forEach(s -> {
    set.add(s); 
    System.out.println(s);
});

理想的管道操作应该是无状态且与访问顺序无关的. 无状态是指操作的结果只与输入有关, 下面即是一个有状态的操作示例:

State state = getState();
List<String> list = new ArrayList(Arrays.asList("a", "b"));
list = list.stream().map(s -> {
  if (state.isReady()) {
    return s;
  }
  else {
    return null;
  }
});

无状态的操作保证无论系统状态如何管道的行为不变, 与顺序无关则有利于进行并行计算.