Java 8 Stream API Features Intermediate operations & Terminal operations

Stream API 中提供了findFirst()，orElse() 这样的 method, 这些 method 具体是做什么，可以看看文档：一目了然。

public static void main(String... args){
    List<Integer> values = Arrays.asList(11,22,33,44,55,60,75);
    System.out.println(values.stream()
                             .filter(i -> i%5 == 0)
                             .map(i -> i*2)
                             .findFirst()
                             .orElse(0)
    );
}

findFirst():  它是一个 terminal operator

/**
 * Returns an {@link Optional} describing the first element of this stream,
 * or an empty {@code Optional} if the stream is empty.  If the stream has
 * no encounter order, then any element may be returned.
 *
 * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
 * terminal operation</a>.
 *
 * @return an {@code Optional} describing the first element of this stream,
 * or an empty {@code Optional} if the stream is empty
 * @throws NullPointerException if the element selected is null
 */
Optional<T> findFirst();

orElse():

/**
 * Return the value if present, otherwise return {@code other}.
 *
 * @param other the value to be returned if there is no value present, may
 * be null
 * @return the value, if present, otherwise {@code other}
 */
public T orElse(T other) {
    return value != null ? value : other;
}

这里举这个 demo 是想说明什么问题呢，现在说 Java 比之前更 efficient ,为什么这么说呢，一点一点分析：我们 demo 示例里的 code 如果我们用 jdk1.7 来实现是这样的：

public static void main(String... args){
    List<Integer> values = Arrays.asList(11,22,33,44,55,60,75);
    System.out.println(values.stream()
                             .filter(i -> i%5 == 0)
                             .map(i -> i*2)
                             .findFirst()
                             .orElse(0)
    );

    int result = 0;
    for (int i: values) {
        if(i % 5 == 0){
            result = i*2;
            break;
        }
    }
    System.out.println(result);
}

两次 output 是相同的。

如果从表面上看，jdk1.7的 implementation 看上去好像比 Stream API 的 efficient 要高一点，因为 jdk1.7里第一个 value 满足条件后就直接 break 了，而 Stream API里呢，它是要先把所有的 number 都检查一遍，看能不能被5整除，再都乘以2，最后再去取第一个，如果找不到就是输出0. 反了？ 真的是这样么？ Stream API 反而让 Java 的 efficient 变低了，哈哈，不要被表面给欺骗了。其实不是这样的。Stream API 不会这么愚蠢的，可是从 code 上面看，java code 从上而下编译执行，应该就是像我刚说的那样很笨的 execute 才对，现在去推翻它。我们给上面的代码加点东西：

public static void main(String... args){
    List<Integer> values = Arrays.asList(11,22,33,44,55,60,75);
    System.out.println(values.stream()
                             .filter(Java8Demo::isDivisible)
                             .map(Java8Demo::mapDouble)
                             .findFirst()
                             .orElse(0)
    );
}

public static boolean isDivisible(int i){
    System.out.println("in isDvs: " + i);
    return i % 5 == 0;
}

public static int mapDouble(int i){
    System.out.println("in mapDouble: " + i);
    return i * 2;
}

看最终输出的：

in isDvs: 33
in isDvs: 44
in isDvs: 55
in mapDouble: 55
110

看到了吧，也是一样的，找到第一个满足条件的 number 后就不会再去往后面找了。很清楚吧。

解释一下：

我觉得下面这段英文解释的非常到位：

A stream supports two types of operations:

• Intermediate operations
• Terminal operations

Intermediate operations are also called lazy operations.

Terminal operations are also called eager operations.

A lazy operation does not process the elements until an eager operation is called on the stream.

An intermediate operation on a stream produces another stream.

Streams link operations to create a stream pipeline.

所以：

In the above code filter() and map() are all lazy operations. While reduce() is eager operation.

Stream API 的efficient 是要比 jdk1.7要高的，而且上面的 code 中使用的internal iteration，所以你 get 到 主要的 point 了么？

更多请参考这里：

http://docs.oracle.com/javase/8/docs/api/

http://www.java2s.com/Tutorials/Java_Streams/Tutorial/Streams/Intermediate_operations_Terminal_operations.htm