java - 如何正确实现递归方法？

Question

我有一个列表，它是这样的:

我有一个arraylist<XmlProperty> myList .

我的 myList 看起来像这个图像，所以 myList.get(0) 是第一行，myList.get(1) 是第二行，依此类推。

重要的一点是，有 myList 元素，例如类型为“AdressType”，因此存在“子”元素。

对于这个 myList，关系如下:

Stage = 0    Stage = 1     Stage = 2
Adress
-------------City
-------------Street
---------------------------StreetName
---------------------------HouseNumber
---------------------------Suffix
-------------PostalCode

因此 Stage=1 的元素是 Stage=0 的元素的子元素。 您可以在“ChildNr”列中看到哪些元素是特定元素的子元素。

所以我想用 objectValues 调用所有方法，但我必须注意有子元素的元素，因为在调用它们之前我必须首先调用子元素。

我尝试实现它，但无法正确实现递归。

public void buildChildrenObjectsRecursively(Object object, int xmlNumber, int fieldNr, int objectLength) throws InvocationTargetException, IllegalAccessException {

    //amount of children-elements
    if (objectLength != 0) {

        if (myList.get(fieldNr).isHasChild() == false) {

            myList.get(fieldNr).getCreateMethod().invoke(object, myList.get(fieldNr).getInstance());
            fieldNr++;

        } else { //recursive call

            int childLength = getLengthOfObject(myList.get(fieldNr).getInstance());
            buildChildrenObjectsRecursively(myList.get(fieldNr).getInstance(), xmlNumber, fieldNr + 1, childLength);
            myList.get(fieldNr).getCreateMethod().invoke(object, allXmls.get(xmlNumber).get(fieldNr).getInstance());
        }
        objectLength--;
    }
}

getInstance() 是“ObjectValue”列中的对象。

那么我的错误在哪里？

我想做的是:

1. 调用对象的方法
2. 如果有子元素，则首先调用子元素上的方法，然后调用对象上的方法

更新

我必须澄清一下。

我想做的是:

1. 调用方法对象
2. 如果有子元素，则首先调用子元素上的方法。之后调用对象

对于图中的示例来说，这意味着:

顺序为 {1, 2, 3, 4, 5, 6, 7} 的列表应为 {2, 4, 5, 6, 3, 7, 1}。 因此，按照这个顺序，我可以轻松地使用循环调用这些方法。

那么我该怎么做呢？

Answer 1

数据结构定义，如果使用Stage类则需要使用lombok:

import lombok.Data;
@Data
public class Stage{
    private Integer number;
    private Integer stageNumber;
    private List<Integer> childNumber;


    public static final class StageBuilder {
        private Integer number;
        private Integer stageNumber;
        private List<Integer> childNumber;

        private StageBuilder() {
        }

        public static StageBuilder aStage() {
            return new StageBuilder();
        }

        public StageBuilder withNumber(Integer number) {
            this.number = number;
            return this;
        }

        public StageBuilder withStageNumber(Integer stageNumber) {
            this.stageNumber = stageNumber;
            return this;
        }

        public StageBuilder withChildNumber(List<Integer> childNumber) {
            this.childNumber = childNumber;
            return this;
        }

        public Stage build() {
            Stage stage = new Stage();
            stage.setNumber(number);
            stage.setStageNumber(stageNumber);
            stage.setChildNumber(childNumber);
            return stage;
        }
    }
}

阶段的实现，只是使用java8按阶段编号排序:

public class StageTest extends TestCase {
    public void test() {
        Stage stage1 = Stage.StageBuilder.aStage().withNumber(1).withStageNumber(0).withChildNumber(Arrays.asList(2, 3, 7)).build();
        Stage stage2 = Stage.StageBuilder.aStage().withNumber(2).withStageNumber(1).build();
        Stage stage3 = Stage.StageBuilder.aStage().withNumber(3).withStageNumber(1).withChildNumber(Arrays.asList(4, 5, 6)).build();
        Stage stage4 = Stage.StageBuilder.aStage().withNumber(4).withStageNumber(2).build();
        Stage stage5 = Stage.StageBuilder.aStage().withNumber(5).withStageNumber(2).build();
        Stage stage6 = Stage.StageBuilder.aStage().withNumber(6).withStageNumber(2).build();
        Stage stage7 = Stage.StageBuilder.aStage().withNumber(7).withStageNumber(1).build();
        List<Stage> stageList = Arrays.asList(stage1, stage2, stage3, stage4, stage5, stage6, stage7);
        stageList.sort((o1, o2) -> o2.getStageNumber() - o1.getStageNumber());
        stageList.forEach(item -> System.out.println(item.getNumber()));
    }
}