Java 如何处理具有复杂数据结构的嵌套for循环？

需要对复杂的数据结构进行检查，并从算法中修改外部变量

我已经试着用流来做了，但据我所知，它不是线程安全的，可以是比赛条件

有没有比下面复制的方法更好的方法

List<ObjectA> externalVariable = new ArrayList<>();
List<ObjectA> externalVariable2 = new ArrayList<>();

if (objectA != null) {
    externalVariable.add(objectA);

    for (ObjectB objectB : objectA) {
        if (objectB.getObjectC() != null) {
            for (ObjectD objectD : objectB.getObjectC()) {
                if (objectD.getObjectE() != null) {
                    for (ObjectE objectE : objectD.getObjectE()) {
                        if (objectE.getObjectF() != null) {
                            for (ObjectG objectG : objectE.getObjectF()) {
                                objectG.setSomething("BlaBla");

                                if (objectG.getOjectH() != null && objectG.getOjectH().getObjectI() != null) {
                                    for (ObjectI objectI : objectG.getOjectH().getObjectI()) {
                                        externalVariable2.add(objectI);
                                        ObjectJ objectJ = getRelevantOjectJ(objectA.getId(), objectI.getId());
                                        objectI.setObjectJ(objectJ);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

List externalVariable=new ArrayList（）；
List externalVariable2=new ArrayList（）；
if（objectA！=null）{
externalVariable.add（objectA）；
for（ObjectB ObjectB:objectA）{
if（objectB.getObjectC（）！=null）{
for（ObjectD ObjectD:objectB.getObjectC（））{
if（objectD.getObjectE（）！=null）{
for（ObjectE ObjectE:objectD.getObjectE（））{
if（objectE.getObjectF（）！=null）{
for（ObjectG ObjectG:objectE.getObjectF（））{
对象设置某些内容（“BlaBla”）；
if（objectG.getObjecth（）！=null&&objectG.getObjecth（）.getObjectI（）！=null）{
对于（ObjectI-ObjectI:objectG.getOjectH（）.getObjectI（））{
外部变量2.add（objectI）；
ObjectJ ObjectJ=getRelevantOjectJ（objectA.getId（），objectI.getId（））；
objectI.setObjectJ（objectJ）；
}
}
}
}
}
}
}
}
}
}

当多个线程同时执行修改共享状态的语句时，会出现争用情况。
如果您当前的代码是线程安全的，那么当您不使用并行流功能时，它仍将与流一起使用。
关于您的实际代码：我们可以认为这是一个箭头代码，不容易阅读和维护。 您有不同的方法来减少全局嵌套，但我不鼓励使用流，因为您不收集到结果中，而是改变外部对象。这不是流的用例

您可以在当前代码中指出，您显式地迭代了许多集合，而应用逻辑并不关心其中的大多数

在这里，仅为获取

ObjectG

实例而执行的所有操作，其余的则不使用：

for (ObjectB objectB : objectA) {
    if (objectB.getObjectC() != null) {
        for (ObjectD objectD : objectB.getObjectC()) {
            if (objectD.getObjectE() != null) {
                for (ObjectE objectE : objectD.getObjectE()) {
                    if (objectE.getObjectF() != null) {
                        for (ObjectG objectG : objectE.getObjectF()) {

因此，将所有这些封装到一个方法中，该方法收集

ObjectG

实例并返回它们。
请注意，它可以在没有流的情况下编写，但也可以使用流，因为要收集它们，您不需要修改共享状态

最后，您可以将方法简化为：

Collection<ObjectG> objectsG = collectG(objectA); // extracted method

for (ObjectG objectG : objectsG) {
    objectG.setSomething("BlaBla");

    if (objectG.getOjectH() != null && objectG.getOjectH().getObjectI() != null) {
        for (ObjectI objectI : objectG.getOjectH().getObjectI()) {
            externalVariable2.add(objectI);
            ObjectJ objectJ = getRelevantOjectJ(objectA.getId(), objectI.getId());
            objectI.setObjectJ(objectJ);
        }
    }

Collection objectsG=collectG（objectA）；//提取方法
for（ObjectG ObjectG:objectsG）{
对象设置某些内容（“BlaBla”）；
if（objectG.getObjecth（）！=null&&objectG.getObjecth（）.getObjectI（）！=null）{
对于（ObjectI-ObjectI:objectG.getOjectH（）.getObjectI（））{
外部变量2.add（objectI）；
ObjectJ ObjectJ=getRelevantOjectJ（objectA.getId（），objectI.getId（））；
objectI.setObjectJ（objectJ）；
}
}

“有比下面复制的方法更好的方法吗？”-如果代码按预期工作，并且您需要审查，那么这个问题可能更适合。好的，使用流作为一个简单的

for

循环，只要流是连续的。这有什么意义？

for（ObjectB ObjectB:objectA）

顺便说一句，如果一个对象是一种集合或流（就像你的例子中的

objectA

），它永远不应该是

null

@PatrickParker如果

objectA Impressions Iterable

（如果代码有效，它必须是这样），这是非常有意义的（至少是语法调用）