先看一段代码
List<String> names = Arrays.asList("Jack", "Jill", "Nate", "Kara", "Kim", "Jullie", "Paul", "Peter");
List<String> subList = new ArrayList<>();
for(String name : names) {
if(name.length() == 4)
subList.add(name);
}
StringBuilder namesOfLength4 = new StringBuilder();
for(int i = 0; i < subList.size() - 1; i++) {
namesOfLength4.append(subList.get(i));
namesOfLength4.append(", ");
}
if(subList.size() > 1)
namesOfLength4.append(subList.get(subList.size() - 1));
System.out.println(namesOfLength4);
Stream API的历史
- 在java8引入
- 受益于lambda表达式
lambda表达式
接口常被用于传递代码，如sort接收一个Comparator接口用于给文件数组按名称排序
Arrays.sort(files, new Comparator<File>() {
@Override
public int compare(File f1, File f2) {
return f1.getName().compareTo(f2.getName());
}
});
不过上述代码需要new一个匿名类，而实际上sort()方法只应该知道如何对两个文件做比较即可，也就是说只要一个函数体，但是java却非要一个类！
Java 8提供只需要传入函数即可进行排序的方案，这就是lambda表达式：
Arrays.sort(files, (f1, f2) -> f1.getName().compareTo(f2.getName()));
上面的代码就自然多了，只需给出一个函数就能完成排序，(f1, f2)表示传入的参数，类型由java根据前面的files自行推断出来。如果无参数，则可以写成()。
函数式接口
接口替换为lambda表达式不是无条件的，要求该接口是所谓的函数式接口。
函数式接口就是一个具有一个方法的普通接口
可以用@FunctionalInterface来注解某个接口，强行要求某个接口为函数式接口，如果该接口含有2个方法，则编译会失败；默认方法与静态方法并不影响函数式接口的契约，可以任意使用：
@FunctionalInterface public interface Comparator<T> { int compare(T o1, T o2); default Comparator<T> reversed() { return Collections.reverseOrder(this); } public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() { return Collections.reverseOrder(); } ...... }
一句话，lambda表达式的目的是让大家编程不用再记忆类名和函数名，也不需要写参数类型，自然得传入需要的函数体即可。
比如这段sort()这段代码：
Arrays.sort(files, (f1, f2) -> f1.getName().compareTo(f2.getName()));
根本不需要记忆sort需要传入Comparator接口，也不需要记忆它的方法名称compare()，也不需要写参数类型File，方便吧。
Stream API
针对常见的集合数据处理，Java 8引入了一套新的类库，位于包java.util.stream下，称之为Stream API。Java 8给Collection接口增加默认方法，可以返回一个Stream。
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
在介绍Stream API之前，先看2个函数式接口，定义在包java.util.function下：
可以把它们想象提供和
Comparator类似的功能，就是提供一个函数体。Predicate叫谓词函数，测试输入是否满足条件，返回true或false；Function叫函数变换，将输入值1->1映射为另一个值。我们完全不用在意它们的接口名和方法名，只要知道它们的用途即可。
为便于举例，我们先定义一个简单的学生类Student，有name和score两个属性，如下所示，我们省略了getter/setter方法。
static class Student {
String name;
double score;
public Student(String name, double score) {
this.name = name;
this.score = score;
}
}
有一个学生列表:
List<Student> students = Arrays.asList(new Student[] {
new Student("zhangsan", 89d),
new Student("lisi", 89d),
new Student("wangwu", 98d) });
map 变换
返回学生的姓名列表：
List<String> nameList = students.stream()
.map(s->s.getName())
.collect(Collectors.toList());
map()接收一个Function接口，将学生变换为姓名；在collect做实际的处理，将学生对象挨个变换为姓名，并构成列表输出。
filter变换
过滤得分在90以上的学生：
List<Student> above90List = students.stream()
.filter(t->t.getScore()>90)
.collect(Collectors.toList());
filter()接收一个Predicate接口，过滤出90分以上的学生，在collect做实际的处理，构成列表输出。
复合变换
返回90分以上的学生姓名：
- 过滤：得到90分以上的学生列表
- 转换：将学生列表转换为姓名列表
List<String> above90Names = students.stream()
.filter(t->t.getScore()>90)
.map(s->s.getName())
.collect(Collectors.toList());
效率问题探讨
对复合变换，如果用旧方法，会在一次遍历中做过滤和变换操作：
List<String> above90NamesList = new ArrayList<>();
for (Student t : students) {
if (t.getScore() > 90) {
above90NamesList.add(t.getName());
}
}
而用Stream的方式看起来似乎先filter遍历了一次，map又遍历了一次，这样速度岂不会变慢？其实不会，java的Stream用了一种巧妙（tricky）的技术，实现了惰性求值，直到最后一步collect的时候才会做遍历操作。要向做到这一点，应该采用某种方式记录用户每一步的操作，当用户调用结束操作时将之前记录的操作叠加到一起在一次迭代中全部执行掉，具体实现可以看这篇文章：深入理解Java Stream流水线。
stream操作分类
前面讲到filter，map，collect都是stream的方法，但是它们是有所不同的，stream的操作分为2类中间操作(intermediate operations)和结束操作(terminal operations)，归纳如下：
| 操作类型 | 接口方法 |
|---|---|
| 中间操作 | concat() distinct() filter() flatMap() limit() map() peek() skip() sorted() parallel() sequential() unordered() |
| 结束操作 | allMatch() anyMatch() collect() count() findAny() findFirst()forEach() forEachOrdered() max() min() noneMatch() reduce() toArray() |
- 中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream，仅此而已。
- 结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以流水线的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。
更多的例子
不仅是List有stream操作，Set也有steam操作，下面是个例子：
Map<Integer, String> HOSTING = new HashMap<>();
HOSTING.put(1, "linode.com");
HOSTING.put(2, "heroku.com");
HOSTING.put(3, "digitalocean.com");
HOSTING.put(4, "aws.amazon.com");
//Map -> Set -> Stream -> Filter -> List
List<String> strings = HOSTING.entrySet().stream()
.filter(map -> "aws.amazon.com".equals(map.getValue()))
.map(map -> map.getValue())
.collect(Collectors.toList());
System.out.println(strings);
回到开头的例子
List<String> names = Arrays.asList("Jack", "Jill", "Nate", "Kara", "Kim", "Jullie", "Paul", "Peter");
// 给定一个名称集合，仅选择长度为 4 的名称，然后通过逗号将它们连接起来。
System.out.println(
names.stream()
.filter(name -> name.length() == 4)
.collect(Collectors.joining(", ")));
问题：给定名为 numbers 的列表，此代码将计算大于 3 且小于 8 的偶数并将该数字乘以 2，然后输出结果。
int result = 0;
for(int e : numbers) {
if(e > 3 && e % 2 == 0 && e < 8) {
result += e * 2;
}
}
System.out.println(result);
System.out.println(
numbers.stream()
.filter(e -> e > 3)
.filter(e -> e % 2 == 0)
.filter(e -> e < 8)
.mapToInt(e -> e * 2)
.sum());
参考文献
Java Stream API入门篇
深入理解Java Stream流水线
计算机程序的思维逻辑 (91) - Lambda表达式
计算机程序的思维逻辑 (92) - 函数式数据处理 (上)
Java 8 Stream Tutorial
提倡使用有帮助的编码
