Selenium Java8流：分阶段映射

是否可以在不创建中间集合的情况下分阶段对流执行映射

我正在使用Selenium并映射

WebElement

s的流。分批执行这些操作非常重要，以避免引发

StaleReferenceException

，因为页面会动态更新自身，并且一些

map

操作需要相对较长的时间才能完成

问题（简化）：

期望输出：

         1        10
         2        20
         3        30
         4        40
         5        50
        10       100
        20       200
        30       300
        40       400
        50       500
       100      1000
       200      2000
       300      3000
       400      4000
       500      5000

当前解决方案：

private static Stream<String> map(String[] input) {
    return Arrays.stream(input)
            .map(s -> s + "0")
            .collect(Collectors.toList()).stream()              
            .map(s -> s + "0")
            .collect(Collectors.toList()).stream()
            .map(s -> s + "0");
}

私有静态流映射（字符串[]输入）{
返回数组.stream（输入）
.map（s->s+“0”）
.collect（Collectors.toList（））.stream（）
.map（s->s+“0”）
.collect（Collectors.toList（））.stream（）
.map（s->s+“0”）；
}

有没有一种方法可以在每次调用

map

之间不创建虚拟集合的情况下实现这一点

---

注意：我需要使用一个包含n个对

映射的调用的流，而不是一系列n个for循环。
老实说，我不知道你想做什么。以下是符合您的示例输出的内容：

private static Stream<String> map(String[] input) {

    return Stream.of("", "0", "00")
            .flatMap(x -> Arrays.stream(input)
                    .map(y -> y + x)
                    .peek(z -> System.out.println(z + " " + z + "0"))
                    .map(z -> z + "0"))
            .skip(2 * input.length);
}

私有静态流映射（字符串[]输入）{
返回流。of（“，“0”，“00”）
.flatMap（x->array.stream（输入）
.map（y->y+x）
.peek（z->System.out.println（z+“”+z+“0”））
.map（z->z+“0”））
.跳过（2*输入长度）；
}

您看到的无序结果是因为您使用的是
并行
，中间操作没有定义的执行顺序，只有terminal do（除非另有说明，例如，forEach

）

老实说，不知道您要做什么。以下是符合您的示例输出的内容：

private static Stream<String> map(String[] input) {

    return Stream.of("", "0", "00")
            .flatMap(x -> Arrays.stream(input)
                    .map(y -> y + x)
                    .peek(z -> System.out.println(z + " " + z + "0"))
                    .map(z -> z + "0"))
            .skip(2 * input.length);
}

私有静态流映射（字符串[]输入）{
返回流。of（“，“0”，“00”）
.flatMap（x->array.stream（输入）
.map（y->y+x）
.peek（z->System.out.println（z+“”+z+“0”））
.map（z->z+“0”））
.跳过（2*输入长度）；
}

您看到的无序结果是因为您使用的是

并行

，中间操作没有定义的执行顺序，只有终端执行（除非另有说明，例如，forEach）

这似乎有效：

String[] input = new String[] {"1", "2", "3", "4", "5"};

Stream.of("", "0", "00")
      .flatMap(suffix -> Stream.of(input)
           .map(prefix -> prefix + suffix)
           .map(s -> String.format("%10s%10s", s, s + "0")))
      .forEach(System.out::println);

错误的排序是由于调用了

parallel（）

，这可能是可以避免的。

这似乎是可行的：

String[] input = new String[] {"1", "2", "3", "4", "5"};

Stream.of("", "0", "00")
      .flatMap(suffix -> Stream.of(input)
           .map(prefix -> prefix + suffix)
           .map(s -> String.format("%10s%10s", s, s + "0")))
      .forEach(System.out::println);

---

错误的顺序是由于

parallel（）

调用造成的，这可能是可以避免的。

这不是设计流的方式

在不创建中间集合的情况下应用一系列映射操作，只有终端操作决定结果（集合或单个值）

---

但要成批工作（将第一个映射操作应用于所有输入，然后将第二个映射操作应用于所有第一个中间结果，等等），您需要中间集合。

这不是流的设计行为方式

在不创建中间集合的情况下应用一系列映射操作，只有终端操作决定结果（集合或单个值）

---

但是要成批工作（将第一个映射操作应用于所有输入，然后将第二个映射操作应用于所有第一个中间结果，等等），您需要中间集合。

在您的示例中，您不需要调用

.collect（Collectors.toList（））.stream（）

。在这里发布您的真实代码，我将帮助您处理这些集合的方式将因您实际尝试的操作而大不相同。发布使用Selenium和WebElements的实际代码或删除[Selenium]标记。我建议使用纯旧for循环。您可以在数组中的每个迭代中进行映射。在您的示例中，您不需要调用

.collect（Collectors.toList（））.stream（）

。在这里发布您的真实代码，我将帮助您处理这些集合的方式将因您实际尝试的操作而大不相同。发布使用Selenium和WebElements的实际代码或删除[Selenium]标记。我建议使用纯旧for循环。你可以在数组中的每个迭代中进行映射。不知道OP想要什么，但是如果你收集结果而不是

forEach

（可能是

forEachOrdered

），你会得到一个结果！=那家伙想要什么。收集OP后想要得到

1000、2000、3000、4000、5000

——如果我理解正确，我不知道OP想要什么，但是如果你收集你的结果而不是

forEach

（这可能是

forEachOrdered

），你会得到一个结果！=那家伙想要什么。收集OP后，如果我理解正确，我希望获得

1000、2000、3000、4000、5000