什么'；在Java8中，优化用于创建hashmap的嵌套for循环的最佳方法是什么？

在我开始之前，我已经做了大量的研究，还没有找到解决方案。我已经引用了以下线程，以及许多其他线程，但我只是想证明，在提出问题之前，我已经搜索了很长时间，很难找到解决方案。我的情况比这些更复杂：

好的，我正在构建一个服务，它使用另一个服务，该服务提供一个我无法控制的类。我必须在类出现时使用它，因为它是在每次项目构建时从文件动态生成的。大量嵌套类和嵌套列表简直是一团糟。命名约定也很混乱，但为了可读性，我在这里已经清理了很多。我需要深入研究列表，从一个对象（较低）中获取两个值（code和cgyCode），并使用一个作为键（code）和一个作为值（cgyCode）创建一个hashmap

我的功能逻辑如下所示：

//Code passing in object Rpn rpn which contains the nested lists        

HashMap<String, String> codeMap = new HashMap<String, String>();

            for (Object datDtl : rpn.getDatDtlOrRpnDtl()) {

                if (datDtl instanceof Rpn.DatDtl) {

                    for (Rpn.DatDtl.Upper upper : ((Rpn.DatDtl) datDtl).Upper()) {

                        for (Rpn.DatDtl.Upper.Lower lower : Upper.getLower()) {

                            codeMap.put(lower.getCode(), lower.getCgyCode());
                        }
                    }
                }
            }

//代码传入包含嵌套列表的对象Rpn Rpn
HashMap codeMap=新的HashMap（）；
对于（对象datDtl:rpn.getdatdtrorpndtl（））{
if（Rpn.datDtl的datDtl实例）{
对于（Rpn.DatDtl.Upper-Upper:（（Rpn.DatDtl）DatDtl.Upper（））{
对于（Rpn.DatDtl.Upper.Lower-Lower:Upper.getLower（））{
put（lower.getCode（），lower.getCgyCode（））；
}
}
}
}

因此，我尝试了许多变体，将整个过程转换为lambda流，如果这样做是正确的话。我还没能把整个事情做好，总有一些事情搞砸了。因此，我最好的方法是流式处理最后一个循环，但上面什么也没有。我觉得它可以通过更多的方式得到巩固

功能：

HashMap<String, String> codeMap = new HashMap<String, String>();
                for (Object datDtl : rpn.getDatDtlOrRpnDtl()) {

                    if (datDtl instanceof Rpn.DatDtl) {

                        for (Rpn.DatDtl.Upper upper : ((Rpn.DatDtl) datDtl).Upper()){

                             upper.getLower().stream().forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()));

              }
         }
    }

HashMap<String, String> codeMap = new HashMap<>();
rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()))));

HashMap<String, String> codeMap = rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .collect(Collectors.toMap(lower -> lower.getCode(), lower -> lower.getCgyCode())));

HashMap codeMap=newhashmap（）；
对于（对象datDtl:rpn.getdatdtrorpndtl（））{
if（Rpn.datDtl的datDtl实例）{
对于（Rpn.DatDtl.Upper-Upper:（（Rpn.DatDtl）DatDtl.Upper（））{
forEach（lower->codeMap.put（lower.getCode（），lower.getCgyCode（））；
}
}
}

我尝试了过滤、平面图和流的多种组合，但我没有成功地将所有功能转换为一系列lambda语句，我也不知道这是否是最好的做法

因此，我的问题是：从性能方面优化代码的最佳方法是什么？如果不是所有的代码都可以使用lambdas和streams进行优化，那么从学习的角度来看，为什么不呢

---

下面我将演示一些我尝试过的其他接近的东西，但最终我无法解决映射问题

失败1:

HashMap<String, String> codeMap = new HashMap<String, String>();
                for (Object datDtl : rpn.getDatDtlOrRpnDtl()) {

                    if (datDtl instanceof Rpn.DatDtl) {

                        for (Rpn.DatDtl.Upper upper : ((Rpn.DatDtl) datDtl).Upper()){

                             upper.getLower().stream().forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()));

              }
         }
    }

HashMap<String, String> codeMap = new HashMap<>();
rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()))));

HashMap<String, String> codeMap = rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .collect(Collectors.toMap(lower -> lower.getCode(), lower -> lower.getCgyCode())));

HashMap codeMap=newhashmap（）；
rpn.getdatdtrorpndtl（）.stream（）
.filter（Rpn.datDtl的datDtl->datDtl实例）
.flatMap（datDtl->（（Rpn.datDtl）datDtl）.getUpper（）.stream（）
.flatMap（upper->upper.getLower（）.stream（））
.forEach（lower->codeMap.put（lower.getCode（），lower.getCgyCode（））；

除.forEach函数给出错误“不存在类型变量R的实例，因此void符合流”外，上述代码似乎正常工作。这与我的包含lambda的功能循环中的逻辑是一样的，所以这让我觉得我到达“较低”的方式是不正确的

失败2:

HashMap<String, String> codeMap = new HashMap<String, String>();
                for (Object datDtl : rpn.getDatDtlOrRpnDtl()) {

                    if (datDtl instanceof Rpn.DatDtl) {

                        for (Rpn.DatDtl.Upper upper : ((Rpn.DatDtl) datDtl).Upper()){

                             upper.getLower().stream().forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()));

              }
         }
    }

HashMap<String, String> codeMap = new HashMap<>();
rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()))));

HashMap<String, String> codeMap = rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .collect(Collectors.toMap(lower -> lower.getCode(), lower -> lower.getCgyCode())));

HashMap codeMap=rpn.getdatdtrorpndtl（）.stream（）
.filter（Rpn.datDtl的datDtl->datDtl实例）
.flatMap（datDtl->（（Rpn.datDtl）datDtl）.getUpper（）.stream（）
.flatMap（upper->upper.getLower（）.stream（））
.collect（Collectors.toMap（lower->lower.getCode（），lower->lower.getCgyCode（））；

此代码与上面的代码类似。这里的错误是“.getCode（）”和“.getCgyCode（）”即使是在较低的类中定义的，也不能被识别为有效的方法。这进一步表明我的理论是正确的，即我到达“较低”的方式不是正确的方法

我尝试了许多其他的.filter、.map等变体，但我在这里完全不知所措。可能无法完成我试图做的事情，但如果是这样，我想知道为什么以及下一个最好的事情是什么

感谢所有读过这篇文章并想和我一起解决这个问题的人

---

编辑：

HashMap<String, String> codeMap = new HashMap<String, String>();
                for (Object datDtl : rpn.getDatDtlOrRpnDtl()) {

                    if (datDtl instanceof Rpn.DatDtl) {

                        for (Rpn.DatDtl.Upper upper : ((Rpn.DatDtl) datDtl).Upper()){

                             upper.getLower().stream().forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()));

              }
         }
    }

HashMap<String, String> codeMap = new HashMap<>();
rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode()))));

HashMap<String, String> codeMap = rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl)datDtl).getUpper().stream()
                    .flatMap(upper -> upper.getLower().stream()
                    .collect(Collectors.toMap(lower -> lower.getCode(), lower -> lower.getCgyCode())));

该解决方案让我找到了答案，但为了向可能遇到此问题的其他人提供文档，我将格式化最终有效的解决方案：

Map<String, String> codeMap = rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl) datDtl).Upper().stream())
                    .flatMap(upper -> upper.getLower().stream())
                    .forEach(lower -> codeMap.put(lower.getCode(), lower.getCgyCode());

Map codeMap=rpn.getdatdtrorpndtl（）.stream（）
.filter（Rpn.datDtl的datDtl->datDtl实例）
.flatMap（datDtl->（（Rpn.datDtl）datDtl）.Upper（）.stream（））
.flatMap（upper->upper.getLower（）.stream（））
.forEach（lower->codeMap.put（lower.getCode（），lower.getCgyCode（））；

您的两次尝试都非常接近

您的代码没有缩进以显示它，但在失败的尝试中，您将在

collect

调用后放置一些右括号

这不是流操作的正确顺序。最后一个操作应该是调用

collect

。编写时，您的代码将生成一个

流

，而不是

映射

请尝试以下代码：

Map<String, String> codeMap = Rpn.getDatDtlOrRpnDtl().stream()
                    .filter(datDtl -> datDtl instanceof Rpn.DatDtl)
                    .flatMap(datDtl -> ((Rpn.DatDtl) datDtl).Upper().stream())
                    .flatMap(upper -> upper.getLower().stream())
                    .collect(Collectors.toMap(lower -> lower.getCode(), lower -> lower.getCgyCode());

Map codeMap=Rpn.getdatdtrorpndtl（）.stream（）
.filter（Rpn.datDtl的datDtl->datDtl实例）
.flatMap（datDtl->（（Rpn.datDtl）datDtl）.Upper（）.stream（））