Java 每次性能调整都有多个

我想迭代一个对象，它在列表中有列表，等等。由于数据量很大，我希望在满足if条件时退出所有迭代

既然forEach中不支持break，我们如何实现这一点？除了使用

forEach

来提高性能之外，还有其他更好的解决方案吗？性能是这里的关键标准。我可以在这里使用流/并行流吗

dataList.forEach(data -> data.getList()
    .forEach(data1 -> data1.getList()
        .forEach(data2 ->data2.getList()
           .forEach(data3 ->data3.getList()
              .forEach(data4 -> {
                  if (data4.getSomeData().equals(someData)) {
                    //some logic to populate some object using data1, data2, data3 & data4 fields
                   //I want to exit all the for each iterations if this condition is met. Since this list is very huge in size
                }
            })))));

---

大多数情况下，传统操作和forEach操作的性能非常相似。因此，在这种情况下，您可以使用传统方法进行操作。现在，您可以在每个循环上传播break

演示代码：

boolean killSwitch = false;
for(;i < size && !killSwitch; i++){
   for( ;j < size && !killSwitch; j++){
       for(;k < size && !killSwitch; k++){
            if(condition == true){
                killSwitch = true;
            }
       }
   }
}

boolean killSwitch=false；
对于（；i

可以通过许多flatmapping阶段来实现这一点：

Optional<YourObject> mappedData = dataList.getList().stream()
    .flatMap(data -> data.getList().stream()
      .flatMap(d1 -> d1.getList().stream()
        .flatMap(d2 -> d2.getList().stream()
          .flatMap(d3 -> d3.getList().stream()
            .flatMap(d4 -> d4.getList().stream()
              .filter(d4.getSomeData().equals(someData))
              .map(d -> mapping(data, d1, d2, d3, d4, d))))))
    ).findFirst();

可选mappedData=dataList.getList（）.stream（）
.flatMap（数据->数据.getList（）.stream（））
.flatMap（d1->d1.getList（）.stream（））
.flatMap（d2->d2.getList（）.stream（））
.flatMap（d3->d3.getList（）.stream（））
.flatMap（d4->d4.getList（）.stream（））
.filter（d4.getSomeData（）.equals（someData））
.map（d->mapping（数据，d1，d2，d3，d4，d‘‘‘‘‘‘）’）
).findFirst（）；

另一种方法是使用方法中的每个循环进行短循环：

private Optional<YourObject> foo(Data data) {
  for (Data d : data.getList()) {
    for (Data1 d1 : d.getList()) {
      for (Data2 d2 : d1.getList()) {
        for (Data3 d3 : d2.getList()) {
          for (Data4 d4 : d3.getList()) {
            if (d4.getSomeData().equals(someData)) {
              return Optinal.of(mapping(data, d1, d2, d3, d4));
            }
          }
        }
      }
    }
  }
  return Optional.empty();
}

private可选foo（数据）{
对于（数据d:Data.getList（））{
对于（data1d1:d.getList（））{
对于（Data2 d2:d1.getList（））{
对于（data3d3:d2.getList（））{
对于（data4d4:d3.getList（））{
如果（d4.getSomeData（）.equals（someData））{
返回选项of（映射（数据，d1，d2，d3，d4））；
}
}
}
}
}
}
返回可选的.empty（）；
}

或者在最外层循环上使用break语句：

Optional<YourObject> yourObject = Optional.empty();
outer: for (Data d : data.getList()) {
  for (Data1 d1 : d.getList()) {
    for (Data2 d2 : d1.getList()) {
      for (Data3 d3 : d2.getList()) {
        for (Data4 d4 : d3.getList()) {
          if (d4.getSomeData().equals(someData)) {
            yourObject = Optional.of(mapping(data, d1, d2, d3, d4));
            break outer;
          }
        }
      }
    }
  }
}

Optional yourObject=Optional.empty（）；
外部：for（数据d:Data.getList（））{
对于（data1d1:d.getList（））{
对于（Data2 d2:d1.getList（））{
对于（data3d3:d2.getList（））{
对于（data4d4:d3.getList（））{
如果（d4.getSomeData（）.equals（someData））{
yourObject=Optional.of（映射（数据，d1，d2，d3，d4））；
打破外部；
}
}
}
}
}
}

您无法停止forEach。使用布尔值跳过或移动到循环。如果性能是这里的关键，您是否考虑过尝试重新构造数据以使其更紧密地绑定在一起？我不能这样做，我们正在使用来自外部源的数据。如果我确实进行了重组，那么它将花费比查找所需数据更多的时间。如果您想要优化，我建议不要使用流。通常，传统的循环速度更快。让它与流一起工作并携带外部值将使代码几乎无法读取。嵌套for each循环将同时解决作用域和中断的问题。为什么不使用嵌套

for（…dataY:dataX.getList（））

循环并在最内层循环中中断？是的，我可以使用传统for循环，但我觉得使用forEach或Streams可以提高性能。@ernest_k，我们也可以使用它。Hi@Flown感谢您的回复，但是哪个选项会提供更好的性能。我们每秒至少会收到100个这样的请求。在这里，性能是处理此类问题的关键要求data@Rohit这要看情况而定。流会产生开销，因此我建议使用for-each循环级联。但是你为什么不自己试试看呢？

dataList.forEach(
                data -> data.forEach(
                    data1 -> data1.forEach(
                            data2 -> data2.stream().
                                    filter(data2.getSomeData().equals(someData)).
                                    findFirst().
                                    ifPresentOrElse(data2.doSomethingMethod()), () -> {
                                //do failed code
                                return 0;
                            })
                    )
        );