除了用于简化对List, Set, Map等集合类型的操作外，java stream其实还可以抽象很多其他数据类型，然后在这一抽象的基础上做一些非常规操作。这些另类操作用好了，有时可以极大简化你的代码，当然也可能导致你被同事殴打。
计算斐波那契数
Fibonacci数是计算机教材中非常经典的几个示例之一，由于其天生的递归式定义，所以总是被当做介绍递归的入门问题。除了直接的递归式解法外，常见的还有迭代法和矩阵法。基于java stream的iterate API，我们可以在一条语句内用迭代法计算第n个Fibonacci数：
public long fib(long n) {
return Stream
.iterate(new int[]{0, 1}, pair -> new int[]{pair[1], pair[0] + pair[1]})
.skip(n)
.findFirst()
.get()[0];
}
蒙特卡罗法计算圆周率
Monte Carlo方法是一种巧妙而极具暴力美学的数值计算方法。这个以知名赌城作为名字的算法，将随机采样和统计结合用于解决各种计算问题。其中比较经典的一个例子，就是计算圆周率。
使用基本的平面几何知识我们就能很快推理出来，上图中的红色四分之一圆与正方形的面积比是pi/4。如果我们在正方形内均匀地随机打点，这些点落在圆内的概率也是pi/4。根据大数定律，只要我们打的点够多，最终圆内的点数和总点数之比将趋近于这个概率。假设我们在正方形内打了N个点，其中有n个落在圆内，则有n/N ≈ pi/4，转换下这个等式可以得到pi ≈ 4*n/N。
这一随机打点，采样，统计的过程，我们可以方便地用stream API构建出来：
public double pi(long N) {
Random random = new Random();
return Stream
.generate(() -> new double[]{random.nextDouble(), random.nextDouble())
.limit(N)
.filter(pair -> (pair[0]*pair[0] + pair[1]*pair[1]) < 1.0)
.count()*4.0 / N;
}
其中N是总的打点次数，N越大，则计算得到的pi精度也越高，当然这种计算方式的收敛速度会比其他算法慢很多。
前序遍历二叉树
二叉树是算法和数据结构课上的经典问题，但绝大部分职业程序员实际工作中直接使用的机会不多，反倒是容易出现在各种面试中。
其实面对树这种“复杂”，又存在递归的数据结构，我们完全可以将其遍历过程抽象成Stream。下次遇到面试官让你写二叉树前序遍历时，不妨试试这么写：
public static class TreeNode<T> {
TreeNode<T> left;
TreeNode<T> right;
T value;
public TreeNode(TreeNode<T> left, TreeNode<T> right, T value) {
this.left = left;
this.right = right;
this.value = value;
}
public static <T> TreeNode<T> create(T value) {
return new TreeNode<>(null, null, value);
}
public TreeNode<T> insertLeft(T value) {
this.left = create(value);
return this.left;
}
public TreeNode<T> insertRight(T value) {
this.right = create(value);
return this.right;
}
public static <T> Stream<T> preIterateTree(TreeNode<T> root) {
if (root == null) {
return Stream.empty();
} else {
return Stream.of(root)
.flatMap(node -> Stream.concat(
Stream.concat(Stream.of(root.value), preIterateTree(root.left)),
preIterateTree(root.right)));
}
}
}
使用这种方式做遍历的一大好处是分离了数据的“生产者”和“消费者”，而且得益于Stream API的抽象性，我们可以零成本地将原本消费Stream from List的代码移植到用来消费Stream from binary tree。
public static void main(String[] args) {
TreeNode<String> root = create("root");
root.insertLeft("left");
root.insertRight("right");
root.left.insertLeft("left-left");
root.right.insertRight("right-right");
// 打印所有节点的值
preIterateTree(root).forEach(System.out::println);
// 打印所有节点的字符串长度的和
System.out.println(preIterateTree(root).mapToInt(String::length).sum());
}
递归遍历目录下所有文件
工作中直接写二叉树的机会不多，但有一类树形数据却是我们每天都会与之打交道的，那就是文件系统。遍历目录，寻找符合某种特征的文件更是运维，排障等工作中的日常操作。和使用Steam做二叉树前序遍历一样，我们也可以用Stream来简化对目录的递归遍历：
public Stream<File> walk(File file) {
if (file.isDirectory()) {
Stream<File> subFiles = Arrays
.stream(file.listFiles())
.flatMap(this::walk);
return Stream.concat(subFiles, Stream.of(file));
} else {
return Stream.of(file);
}
}
在这个Stream的基础上，解决"根据寻找某个大小超过3MB，文件名中包含log的文件"之类的需求，也就显得非常简单了：
public static void main(String[] args) {
File home = new File("/Users/jizhilong/");
walk(home)
.filter(File::isFile)
.filter(file -> file.getName().contains("log"))
.filter(file -> file.length() > 3 * 1024 * 1024)
.findFirst()
.ifPresent(System.out::println);
}
更复杂的，寻找到所有包含了路径列表的文件，然后遍历这些文件中列出的目录，代码量也不会增大多少:
public static void main(String[] args) {
File home = new File("/Users/jizhilong/");
walk(home)
.filter(file -> file.getName().contains("file-list"))
.flatMap(file -> {
try {
return Files.lines(Paths.get(file.getAbsolutePath()));
} catch (IOException e) {
throw new UncheckedIOException(e);
}
})
.map(File::new)
.flatMap(DirectoryWalker::walk)
.findFirst()
.ifPresent(System.out::println);
}
