如何在java中将树结构转换成节点流

Question

我想转换Java8节点流中的一棵树。

下面是一个存储数据的节点树，可以选择：

public class SelectTree<D> {

  private D data;

  private boolean selected = false;

  private SelectTree<D> parent;

  private final List<SelectTree<D>> children = new ArrayList<>();

  public SelectTree(D data, SelectTree<D> parent) {
    this.data = data;
    if (parent != null) {
      this.parent = parent;
      this.parent.getChildren().add(this);
    }
  }

  public D getData() {
    return data;
  }

  public void setData(D data) {
    this.data = data;
  }

  public boolean isSelected() {
    return selected;
  }

  public void setSelected(boolean selected) {
    this.selected = selected;
  }

  public SelectTree<D> getParent() {
    return parent;
  }

  public void setParent(SelectTree<D> parent) {
    this.parent = parent;
  }

  public List<SelectTree<D>> getChildren() {
    return children;
  }

  public boolean isRoot() {
    return this.getParent() == null;
  }

  public boolean isLeaf() {
    return this.getChildren() == null || this.getChildren().isEmpty();
  }
}

我想获取所选数据的集合

我想做这样的事情：

  public static void main(String[] args) {
    SelectTree<Integer> root = generateTree();
    
    List<Integer> selectedData = root.stream()
            .peek(node -> System.out.println(node.getData()+": "+node.isSelected()))
            .filter(node-> node.isSelected())
            .map(node-> node.getData())
            .collect(Collectors.toList()) ;
    
    System.out.println("\nselectedData="+selectedData);
  }

  private static SelectTree<Integer> generateTree() {
    SelectTree<Integer> n1 = new SelectTree(1, null);
    SelectTree<Integer> n11 = new SelectTree(11, n1);
    SelectTree<Integer> n12 = new SelectTree(12, n1);
    n12.setSelected(true);
    SelectTree<Integer> n111 = new SelectTree(111, n11);
    n111.setSelected(true);
    SelectTree<Integer> n112 = new SelectTree(112, n11);
    SelectTree<Integer> n121 = new SelectTree(121, n12);
    SelectTree<Integer> n122 = new SelectTree(122, n12);
    return n1;
  }

问题是找到stream（）的实现，我想我可以帮助一些人分享我的解决方案，我很想知道是否有一些问题或更好的方法来做到这一点。

起初，它是用于primefaceTreeNode的，但我将问题推广到所有类型的树。

Answer 1

使用任何节点类的更通用方法是为方法添加一个参数，该参数返回子级：

public class TreeNodeStream {
  public static <T> Stream<T> of(T node, Function<T, Collection<? extends T>> childrenFunction) {
    return Stream.concat( //
      Stream.of(node), //
      childrenFunction.apply(node).stream().flatMap(n -> of(n, childrenFunction)));
  }
}

使用文件的示例：

TreeNodeStream.of(
  new File("."), f -> f.isDirectory() ? Arrays.asList(f.listFiles()) :
                                        Collections.emptySet())
  .filter(f -> f.getName().endsWith(".java"))
  .collect(Collectors::toList);

Answer 2

我发现stream（）的这个实现，它是DFS树遍历：

public class SelectTree<D> {

  //...

  public Stream<SelectTree<D>> stream() {
    if (this.isLeaf()) {
      return Stream.of(this);
    } else {
      return this.getChildren().stream()
                .map(child -> child.stream())
                .reduce(Stream.of(this), (s1, s2) -> Stream.concat(s1, s2));
    }
  }
}

如果不能像prime faces < code > TreeNode (< code > org . prime faces . model . TreeNode )那样更改树实现，可以在另一个类中定义一个方法:

  public Stream<TreeNode> stream(TreeNode parentNode) {
    if(parentNode.isLeaf()) {
      return Stream.of(parentNode);
    } else {
      return parentNode.getChildren().stream()
                .map(childNode -> stream(childNode))
                .reduce(Stream.of(parentNode), (s1, s2) -> Stream.concat(s1, s2)) ;
    }
  }

Answer 3

克维萨茨回答的一个小补充。

该实现:

this.getChildren().stream()
        .map(SelectTree::stream)
        .reduce(Stream.of(this), Stream::concat);

会更急切，即。e.整个层次结构将在流创建期间遍历。如果您的层次结构很大，比如说，您正在寻找与某些谓词匹配的单个节点，您可能需要更懒惰的行为：

Stream.concat(Stream.of(this),
              this.getChildren().stream().flatMap(SelectTree::stream));

在这种情况下，在流创建期间只会检索根节点的子节点，搜索节点不一定会导致遍历整个层次结构。

这两种方法都将显示 DFS 迭代顺序。