找到层次结构

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

给定您的六个实体（请注意，我已经设置了 Id e6，否则我们会得到一个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搜索，分别简单地搜索listbyid和parentId。