Question

我正在尝试遍历对象列表并将其属性打印到xml文件中，但由于需要封闭标记，我需要递归遍历子节点并打印其属性，然后再返回顶部堆栈中写出最高组件的闭包标签。

然而，似乎for循环和递归在java中并不能很好地结合在一起，因为有一些奇怪的原因，当我在for循环中有一个方法调用本身时，计数器“重置”（基本上是计数器变量似乎当进入循环的下一次迭代时，在尝试使用所有3个参数的正常循环时取消分配，导致无限循环。

我尝试了许多不同的方法，包括尝试在类构造函数中使计数器成为静态变量，而在for-each循环中替换，都具有类似的问题。我最接近找到答案的是以下解决方案，传入并将计数器返回到递归方法中：

Adding counter to a loop inside a recursive method - Java

然而，虽然这适用于上面的情况，它只是添加一个值，但它会导致问题，如果我不调整计数器，它现在比它需要的高一个并导致indexOutOfBound异常如果我在进入循环之前减去计数器和/或将其指定为0，则返回返回0，即使我在传回计数器之前明确地将其添加到计数器中。

这些都没有任何意义。以下是我正在使用的代码的基本逻辑：如果有人知道这有什么问题，或者知道任何替代解决方案，请告诉我。

public int write(PrintWriter fromPortalTXTFile, String level, Integer counter){
    ...
    if (children) {
        for(;counter < childrenList.size();) {
            counter++;
            counter = ClassName.get(counter - 1).write(fromPortalTXTFile, level, counter);
        }
    }
    else {
        counter++;
    }

    return counter;
}

编辑：由于各种请求，这是整个方法代码。它包含对不同函数的引用，并且具有与我遇到的问题无关的逻辑，我不能详细说明该方法的每个部分如何工作。问题是如果组件有子代，则输入for循环，我仍然认为上面有更好的说明。

// Writes the information about this BOM component out to the from_portal.txt file
public int write(PrintWriter fromPortalTXTFile, String level, Integer counter) throws Exception {

    //Retrieve the item and revision of the BOM line.  If
    //read access is denied, skip the BOM line.
    Debug.println("PERF: Inside printXMLTag: Reading BOMLine props start");        
    TCComponentItem item = TXDExportAction.getItem(currentComponent);
    TCComponentItemRevision rev = TXDExportAction.getItemRevision(currentComponent);
    //if (item == null || rev == null) {
    //    return null;
    //}
    String itemID = item.getProperty("item_id");
    String revID = rev.getProperty("item_revision_id");

    // Get the pdm_occ_id of the current component
    String pdmOccID = TXDExportAction.getBOMLineProperty(currentComponent, "bl_occurrence_uid");

    // Determine if the item is currently selected in the BOM window
    Boolean isSelected = false;

    //if (selectedComponents.contains(currentComponent)){
    //  isSelected = true;
    //}

    // TODO: See if it is actually needed to get the quantity of packed lines

    //If the user created a single occurrence to represent
    //multiple occurrences, get the quantity
    int n = 1;
    boolean packed = currentComponent.isPacked();
    if (!packed) {
        try {
            //String str = icbl.getProperty("bl_quantity");
            String str = TXDExportAction.getBOMLineProperty(currentComponent, "bl_quantity");
            if (str != null) {
                n = Integer.parseInt(str);
            }
        } catch (NumberFormatException e) {
            //Do nothing
        }
    }

    Debug.println("PERF: Inside printXMLTag: Reading BOMLine props  complete");

    //TODO: See why this is in a loop, and if it is necessary
    XMLStringBuffer buf = new XMLStringBuffer();

    //Loop over the BOM line n times
    for (int count = 0; count < n ; count++) {
        //Build the opening XML entry
        //XMLStringBuffer buf = new XMLStringBuffer();
        buf.startTag(TXDExportAction.BOMLINE);
        buf.appendAttribute(TXDExportAction.ITEM_ID, itemID);
        buf.appendAttribute(TXDExportAction.REV_ID, revID);

        buf.appendAttribute(TXDExportAction.PDM_OCC_ID, pdmOccID);
        buf.appendAttribute(TXDExportAction.ITEM_SELECTED, isSelected);

        // If this is not the lowest level tag, don't put in the slash at the end.
        // If it is, close the tag.
        //TODO: Remove writing of tags, add to the BOMElement.write function.
        //if (closureTags == 0){
        //  buf.endTagBracket();
        //}
        //else{
        //  buf.endTag();

        //  //Handle closure tags for parents
        //    for(int i = 0; i < closureTags; i++){
        //      buf.endTag(BOMLINE);
        //    }
        //}


    }
    buf.endTagBracket();

    // Step 3: write a </bomline> tag at the same level
    fromPortalTXTFile.print(level);
    fromPortalTXTFile.println(buf);
    //buf.endTag(TXDExportAction.BOMLINE);

    if (!childBOMElements.isEmpty()){
        // Step 1: print tag + information
        level = level + "    ";
        // Step 2: for each child, call child.write()
        for (; counter < childBOMElements.size();){
            counter ++;
            //BOMElement nextElement = childBOMElements.get(index);
            counter = childBOMElements.get(counter - 1).write(fromPortalTXTFile, level, counter); 
        }
        // </Bomline> tag
        //fromPortalTXTFile.println(buf.endTag(TXDExportAction.BOMLINE));
    }
    else
    {
        // If no children, close the tag with a leaflet
        //fromPortalTXTFile.println(buf);
        counter++;
        fromPortalTXTFile.print(buf.endTag());
    }


    // For some reason, using a recursive function in a for loop resets the counter of the for loop.
    // The only work-around is to pass the counter back as a return method.
    return counter;
}

Answer 1

这是因为你在调用递归方法之前增加counter（这就是你在递归调用中需要counter - 1并且完全冗余的原因）。

那说你遇到的问题是你的一般结构。你是在计数器中传递并定义每个计数器值的循环。但是，子对象不能保证父母的子女数量。父A有3个孩子，所以你传递counter的值为0,1或2.但是，如果Child A本身只有1个孩子，则{1}}为1或2将导致它失败（IndexOutOfBounds错误）。

counter

请记住这不会是完美的。我无法访问您的整个代码。我不知道在做什么水平。我不知道你是怎么得到孩子的。

但是你太过于复杂了。如果孩子存在，你需要做的就是为每个孩子提供递归。

编辑：来自评论链：

您可能无法正确处理根文档的子项。或者，或者你有一个无限循环，因为它永远重新启动for循环（因此n将始终为0）。您可以通过查看级别是否正确递增（或递减）来测试它。

因此，上面的例子不是完整的答案。处理子对象的处理方式是解决方案的一部分。

Java For循环计数器在调用递归方法时不起作用

1 个答案: