找到层次结构

Question

让我们考虑一下java中的一个类

class Entity  {

Integer id;
Integer parentId;

public Integer getId() {
    return id;
}

public void setId(Integer id) {
    this.id = id;
}

public Integer getParentId() {
    return parentId;
}

public void setParentId(Integer parentId) {
    this.parentId = parentId;
}


}
 }

将parentId视为外键(与另一个对象的id相关)。

现在我创建了6个对象并放置了一些值。

Entity e1 = new Entity();
    e1.setId(400);

    Entity e2 = new Entity();
    e2.setId(300);
            e2.setParentId(400);

    Entity e3 = new Entity();
    e3.setId(200);
    e3.setParentId(300);

    Entity e4 = new Entity();
    e4.setId(100);
            e4.setParentId(200);

    Entity e5 = new Entity();
    e5.setId(50);
            e5.setParentId(100);

    Entity e6 = new Entity();
    e6.setParentId(50);

现在我想获得对象的层次结构。这意味着如果我给出id，我应该得到完整的父层次结构和子层次结构。

如果我给出100个id(实体: e4)，我应该得到父层次结构：- e4、e3、e2、e1子层次结构：- e4、e5、e6

说明：-对于父层次结构：-我们应该首先添加初始的e4对象。然后，我们将找到其iD与e4的parentid相同的对象。(在这里，e3)进程一直持续到子层次结构，父母亲为null：-我们应该首先添加初始的e4对象。然后，我们将找到其parentId与e4的id相同的对象。(这里是e5)进程一直持续到父进程为null

解决方案，由我为父层次结构：-

 List<Entity> parent = new ArrayList<Entity>();

    Entity ent = list.stream().filter(e -> e.getId() == 100).findFirst()
            .get(); // // 100 input id value

    parent.add(ent);

    Integer parentId = ent.getParentId();

    while (parentId != null) {

        int search = parentId;
        Entity newEntity = list.stream().filter(e -> e.getId() == search)
                .findFirst().get();

        parent.add(newEntity);
        parentId = newEntity.getParentId();
    }

对于儿童等级：

    Entity entnew = list.stream().filter(e -> e.getId() == 100).findFirst()
            .get(); // 100 input id value



    child.add(entnew);


    Integer idNew = entnew.getId();


    while (idNew != null) {

    int searchNew = idNew;

    Entity newEnt = list.stream().filter(f -> f.getParentId()!= null && f.getParentId() == searchNew)
            .findFirst().get();

    child.add(newEnt);
    idNew = newEnt.getId();

    }

我找到了这个方法来解决这个场景，但是我希望在java 8中使用它的核心概念来解决这个问题。

Answer 1

我找到了一个更像Java8的解决方案，带有函数编程的味道。

给定您的六个实体(请注意，我已经为e6设置了Id，否则我们将得到一个NullPointerException)：

Entity e1 = new Entity();
e1.setId(400);

Entity e2 = new Entity();
e2.setId(300);
e2.setParentId(400);

Entity e3 = new Entity();
e3.setId(200);
e3.setParentId(300);

Entity e4 = new Entity();
e4.setId(100);
e4.setParentId(200);

Entity e5 = new Entity();
e5.setId(50);
e5.setParentId(100);

Entity e6 = new Entity();
e6.setId(25); // this Id must be set, or we'll get a NPE
e6.setParentId(50);

以及一份载有这些内容的清单：

List<Entity> list = new ArrayList<>();
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
list.add(e5);
list.add(e6);

然后，对于父母等级：

Function<Integer, Entity> byId = 
    id -> list.stream()
        .filter(e -> e.getId().equals(id))
        .findFirst()
        .orElse(null);

Entity parentsSeed = byId.apply(100); // e4

UnaryOperator<Entity> nextParent = 
    e -> e == null ? e : byId.apply(e.getParentId());

List<Entity> parents = 
    Stream.iterate(parentsSeed, nextParent)
        .limit(list.size())
        .filter(Objects::nonNull)
        .collect(Collectors.toList()); // [e4, e3, e2, e1]

至于儿童等级制度：

Entity childrenSeed = byId.apply(100); // e4

Function<Integer, Entity> byParentId = 
    id -> list.stream()
        .filter(e -> id.equals(e.getParentId()))
        .findFirst()
        .orElse(null);

UnaryOperator<Entity> nextChild = 
    e -> e == null ? e : byParentId.apply(e.getId());

List<Entity> children = 
    Stream.iterate(childrenSeed, nextChild)
        .limit(list.size())
        .filter(Objects::nonNull)
        .collect(Collectors.toList()); // [e4, e5, e6]

其思想是使用Stream.iterate()方法，通过"functional“迭代创建流。

对于父母，我创建了一个UnaryOperator (一个函数)，该函数给定一个Entity，返回它的父Entity或null；对于子Entity或null，我创建了一个给定Entity的UnaryOperator，该UnaryOperator返回其子Entity或null。

为了执行这两个搜索，我使用了另一个Function，它分别通过id和parentId搜索list。

Answer 2

我会为对象、父级和子级创建查找表：

List<Integer> ancestors = new ArrayList<>();
List<Integer> descendants = new ArrayList<>();
Map<Integer, Entity> objectById = list.stream().collect(Collectors.toMap(e ->e.getId(), e->e));
Map<Integer, Integer> parentIdByChildId = list.stream().collect(Collectors.toMap(e->e.getId(), e ->e.getParentId());
Map<Integer, Integer> childIdByParentId = list.stream().collect(Collectors.toMap(e ->e.getParentId(), e->e.getId());
Integer parentId = 10;
Integer current = parentId;
while(current!=null) {
    current = childIdByParentId.get(current);
    if(current!=null){
        descendants.add(objectById.get(current));
    }
}
current = parentId;
while(current!=null) {
    current = parentIdByChildId.get(current);
    if(current!=null){
        ancestors.add(objectById.get(current));
    }
}   

这不支持具有多个子实体的实体，您可能需要检查java.util.stream.Collectors.groupBy示例

Answer 3

是否必须使用int ids链接到父节点？取决于你想要达到的目标，但你就不能像这样联系：

class Entity  {
    Integer id;
    Entity  parent;
}

这样，一旦你有了第一个实体，你就不必搜索你的整个列表了。