Java 关于在一次过程中处理中间操作？

以下面的代码为例：

// trader (name, city) 
Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");
// transaction(trader, year, value)
List<Transaction> transactions = Arrays.asList(
    new Transaction(brian, 2011, 300),
    new Transaction(raoul, 2012, 1000),
    new Transaction(raoul, 2011, 400),
    new Transaction(mario, 2012, 710),
    new Transaction(mario, 2012, 700),
    new Transaction(alan, 2012, 950)
);
transactions.stream()
    .filter( t -> {
        System.out.println("filtring "+t.getValue());
        return t.getValue()>=700;
    })
    .map(t -> {
        System.out.println("mapping "+t.getValue());
        return t.getValue();
    })
    .count();

我不取消重新启动此输出。有人可以给我解释一下这个结果。我期望这一产出：

filtring 300
filtring 1000
filtring 400
filtring 710
filtring 700
filtring 950
mapping 1000
mapping 710
mapping 700
mapping 950

---

这是意料之中的。整个管道一次在一个元素上执行（以一种惰性的方式-这就是为什么您只看到第一个过滤300，之后没有映射）

你可以这样想：第一个元素首先被过滤，然后被映射；然后过滤第二个，然后映射。如果筛选返回

false

，则无需执行映射，结果将被忽略（这就是它懒惰的原因）

实际上，对于流来说，这是非常基本的东西

---

顺便说一句，如果我没有弄错的话，这似乎是“java-8实际运行”中的一个例子，而且这本书对这些基本问题的解释非常好。一定要再读一遍（必要时再读一遍）。

这是意料之中的。整个管道一次在一个元素上执行（以一种惰性的方式-这就是为什么您只看到第一个过滤300，之后没有映射）

你可以这样想：第一个元素首先被过滤，然后被映射；然后过滤第二个，然后映射。如果筛选返回

false

，则无需执行映射，结果将被忽略（这就是它懒惰的原因）

实际上，对于流来说，这是非常基本的东西

---

顺便说一句，如果我没有弄错的话，这似乎是“java-8实际运行”中的一个例子，而且这本书对这些基本问题的解释非常好。一定要再读一遍（如果需要，再读一遍）。

在下面的表达式中

transaction.stream().filter(conditionPredicate).map(mapperFunction).count();

每次方法调用后返回的对象的类型为

List<Transaction> => Stream<Transaction> => Stream<Transaction> => Stream<Integer> => long

List=>Stream=>Stream=>Stream=>long

流

库大部分是惰性实现的。这意味着操作管道中的所有lambda应用于第一个元素，然后所有lambda应用于第二个元素，依此类推。根本不存储中间集合（流）

---

希望这有帮助。

在下面的表达式中

transaction.stream().filter(conditionPredicate).map(mapperFunction).count();

每次方法调用后返回的对象的类型为

List<Transaction> => Stream<Transaction> => Stream<Transaction> => Stream<Integer> => long

List=>Stream=>Stream=>Stream=>long

流

库大部分是惰性实现的。这意味着操作管道中的所有lambda应用于第一个元素，然后所有lambda应用于第二个元素，依此类推。根本不存储中间集合（流）

希望这有帮助。

尝试使用

findFirst（）

而不是

count（）

。这可能会提供更多的见解…请尝试使用

findFirst（）

而不是

count（）

。这可能会提供更多的见解…