Question

我有一个列表，这就是它的样子：

我有arraylist<XmlProperty> myList。

我的myList看起来像这个Image，所以myList.get（0）是第一行，myList.get（1）是第二行等。

重点是有myList-Elements，例如Type为“AdressType”，因此有“children”元素。

对于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”列中的Object。

那我的错误在哪里？

我想做的就是：

调用对象上的方法
如果有子节点，则在对象

更新

我必须澄清它。

我想做的就是：

调用方法对象
如果有childre，则首先在children-element上调用方法。之后调用对象

这意味着我们在图片中的示例：

订单{1,2,3,4,5,6,7}的列表应为{2,4,5,6,3,7,1}。因此，按此顺序，我可以轻松地使用Loop调用方法。

那我怎么能这样做呢？

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

如何正确实现递归方法？

1 个答案: