Java 树形结构和List＜?＞ 相互转换

1、基础对象

package org.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car implements Serializable {
    private Integer id;
    private Integer parentId ;
    private Integer size ;
}

2、扩展对象和操作方法

package org.example;

import _20230221_tree.Department;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import lombok.*;
import org.springframework.beans.BeanUtils;
import org.springframework.util.ObjectUtils;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

@ToString
@Data
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)

public class CarExtend extends Car implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer level;
    private List<Integer> total;
    private List<Integer> chilNode;
    private List<CarExtend> children;
    private List<String> node;

    public CarExtend(Integer id, Integer parentId, Integer size, Integer level, List<Integer> total, List<Integer> chilNode, List<CarExtend> chilren) {
        super(id, parentId, size);
        this.level = level;
        this.total = total;
        this.chilNode = chilNode;
        this.children = chilren;
    }

    public CarExtend(Integer level, List<Integer> total, List<Integer> chilNode, List<CarExtend> chilren) {
        this.level = level;
        this.total = total;
        this.chilNode = chilNode;
        this.children = chilren;
    }

    /**
     * 父类转换成子类，增加属性
     * @param list 父类list
     * @return 子类list
     */
    public static List<CarExtend> getCarExtendList(List<Car> list) {
        List<CarExtend> carExtends = new ArrayList<>();
        for (Car car : list) {
            CarExtend carExtend = new CarExtend();
            BeanUtils.copyProperties(car, carExtend);
            carExtend.setLevel(null);
            carExtends.add(carExtend);
        }
        return carExtends;
    }

    /**
     * 转换成树形结构
     * @param list 父类list
     * @param pid 父类id
     * @return 树形
     */
    public static List<CarExtend> getTree(List<CarExtend> list, int pid) {
        List<CarExtend> tree = new ArrayList<>();
        for (CarExtend car : list) {
            if (car.getParentId().equals(pid)) {
                car.setChildren(getTree(list, car.getId()));
                tree.add(car);
            }
        }
        return tree;
    }

    /**
     * 树形，检查节点是否存在
     * @param tree 树形结构数据
     * @param id 节点Id
     * @return 节点对象
     */
    public static int checkNode(List<CarExtend> tree, int id ) {
        int level = 1 ;
        for (CarExtend car : tree){
            if(car.getId().equals(id)){
                return level;
            }else{
                if(car.getChildren().size() > 0 ){
                    getLevel(car.getChildren(),id);
                }
            }
        }
        return level;
    }

    /**
     * 获取某个节点下，所有的数据
     * @param list
     * @return
     */
    public static List<CarExtend> getNodeEntity(List<CarExtend> list){
        List<CarExtend> ids = new ArrayList<>();
        for (CarExtend car : list){
            ids.add(car);
            if(car.getChildren().size()>0){
                ids.addAll(getNodeEntity(car.getChildren()));
            }
        }
        return ids;
    }

    /**
     * 获取父节点信息
     * @param list 节点数据
     * @param nodeId 节点ID
     * @return 父节点信息
     */
    public static CarExtend getParentId(List<CarExtend> list, Integer nodeId){
        for (CarExtend car : list){
            if(nodeId.equals(car.getId())){
                return car;
            }
        }
        return null;
    }

    /**
     * 获取层数
     * @param list  节点数据
     * @param nodeId  节点ID
     * @return 层数
     */
    public static int getLevel(List<CarExtend> list,Integer nodeId){
        int i = 1 ;
        while (true){
            CarExtend subCar = getParentId(list,nodeId);
            if(ObjectUtil.isNull(subCar)){
                break;
            }
            nodeId = subCar.getParentId();
            i++;
        }
        return i;
    }

    /**
     * 获取最大层数
     * @param list 节点数据
     * @return 最大层数
     */
    public static int getMaxLevel(List<CarExtend> list) {
        int maxLevel  =  1 ;
        for (CarExtend car :list){
           int level = getLevel(list,car.getParentId());
           if(level > maxLevel) maxLevel = level ;
        }
        return maxLevel;
    }

    /**
     * 把树转成list
     * @param lists 节点数据
     * @return list
     */
    public static List<CarExtend> getList(List<CarExtend> lists){
        List<CarExtend> list = new ArrayList<>();
        for (CarExtend car : lists){
            new CarExtend().treeToList(car,list);
        }
        return list;
    }

    /**
     * 将tree结构数据转成List结构
     * @param list 节点数据
     */
    public void treeToList(CarExtend node,List<CarExtend> list){
        if(ObjectUtil.isNull(list)) list =  new ArrayList<CarExtend>();
        CarExtend nodeValue = new CarExtend(
                node.getId(), node.getParentId(), node.getSize(), node.getLevel(),
                node.getTotal(), node.getChilNode(),null );//node.getChilren()
        list.add(nodeValue);
        if(ObjectUtil.isNotNull(list) && list.size() > 0 ){
            for (int i = 0; i < node.getChildren().size(); i++) {
                CarExtend node_= node.getChildren().get(i);
                treeToList(node_,list);
            }
        }
    }

}

3、实践

package org.example;

import java.util.ArrayList;
import java.util.List;

public class App {
    public static void main(String[] args) {
        List<Car> cars = new ArrayList<>();
        cars.add(new Car(1, 0, 50));
        cars.add(new Car(2, 1, 60));
        cars.add(new Car(3, 1, 70));
        cars.add(new Car(4, 2, 80));
        cars.add(new Car(5, 2, 90));
        cars.add(new Car(6, 3, 100));
        cars.add(new Car(9, 6, 130));
        cars.add(new Car(10, 6, 140));
        cars.add(new Car(11, 9, 150));
        cars.add(new Car(12, 9, 160));
        cars.add(new Car(13, 12, 160));
        cars.add(new Car(7, 0, 110));
        cars.add(new Car(8, 7, 120));
        //获取子类对象
        List<CarExtend> carList = CarExtend.getCarExtendList(cars);
        //转换树形
        List<CarExtend> tree = CarExtend.getTree(carList,0);
        //树形转换成list
        List<CarExtend> list = CarExtend.getList(tree);
        //获取树高
        int maxLevel = CarExtend.getMaxLevel(list);
        //获取每个节点高度
        for(CarExtend car : list){
            System.out.println(CarExtend.getLevel(list,car.getParentId()));
        }
    }
}