父子关系树或列表排序

父子关系列表排序

父节点在前，子节点在后

/**
  * 按父子节点排序，父节点在子节点前面
  *
  * @param departs 列表
  * @return 排序列表
  */
public static List<Depart> sort(List<Depart> departs) {
  // 先找出所有的 root 元素
  Queue<Depart> queues = departs.stream()
    .filter(d -> d.getParentId() == null || -1L == d.getParentId())
    .collect(Collectors.toCollection(LinkedList::new));
  return findChildren(departs, queues);
}

private static List<Depart> findChildren(List<Depart> departs, Queue<Depart> queues) {
  List<Depart> childrenList = new ArrayList<>();
  while (queues.size() > 0) {
    // 弹出队列
    Depart poll = queues.poll();
    childrenList.add(poll);
    for (Depart depart : departs) {
      if (Objects.equals(depart.getParentId(), poll.getId())) {
        // 加入队列
        queues.offer(depart);
      }
    }
  }
  return childrenList;
}

倒序迭代

for (int i = departs.size() - 1; i >= 0; i--) {
  Depart depart = departs.get(i);
  log.info("部门 ---> depart: {}", depart);
}

树结构数据

import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 树结构
 */
@Data
@NoArgsConstructor
public class TreeNode implements Serializable {
    private static final long serialVersionUID = 3083223582409151873L;

    private String id;
    private String label;
    private String parentId;
    private List<TreeNode> children = new ArrayList<>();

    /**
     * 根据列表，构建树结构
     *
     * @param list   列表
     * @param rootId 根节点 Id
     * @return 树结构数据
     */
    public static List<TreeNode> convert(List<TreeNode> list, String rootId) {
        List<TreeNode> tree = new ArrayList<>();
        Iterator<TreeNode> iterator = list.iterator();
        while (iterator.hasNext()) {
            TreeNode node = iterator.next();
            String parentId = node.getParentId();
            // 根节点
            if (ObjectUtils.isEmpty(parentId) || rootId.equals(parentId)) {
                tree.add(node);
                iterator.remove();
            }
        }

        for (TreeNode node : tree) {
            List<TreeNode> children = TreeNode.getChildren(node, list);
            node.getChildren().addAll(children);
        }
        return tree;
    }

    /**
     * 获取子节点数据
     *
     * @param parentNode 父节点
     * @param list       所有节点集合
     * @return 返回子节点列表
     */
    private static List<TreeNode> getChildren(TreeNode parentNode, List<TreeNode> list) {
        List<TreeNode> children = new ArrayList<>();
        Iterator<TreeNode> iterator = list.iterator();
        while (iterator.hasNext()) {
            TreeNode node = iterator.next();
            // 如果当前节点 ID 与父节点 ID 一致，表示当前数据是该节点的子节点
            if (parentNode.getId().equals(node.getParentId())) {
                children.add(node);
                iterator.remove();
            }
        }
        // 递归调用
        for (TreeNode node : children) {
            // 调用自身方法，依次添加子节点数据
            node.getChildren().addAll(getChildren(node, list));
        }
        return children;
    }
}