java8 stream 树_java stream的几种"另类"用法

除了用于简化对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 {

TreeNode left;

TreeNode right;

T value;

public TreeNode(TreeNode left, TreeNode right, T value) {

this.left = left;

this.right = right;

this.value = value;

}

public static TreeNode create(T value) {

return new TreeNode<>(null, null, value);

}

public TreeNode insertLeft(T value) {

this.left = create(value);

return this.left;

}

public TreeNode insertRight(T value) {

this.right = create(value);

return this.right;

}

public static Stream preIterateTree(TreeNode 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 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 walk(File file) {

if (file.isDirectory()) {

Stream 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);

}