多個對於每個性能調整

Question

我想迭代一個 object ，其中包含列表等。 由於這個數據很大，我想在滿足 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
                }
            })))));

Answer 1

可以通過很多平面映射階段來做到這一點：

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();

另一種方法是在方法中使用 for-each 循環來進行短路：

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();
}

或在最外層循環上使用 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;
          }
        }
      }
    }
  }
}

Answer 2

性能非常相似 -傳統的 for和forEach操作在大多數情況下。 所以在這種情況下你可以使用傳統的進行操作。 您現在可以在每個循環上傳播中斷。

演示代碼：

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

Answer 3

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;
                            })
                    )
        );