从Java 8迁移到Java 9时的Stream处理异常问题

问题场景 #

以下代码在Java 8环境运行时，print方法会正常打印消息；但切换到Java 9及以上环境后，print方法完全不执行，控制台仅输出计数结果。

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.lang.*;

public class TestingJavaStream {
    public static void main(String[] args) {

        Message message = new Message();
        message.setName("Hello World!");

        Stream<Message> messageStream = streamNonnulls(Collections.singleton(message))
                .filter(not(Collection::isEmpty))
                .findFirst()
                .map(Collection::stream)
                .orElseGet(Stream::empty);

        System.out.println("Number of messages printed are " 
                + messageStream
                        .map(TestingJavaStream::print)
                        .count());
    }

    public static class Message {
        private String name;

        public String getName() {
            return this.name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Message other = (Message) obj;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }

        @Override
        public String toString() {
            return "Message [name=" + name + "]";
        }

    }

    @SafeVarargs
    public static <T> Stream<T> streamNonnulls(T... in) {
        return stream(in).filter(Objects::nonNull);
    }

    @SafeVarargs
    public static <T> Stream<T> stream(T... in) {
        return Optional.ofNullable(in)
                .filter(arr -> !(arr.length == 1 && arr[0] == null))
                .map(Stream::of)
                .orElseGet(Stream::empty);
    }

    public static <T> Predicate<T> not(Predicate<T> p) {
        return (T x) -> !p.test(x);
    }

    public static Message print(Message someValue) {
        System.out.println("Message is  :: "+someValue.toString());
        return someValue;
    }
}

核心原因：Stream.count()的优化逻辑变更 #

Java 9对Stream终端操作count()做了SIZED流优化：

• 当Stream属于SIZED特性的流（即可以提前确定元素数量的流，比如Collections.singleton(message).stream()就是典型的SIZED流），count()会直接返回预计算的元素数量，不会遍历流中的元素，自然不会触发map操作里的print方法。
• Java 8中count()没有这个优化，无论流是否为SIZED，都会遍历所有元素来统计数量，因此print方法会被执行。

验证方式 #

如果要让Java 9中print方法执行，可以通过以下方式破坏流的SIZED特性：

// 在map前添加filter，filter会移除流的SIZED特性
System.out.println("Number of messages printed are " 
        + messageStream
                .filter(x -> true)
                .map(TestingJavaStream::print)
                .count());

或者将count()替换为需要遍历元素的终端操作（比如forEach）：

messageStream.map(TestingJavaStream::print).forEach(x -> {});
System.out.println("Number of messages printed are 1");

内容的提问来源于stack exchange，提问作者Kartik