标签：实现 owa gen getname 情况 compare table 技术 重要
什么是惰性求值（惰性计算）
在编程语言理论中，惰性求值（英语：Lazy Evaluation），又译为惰性计算、懒惰求值，也称为传需求调用（call-by-need），是一个计算机编程中的一个概念，它的目的是要最小化计算机要做的工作。它有两个相关而又有区别的含意，可以表示为“延迟求值”和“最小化求值”，本条目专注前者，后者请参见最小化计算条目。除可以得到性能的提升外，惰性计算的最重要的好处是它可以构造一个无限的数据类型。
惰性求值的相反是及早求值(热情求值)，这是在大多数编程语言中随处可见的一种计算方式，例如：
int x = 1; String name = getUserName();
上面的表达式在绑定了变量后就立即求值，得到计算的结果。
Java中的惰性求值
以下Java代码就是惰性求值的范例。这段代码在定义 nameStream 这个流的时候，System.out.println 语句不会被立即执行。
public static void main(String[] args) { // 定义流 Stream<String> nameStream = Stream.of("Zebe", "July", "Yaha").filter(name -> { if (!name.isEmpty()) { System.out.println("过滤流，当前名称：" + name); return true; } return false; }); // 取出流的值，这时候才会调用计算 List<String> names1 = nameStream.collect(Collectors.toList()); // 流只能被使用一次，下面这行代码会报错，提示流已经被操作或者关闭了 List<String> names2 = nameStream.collect(Collectors.toList()); }
在jdk8的stream流编程里面，没有调用最终操作的时候，中间操作的方法都不会执行，这也是惰性求值。
stream编程主要是学习API的使用，但前提是学好lambda，基础好了，看这些方法定义非常简单，要是没有打好基础，你会有很多东西需要记忆。
内部迭代和外部迭代
一般来说，我们之前的编码方法，叫外部迭代，stream的写法叫内部迭代。内部迭代代码更加可读更加优雅，关注点是做什么（外部迭代关注是怎么样做），也很容易让我们养成编程小函数的好习惯！这点在编程习惯里面非常重要！看例子：
package com.dxz.stream; import java.util.stream.IntStream; public class StreamDemo1 { public static void main(String[] args) { int[] nums = { 1, 2, 3 }; // 外部迭代 int sum = 0; for (int i : nums) { sum += i; } System.out.println("结果1为：" + sum); // 使用stream的内部迭代 // map就是中间操作（返回stream的操作） // sum就是终止操作 int sum2 = IntStream.of(nums).map(StreamDemo1::doubleNum).sum(); System.out.println("结果2为：" + sum2); System.out.println("惰性求值就是终止没有调用的情况下，中间操作不会执行,下面的不会打印了"); IntStream.of(nums).map(StreamDemo1::doubleNum); } public static int doubleNum(int i) { System.out.println("执行了乘以2"); return i * 2; } }
结果：
结果1为：6 执行了乘以2 执行了乘以2 执行了乘以2 结果2为：12 惰性求值就是终止没有调用的情况下，中间操作不会执行,下面的不会打印了
操作类型概念要理清楚。有几个维度。
首先分为 中间操作 和 最终操作，在最终操作没有调用的情况下，所有的中级操作都不会执行。那么那些是中间操作那些是最终操作呢？ 简单来说，返回stream流的就是中间操作，可以继续链式调用下去，不是返回stream的就是最终操作。这点很好理解。
最终操作里面分为短路操作和非短路操作，短路操作就是limit/findxxx/xxxMatch这种，就是找了符合条件的就终止，其他的就是非短路操作。在无限流里面需要调用短路操作，否则像炫迈口香糖一样根本停不下来！
中间操作又分为 有状态操作 和 无状态操作，怎么样区分呢？ 一开始很多同学需要死记硬背，其实你主要掌握了状态这个关键字就不需要死记硬背。状态就是和其他数据有关系。我们可以看方法的参数，如果是一个参数的，就是无状态操作，因为只和自己有关，其他的就是有状态操作。如map/filter方法，只有一个参数就是自己，就是无状态操作；而distinct/sorted就是有状态操作，因为去重和排序都需要和其他数据比较，理解了这点，就不需要死记硬背了！
为什么要知道有状态和无状态操作呢？在多个操作的时候，我们需要把无状态操作写在一起，有状态操作放到最后，这样效率会更加高。
运行机制
我们可以通过下面的代码来理解stream的运行机制
package stream;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
/**
* 验证stream运行机制
*
* 1. 所有操作是链式调用, 一个元素只迭代一次
* 2. 每一个中间操作返回一个新的流. 流里面有一个属性sourceStage
* 指向同一个 地方,就是Head
* 3. Head->nextStage->nextStage->... -> null
* 4. 有状态操作会把无状态操作阶段,单独处理
* 5. 并行环境下, 有状态的中间操作不一定能并行操作.
*
* 6. parallel/ sequetial 这2个操作也是中间操作(也是返回stream)
* 但是他们不创建流, 他们只修改 Head的并行标志
*
* @author 晓风轻
*
*/
public class RunStream {
public static void main(String[] args) {
Random random = new Random();
// 随机产生数据
Stream<Integer> stream = Stream.generate(() -> random.nextInt())
// 产生500个 ( 无限流需要短路操作. )
.limit(500)
// 第1个无状态操作
.peek(s -> print("peek: " + s))
// 第2个无状态操作
.filter(s -> {
print("filter: " + s);
return s > 1000000;
})
// 有状态操作
.sorted((i1, i2) -> {
print("排序: " + i1 + ", " + i2);
return i1.compareTo(i2);
})
// 又一个无状态操作
.peek(s -> {
print("peek2: " + s);
}).parallel();
// 终止操作
stream.count();
}
/**
* 打印日志并sleep 5 毫秒
*
* @param s
*/
public static void print(String s) {
// System.out.println(s);
// 带线程名(测试并行情况)
System.out.println(Thread.currentThread().getName() + " > " + s);
try {
TimeUnit.MILLISECONDS