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），该过程继续，直到parentid为空对于子层次结构： - 我们应该首先添加初始e4对象。然后我们将找到其parentId与e4的id相同的对象。（这里是e5）这个过程一直持续，parentid为空

我的解决方案 对于父级层次结构： -

 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-ish解决方案，带有函数式编程的味道。

鉴于您的六个实体（请注意我已为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()方法，通过“功能”迭代创建流。

对于家长，我创建了UnaryOperator（一个函数），给定Entity，返回其父Entity或null;对于儿童，我创建了一个UnaryOperator，如果Entity，则返回其子Entity或null。

要执行这两项搜索，我使用了另一个Function，只需分别按list和id搜索parentId。

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 ID链接到父级？取决于你想要达到的目标，但你不能像这样链接：

class Entity  {
    Integer id;
    Entity  parent;
}

然后，一旦拥有第一个实体，就不必搜索整个列表。

找到层次结构

3 个答案: