相关疑难解决方法(0)

我有以下示例代码:

System.out.println(
       "Result: " +
        Stream.of(1, 2, 3)
                .filter(i -> {
                    System.out.println(i);
                    return true;
                })
                .findFirst()
                .get()
);
System.out.println("-----------");
System.out.println(
       "Result: " +
        Stream.of(1, 2, 3)
                .flatMap(i -> Stream.of(i - 1, i, i + 1))
                .flatMap(i -> Stream.of(i - 1, i, i + 1))
                .filter(i -> {
                    System.out.println(i);
                    return true;
                })
                .findFirst()
                .get()
);

输出如下:

1
Result: 1
-----------
-1
0
1
0
1
2
1
2
3
Result: -1

从这里我看到,在第一种情况下stream真的表现得懒惰 - 我们使用findFirst()所以一旦我们有第一个元素我们的过滤lambda没有被调用.然而,在使用flatMaps的第二种情况下,我们看到尽管找到满足过滤条件的第一个元素(它只是任何第一个元素,因为lambda总是返回true),流的其他内容仍然通过过滤函数被馈送.

我试图理解为什么它表现得像这样,而不是在第一个元素计算后放弃,如第一种情况.任何有用的信息将不胜感激.

为了尝试深入理解java流和分裂器,我对spliterator特性有一些微妙的问题:

Q1:Stream.empty()vsStream.of()(没有args的Stream.of())

• Stream.empty():SUBSIZED,SIZED
• Stream.of(): SUBSIZED,IMMUTABLE,SIZED,ORDERED

为什么Stream.empty()没有相同的特征Stream.of()？请注意,与Stream.concat()(特别是没有ORDERED)一起使用时会产生影响.我会说不Stream.empty()应该只有IMMUTABLE和ORDERED,还有DISTINCT和NONNULL.也很有意义Stream.of()仅具有一个参数DISTICT.

Q2:LongStream.of()没有NONNULL

刚注意到NONNULL不可用LongStream.of.不是NONNULL所有LongStreams,IntStreams和DoubleStreams 的主要特征吗？

Q3:LongStream.range(,)vsLongStream.range(,).boxed()

• LongRange.range(,):SUBSIZED,IMMUTABLE,NONNULL,SIZED,ORDERED,SORTED ,DISTINCT
• LongStream.range(,).boxed():SUBSIZED,SIZED,ORDERED

为什么.boxed()失去所有这些特征？它不应该失去任何.

我明白.mapToObj()可以失去NONNULL,IMMUTABLE和DISTICT,但.boxed()......没有意义.

Q4:.peek()输掉IMMUTABLE和NONNULL

LongStream.of(1): …

假设我们有一个由唯一Strings 标识的对象集合,以及一个Tree定义它们层次结构的类.该类使用Mapfrom节点(由其ID表示)到Collection其各自子节点的s来实现.

class Tree {
  private Map<String, Collection<String>> edges;

  // ...

  public Stream<String> descendants(String node) {
    // To be defined.
  }
}

我想启用流式节点的后代.一个简单的解决方案是:

private Stream<String> children(String node) {
    return edges.getOrDefault(node, Collections.emptyList()).stream();
}

public Stream<String> descendants(String node) {
    return Stream.concat(
        Stream.of(node),
        children(node).flatMap(this::descendants)
    );
}

在继续之前,我想对此解决方案做出以下断言.(我对这些是正确的吗？)

1. 从Stream返回的descendants消耗资源(时间和内存) - 相对于树的大小 - 以与手动编码递归相同的复杂度顺序行走.特别地,表示迭代状态(Streams,Spliterators,...)的中间对象形成堆栈,因此在任何给定时间的存储器要求与树的深度具有相同的复杂度.

2. 据我所知此,只要我在执行终止操作Stream从返回descendants,根级别调用flatMap将导致所有包含Stream秒-一个用于每个(递归)呼叫descendants-被立即实现.因此,结果Stream …