上节我们介绍了Lambda表达式和函数式接口，本节探讨它们的应用，函数式数据处理，针对常见的集合数据处理，Java 8引入了一套新的类库，位于包java.util.stream下，称之为Stream API，这套API操作数据的思路，不同于我们在38节到55节介绍的容器类API，它们是函数式的，非常简洁、灵活、易读，具体有什么不同呢？由于内容较多，我们分为两节来介绍，本节先介绍一些基本的API，下节讨论一些高级功能。
基本概念
接口Stream类似于一个迭代器，但提供了更为丰富的操作，Stream API的主要操作就定义在该接口中。 Java 8给Collection接口增加了两个默认方法，它们可以返回一个Stream，如下所示：
default Stream<E> stream() { return StreamSupport.stream(spliterator(), false);
}default Stream<E> parallelStream() { return StreamSupport.stream(spliterator(), true);
}
stream()返回的是一个顺序流，parallelStream()返回的是一个并行流。顺序流就是由一个线程执行操作。而并行流背后可能有多个线程并行执行，与之前介绍的并发技术不同，使用并行流不需要显式管理线程，使用方法与顺序流是一样的。
下面，我们主要针对顺序流，学习Stream接口，包括其用法和基本原理，随后我们再介绍下并行流。先来看一些简单的示例。
基本示例
上节演示时使用了学生类Student和学生列表List<Student> lists，本节继续使用它们。
基本过滤
返回学生列表中90分以上的，传统上的代码一般是这样的：
List<Student> above90List = new ArrayList<>();for (Student t : students) { if (t.getScore() > 90) {
above90List.add(t);
}
}
使用Stream API，代码可以这样：
List<Student> above90List = students.stream() .filter(t->t.getScore()>90) .collect(Collectors.toList());
先通过stream()得到一个Stream对象，然后调用Stream上的方法，filter()过滤得到90分以上的，它的返回值依然是一个Stream，为了转换为List，调用了collect方法并传递了一个Collectors.toList()，表示将结果收集到一个List中。
代码更为简洁易读了，这种数据处理方式被称为函数式数据处理，与传统代码相比，它的特点是：
没有显式的循环迭代，循环过程被Stream的方法隐藏了
提供了声明式的处理函数，比如filter，它封装了数据过滤的功能，而传统代码是命令式的，需要一步步的操作指令
流畅式接口，方法调用链接在一起，清晰易读
基本转换
根据学生列表返回名称列表，传统上的代码一般是这样：
List<String> nameList = new ArrayList<>(students.size());for (Student t : students) {
nameList.add(t.getName());
}使用Stream API，代码可以这样：
List<String> nameList = students.stream() .map(Student::getName) .collect(Collectors.toList());
这里使用了Stream的map函数，它的参数是一个Function函数式接口，这里传递了方法引用。
基本的过滤和转换组合
返回90分以上的学生名称列表，传统上的代码一般是这样：
List<String> nameList = new ArrayList<>();for (Student t : students) { if (t.getScore() > 90) {
nameList.add(t.getName());
}
}
使用函数式数据处理的思路，可以将这个问题分解为由两个基本函数实现：
过滤：得到90分以上的学生列表
转换：将学生列表转换为名称列表
使用Stream API，可以将基本函数filter()和map()结合起来，代码可以这样：
List<String> above90Names = students.stream() .filter(t->t.getScore()>90) .map(Student::getName) .collect(Collectors.toList());
这种组合利用基本函数、声明式实现集合数据处理功能的编程风格，就是函数式数据处理。
代码更为直观易读了，但你可能会担心它的性能有问题。filter()和map()都需要对流中的每个元素操作一次，一起使用会不会就需要遍历两次呢？答案是否定的，只需要一次。实际上，调用filter()和map()都不会执行任何实际的操作，它们只是在构建操作的流水线，调用collect才会触发实际的遍历执行，在一次遍历中完成过滤、转换以及收集结果的任务。
像filter和map这种不实际触发执行、用于构建流水线、返回Stream的操作被称为中间操作(intermediate operation)，而像collect这种触发实际执行、返回具体结果的操作被称为终端操作(terminal operation)。Stream API中还有更多的中间和终端操作，下面我们具体来看下。
中间操作
除了filter和map，Stream API的中间操作还有distinct, sorted, skip, limit, peek, mapToLong, mapToInt, mapToDouble, flatMap等，我们逐个来看下。
distinct
distinct返回一个新的Stream，过滤重复的元素，只留下唯一的元素，是否重复是根据equals方法来比较的，distinct可以与其他函数如filter, map结合使用。
比如，返回字符串列表中长度小于3的字符串、转换为小写、只保留唯一的，代码可以为：
List<String> list = Arrays.asList(new String[]{"abc","def","hello","Abc"});
List<String> retList = list.stream()
.filter(s->s.length()<=3)
.map(String::toLowerCase)
.distinct()
.collect(Collectors.toList());
System.out.println(retList);
输出为：
[abc, def]
虽然都是中间操作，但distinct与filter和map是不同的，filter和map都是无状态的，对于流中的每一个元素，它的处理都是独立的，处理后即交给流水线中的下一个操作，但distinct不同，它是有状态的，在处理过程中，它需要在内部记录之前出现过的元素，如果已经出现过，即重复元素，它就会过滤掉，不传递给流水线中的下一个操作。
对于顺序流，内部实现时，distinct操作会使用HashSet记录出现过的元素，如果流是有顺序的，需要保留顺序，会使用LinkedHashSet。
sorted
有两个sorted方法：
Stream<T> sorted() Stream<T> sorted(Comparator<? super T> comparator)
它们都对流中的元素排序，都返回一个排序后的Stream，第一个方法假定元素实现了Comparable接口，第二个方法接受一个自定义的Comparator。
比如，过滤得到90分以上的学生，然后按分数从高到低排序，分数一样的，按名称排序，代码可以为：
List<Student> list = students.stream() .filter(t->t.getScore()>90) .sorted(Comparator.comparing(Student::getScore) .reversed() .thenComparing(Student::getName)) .collect(Collectors.toList());
这里，使用了Comparator的comparing, reversed和thenComparing构建了Comparator。
与distinct一样，sorted也是一个有状态的中间操作，在处理过程中，需要在内部记录出现过的元素，与distinct不同的是，每碰到流中的一个元素，distinct都能立即做出处理，要么过滤，要么马上传递给下一个操作，但sorted不能，它需要先排序，为了排序，它需要先在内部数组中保存碰到的每一个元素，到流结尾时，再对数组排序，然后再将排序后的元素逐个传递给流水线中的下一个操作。
skip/limit
它们的定义为：
Stream<T> skip(long n) Stream<T> limit(long maxSize)
skip跳过流中的n个元素，如果流中元素不足n个，返回一个空流，limit限制流的长度为maxSize。
比如，将学生列表按照分数排序，返回第3名到第5名，代码可以为：
List<Student> list = students.stream() .sorted(Comparator.comparing( Student::getScore).reversed()) .skip(2) .limit(3) .collect(Collectors.toList());
skip和limit都是有状态的中间操作。对前n个元素，skip的操作就是过滤，对后面的元素，skip就是传递给流水线中的下一个操作。limit的一个特点是，它不需要处理流中的所有元素，只要处理的元素个数达到maxSize，后面的元素就不需要处理了，这种可以提前结束的操作被称为短路操作。
peek
peek的定义为：
Stream<T> peek(Consumer<? super T> action)
它返回的流与之前的流是一样的，没有变化，但它提供了一个Consumer，会将流中的每一个元素传给该Consumer。这个方法的主要目的是支持调试，可以使用该方法观察在流水线中流转的元素，比如：
List<String> above90Names = students.stream() .filter(t->t.getScore()>90) .peek(System.out::println) .map(Student::getName) .collect(Collectors.toList());
mapToLong/mapToInt/mapToDouble
map函数接受的参数是一个Function<T, R>，为避免装箱/拆箱，提高性能，Stream还有如下返回基本类型特定流的方法：
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) IntStream mapToInt(ToIntFunction<? super T> mapper) LongStream mapToLong(ToLongFunction<? super T> mapper)
DoubleStream/IntStream/LongStream是基本类型特定的流，有一些专门的更为高效的方法。比如，求学生列表的分数总和，代码可以为：
double sum = students.stream() .mapToDouble(Student::getScore) .sum();
flatMap
flatMap的定义为：
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
它接受一个函数mapper，对流中的每一个元素，mapper会将该元素转换为一个流Stream，然后把新生成流的每一个元素传递给下一个操作。比如：
List<String> lines = Arrays.asList(new String[]{ "hello abc", "老马 编程"
});
List<String> words = lines.stream()
.flatMap(line -> Arrays.stream(line.split("\\s+")))
.collect(Collectors.toList());
System.out.println(words);
这里的mapper将一行字符串按空白符分隔为了一个单词流，Arrays.stream可以将一个数组转换为一个流，输出为：
[hello, abc, 老马, 编程]
可以看出，实际上，flatMap完成了一个1到n的映射。
针对基本类型，flatMap还有如下类似方法：
DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper)
终端操作
中间操作不触发实际的执行，返回值是Stream，而终端操作触发执行，返回一个具体的值，除了collect，Stream API的终端操作还有max, min, count, allMatch, anyMatch, noneMatch, findFirst, findAny, forEach, toArray, reduce等，我们逐个来看下。
max/min
max/min的定义为：
Optional<T> max(Comparator<? super T> comparator) Optional<T> min(Comparator<? super T> comparator)
它们返回流中的最大值/最小值，值的注意的是，它的返回值类型是Optional<T>，而不是T。
java.util.Optional是Java 8引入的一个新类，它是一个泛型容器类，内部只有一个类型为T的单一变量value，可能为null，也可能不为null。Optional有什么用呢？它用于准确地传递程序的语义，它清楚地表明，其代表的值可能为null，程序员应该进行适当的处理。
Optional定义了一些方法，比如：
// value不为null时返回truepublic boolean isPresent()// 返回实际的值，如果为null，抛出异常NoSuchElementExceptionpublic T get()// 如果value不为null，返回value，否则返回otherpublic T orElse(T other)// 构建一个空的Optional，value为nullpublic static<T> Optional<T> empty()// 构建一个非空的Optional, 参数value不能为nullpublic static <T> Optional<T> of(T value)// 构建一个Optional，参数value可以为null，也可以不为nullpublic static <T> Optional<T> ofNullable(T value)
在max/min的例子中，通过声明返回值为Optional，我们就知道，具体的返回值不一定存在，这发生在流中不含任何元素的情况下。
看个简单的例子，返回分数最高的学生，代码可以为：
Student student = students.stream() .max(Comparator.comparing(Student::getScore).reversed()) .get();
这里，假定students不为空。
count
count很简单，就是返回流中元素的个数。比如，统计大于90分的学生个数，代码可以为：
long above90Count = students.stream() .filter(t->t.getScore()>90) .count();
allMatch/anyMatch/noneMatch
这几个函数都接受一个谓词Predicate，返回一个boolean值，用于判定流中的元素是否满足一定的条件，它们的区别是：
allMatch: 只有在流中所有元素都满足条件的情况下才返回true
anyMatch: 只要流中有一个元素满足条件就返回true
noneMatch: 只有流中所有元素都不满足条件才返回true
如果流为空，这几个函数的返回值都是true。
比如，判断是不是所有学生都及格了(不小于60分)，代码可以为：
boolean allPass = students.stream() .allMatch(t->t.getScore()>=60);
这几个操作都是短路操作，都不一定需要处理所有元素就能得出结果，比如，对于allMatch，只要有一个元素不满足条件，就能返回false。
findFirst/findAny
它们的定义为：
Optional<T> findFirst() Optional<T> findAny()
它们的返回类型都是Optional，如果流为空，返回Optional.empty()。findFirst返回第一个元素，而findAny返回任一元素，它们都是短路操作。
随便找一个不及格的学生，代码可以为：
Optional<Student> student = students.stream()
.filter(t->t.getScore()<60)
.findAny();if(student.isPresent()){ // 不及格的学生....}
forEach
有两个foreach方法：
void forEach(Consumer<? super T> action)void forEachOrdered(Consumer<? super T> action)
它们都接受一个Consumer，对流中的每一个元素，传递元素给Consumer，区别在于，在并行流中，forEach不保证处理的顺序，而forEachOrdered会保证按照流中元素的出现顺序进行处理。
比如，逐行打印大于90分的学生，代码可以为：
students.stream() .filter(t->t.getScore()>90) .forEach(System.out::println);
toArray
toArray将流转换为数组，有两个方法：
Object[] toArray()<A> A[] toArray(IntFunction<A[]> generator)
不带参数的toArray返回的数组类型为Object[]，这经常不是期望的结果，如果希望得到正确类型的数组，需要传递一个类型为IntFunction的generator，IntFunction的定义为：
public interface IntFunction<R> {
R apply(int value);
}generator接受的参数是流的元素个数，它应该返回对应大小的正确类型的数组。
比如，获取90分以上的学生数组，代码可以为：
Student[] above90Arr = students.stream() .filter(t->t.getScore()>90) .toArray(Student[]::new);
Student[]::new就是一个类型为IntFunction<Student[]>的generator。
reduce
reduce代表归约或者叫折叠，它是max/min/count的更为通用的函数，将流中的元素归约为一个值，有三个reduce函数：
Optional<T> reduce(BinaryOperator<T> accumulator); T reduce(T identity, BinaryOperator<T> accumulator);<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
第一个基本等同于调用：
boolean foundAny = false;
T result = null;for (T element : this stream) { if (!foundAny) {
foundAny = true;
result = element;
} else
result = accumulator.apply(result, element);
}return foundAny ? Optional.of(result) : Optional.empty();
比如，使用reduce求
http://www.cnblogs.com/swiftma/p/7237442.html
延伸阅读
- 计算机程序的思维逻辑 (91) - Lambda表达式 2017-07-06 14:45:46.27
- 计算机程序的思维逻辑 (90) - 正则表达式 (下 - 剖析常见表达式) 2017-06-22 11:12:41.2
- 计算机程序的思维逻辑 (74) - 并发容器 - ConcurrentHashMap 2017-06-20 15:06:30.193
- 计算机程序的思维逻辑 (72) - 显式条件 2017-06-13 17:11:57.753
- 计算机程序的思维逻辑 (69) - 线程的中断 2017-06-05 15:06:19.833
- 计算机程序的思维逻辑 (87) - 类加载机制 2017-05-25 14:03:03.377
- 计算机程序的思维逻辑 (64) - 常见文件类型处理: 属性文件/CSV/EXCEL/HTML/压缩文件 2017-05-18 16:14:23.813
- 计算机程序的思维逻辑 (65) - 线程的基本概念 2017-05-17 15:49:17.517
- 计算机程序的思维逻辑 (83) - 并发总结 2017-04-27 11:43:59.693
- 计算机程序的思维逻辑 (82) - 理解ThreadLocal 2017-04-26 17:26:44.63
计算机程序的思维逻辑 (91) - Lambda表达式