如何遍历<Type>包含相同类型列表的列表

Question

我有一个Type类的List，该类别具有以下结构：

class Type {
    private String name;
    private String level;
    private List<Type> types;
}

这是我的AnotherType，结果我想构建。

class AnotherType {
    private String name; 
    private List<AnotherType> types;
}

我是从UI的请求中构建List<Type>对象：

{
  "types": [
    {
      "level": "1",
      "name": "Name1"
    },
    {
      "level": "2",
      "name": "Name2",
      "types": [
        {
          "level": "2.1",
          "title": "Name2.1",
          "types": [
            {
              "level": "2.1.1",
              "name": "Name2.1.1"
            },
            {
              "level": "2.1.2",
              "title": "Name2.1.2"
            }
          ]
        }
      ]
    },
    {
      "level": "3",
      "name": "Name3",
      "types": [
        {
          "level": "3.1",
          "name": "Name3.1",
          "types": [
            {
              "level": "3.1.1",
              "name": "Name3.1.1"
            },
            {
              "level": "3.1.2",
              "name": "Name3.1.2"
            }
          ]
        }
      ]
    }
  ]
}

您可以看到每个types可以在那里或可以是null。

我不知道它能深入。

我的问题是我如何递归（或迭代）到此List<Type>并构造List<AnotherType>？

预先感谢。

Answer 1

首先，在类中添加getters/setters以访问和修改私有字段。然后，您可以使用以下方法将Type转换为AnotherType。

public AnotherType toAnotherType(Type type) {
    AnotherType anotherType = new AnotherType();
    anotherType.setName(type.getName());
    if (type.getTypes() != null && !type.getTypes().isEmpty()) {
        List<AnotherType> lAnotherTypes = new ArrayList<>();
        for(Type innerType : type.getTypes()) {
            AnotherType innerAnotherType = toAnotherType(innerType);
            lAnotherTypes.add(innerAnotherType);
        }
        anotherType.setTypes(lAnotherTypes);
    }   
    return anotherType;
}

然后使用此方法，您可以在List<Type>上遍历一次，并为每个Type致电toAnotherType方法：

List<AnotherType> allAnotherTypes = new ArrayList<>();
for (Type type : types) {
    AnotherType anotherType = toAnotherType(type);
    allAnotherTypes.add(anotherType);
}

希望这会有所帮助。

Answer 2

也许您正在搜索诸如模型映射器之类的东西，e。G。modelmapper.org

否则可以通过多种方式完成穿越对象的遍历。一种可能性：

AnotherType transform(Type type) {
  if (type == null) {
    return null;
  }
  AnotherType anotherType = new AnotherType();
  anotherType.name = type.name;
  if (type.types != null) {
    anotherType.types = type.types.stream()
        .map(this::transform)
        .collect(Collectors.toList());
  }
  return anotherType;
}

之后呼叫该功能：

Type toTransform ...
AnotherType anotherType = transform(toTransform);

（当然：根据您的需求添加修饰符和可见性）

Answer 3

您可以在列表中所有类上运行相同功能的类上的函数，然后返回答案。

类似这样的东西

class Myclass
{
    list<Myclass> items = new List<Myclass>();
    List<Myclass> GetItems()
    {
     var result = items.SelectMany(a => a.GetItems()).Tolist();
     result.add(this);
     return result;
    }
}

Answer 4

递归伪码（无括号格式）：

function WalkList(List<Type> aList, int aLevel = 0)
   if (aList) //not null
       output aList.name, level after aLevel  spaces
       WalkList(aList.types, aLevel + 1) 

Answer 5

首先，如果您的班级看起来像这样，没有人可以访问它们 - 所有成员都是私人的，没有一个会初始化私人成员的Getters/Setters或公共构造仪。解决此问题后，转换代码如下：

List<AnotherType> convert(List<Type> tList) {
    if(tList == null)
        return null;
    List<AnotherType> retVal = new ArrayList<AnotherType>();
    for(Type t : tList) {
        List<AnotherType> aTypes = convert(t.types);
        retVal.add(new AnotherType(t.name, aTypes));
    }
    return retVal;
}