查找层次结构 让我们考虑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为null 对于子层次结构：-我们应该首先添加初始e4对象。然后，我们将找到其parentId与e4的id相同的对象。（此处为e5）该过程将继续，直到parentId为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();
    }

---

我发现这个方法可以解决这个问题，但是我想要一个在java 8中使用其核心概念的更有效的解决方案来解决这个问题。

您必须使用int-id链接到父级吗？取决于你想要实现的目标，但你不能这样链接：

class Entity  {
    Integer id;
    Entity  parent;
}

---

一旦有了第一个实体，您就不必搜索整个列表。

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

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

List祖先=新建ArrayList（）；
列表子体=新的ArrayList（）；
Map objectById=list.stream（）.collect（Collectors.toMap（e->e.getId（），e->e））；
Map parentIdByChildId=list.stream（）.collect（Collectors.toMap（e->e.getId（），e->e.getParentId（））；
Map childIdByParentId=list.stream（）.collect（Collectors.toMap（e->e.getParentId（），e->e.getId（））；
整数parentId=10；
整数当前=父ID；
while（当前！=null）{
current=childIdByParentId.get（当前）；
如果（当前！=null）{
add（objectById.get（当前））；
}
}
当前=父ID；
while（当前！=null）{
current=parentIdByChildId.get（当前）；
如果（当前！=null）{
add（objectById.get（当前））；
}
}   

---

这不支持具有多个子项的实体，您可能希望查看java.util.stream.Collectors.groupBy的示例。我发现了一个更具Java8风格的解决方案，带有函数式编程的味道

考虑到您的六个实体（请注意，我已经为

e6

设置了Id，否则我们会得到

NullPointerException

）：

以及一份载有这些文件的清单：

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

List List=new ArrayList（）；
列表。添加（e1）；
增加（e2）；
列表。添加（e3）；
增加（e4）；
列表。添加（e5）；
增加（e6）；

然后，对于父级层次结构：

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

    }

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]

函数byId=
id->list.stream（）
.filter（e->e.getId（）.equals（id））
.findFirst（）
.orElse（空）；
实体parentsSeed=byId.apply（100）；//e4
一元运算符nextParent=
e->e==null？e:byId.apply（e.getParentId（））；
列出家长=
Stream.iterate（parentsSeed，nextParent）
.limit（list.size（））
.filter（对象：：非空）
.collect（Collectors.toList（））；//[e4、e3、e2、e1]

对于儿童层次结构：

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

    }

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]

Entity childrenSeed=byId.apply（100）；//e4
函数byParentId=
id->list.stream（）
.filter（e->id.equals（e.getParentId（）））
.findFirst（）
.orElse（空）；
一元运算符nextChild=
e->e==null？e:byParentId.apply（e.getId（））；
列出子项=
Stream.iterate（childrenSeed，nextChild）
.limit（list.size（））
.filter（对象：：非空）
.collect（collector.toList（））；//[e4、e5、e6]

其思想是使用

Stream.iterate（）

方法，通过“函数式”迭代创建流

对于家长，我创建了一个

UnaryOperator

（一个函数），给定一个

实体

，它将返回其父

实体

或

空

；对于孩子，我创建了一个

UnaryOperator

，给定一个

实体

，它将返回其子

实体

或

空

---

为了执行这两个搜索，我使用了另一个

函数

，分别通过

id

和

parentId

搜索

列表

。

这是你为什么保留

parentId

而不是引用parent的原因吗？我认为你应该提供一个关于这个问题的解决方案，而不是通过编辑问题为某个问题选择合适的数据结构至少与算法本身一样重要。如果使用不适合该问题的数据结构，算法可能会变得缓慢而复杂。因此，我问是否有任何理由必须使用此数据结构。