Java 8 如果API调用期间出现部分故障，下面的java代码的输出将是什么？

我有一个总共115个输入的列表，使用下面的代码将其分为大小为20个输入的数据包，这意味着

xoneIndexListOfList

有6个元素，大小分别为

[[20]、[20]、[20]、[20]、[15]

final AtomicInteger counter = new AtomicInteger();
final Collection<List<XoneIndexRequest>> xoneIndexListOfList = xoneIndexRequestList.stream()
          .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / xoneIndicesPacketSize))
              .values(); 

从上面的代码中，我们可以看到上面的API将有6个调用（即每个数据包一个调用），因此我的问题是，如果出现部分故障，会发生什么情况

场景： 假设数据包1和2通过，而数据包3失败（即API无法返回第三个数据包的数据）

**问题:**

在上面的场景中，它会继续处理4和5个数据包吗？如果是，那么假设数据包4和5也通过了，那么总的来说，数据包1、2、4、5通过了，但3失败了，那么上面代码的返回输出是什么

如果否，它们将只返回数据包1和2的输出，因为数据包1和2已经通过，而数据包3的请求失败

或者，如果任何一个数据包在任何时候都会失败，它是否会将该数据包列表处理的每个数据包标记为失败

编辑-添加完整方法

@Override
public List<XoneIndexResponse> creditIndicesSearch7(List<XoneIndexRequest> xoneIndexRequestList) {

    try {

        final AtomicInteger counter = new AtomicInteger();
        final Collection<List<XoneIndexRequest>> xoneIndexListOfList = xoneIndexRequestList.stream()
            .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / xoneIndicesPacketSize))
            .values();

        return xoneIndexListOfList.stream()
            .map(e -> {
               return getResponseBody(creditIndicesApiClient.creditIndicesSearch7(e));
            }).collect(Collectors.toList());

    } catch (Exception e) {
        log.error("error while retrieving data from x-one! for Index", e);
        return emptyList();
    }
}

@覆盖
公共列表CreditIndicateSarch7（列表xoneIndexRequestList）{
试一试{
最终AtomicInteger计数器=新的AtomicInteger（）；
最终集合xoneIndexListOfList=xoneIndexRequestList.stream（）
.collect（Collectors.groupingBy（it->counter.getAndIncrement（）/xoneIndicesPacketSize））
.values（）；
返回xoneIndexListOfList.stream（）
.map（e->{
返回GetResponseBy（CreditIndicatesAppClient.CreditIndicatesArch7（e））；
}).collect（Collectors.toList（））；
}捕获（例外e）{
log.error（“从x-one！检索索引的数据时出错”，e）；
返回空列表（）；
}
}

当发生未经处理的异常时，流的处理立即停止

因此，除非处理异常，否则不会得到列表

我们可以使用以下代码对其进行测试：

Stream.of(6, 0, 7)
        .map(integer -> 5/integer + integer)
        .forEach(System.out::println);

输出：

6
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.example.demo.DemoApplication.lambda$main$8(DemoApplication.java:244)
    at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
    at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
    at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
    at com.example.demo.DemoApplication.main(DemoApplication.java:245)

6
7

这取决于我们正在尝试做什么，但我们可以通过以下方式解决：

Stream.of(6, 0, 7)
        .map(integer -> {
            try{
                return  Optional.of(5/integer + integer);
            }catch (ArithmeticException e){
                return Optional.empty();
            }
        })
        .filter(Optional::isPresent)
        .map(Optional::get)
        .forEach(System.out::println);

输出：

6
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.example.demo.DemoApplication.lambda$main$8(DemoApplication.java:244)
    at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
    at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
    at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
    at com.example.demo.DemoApplication.main(DemoApplication.java:245)

6
7

---

编辑：

当整个事件包装在

try

范围中时，从流中抛出的异常将传播并在

catch

范围中捕获

---

因此，在您的情况下，将在日志中打印一个错误，并调用

emptyList（）

。

上面的整个代码都写在try-catch块中，现在会出现什么行为？@MOnkey I编辑以回答您的问题：）