1. import java.util.List;
    3. public class TreeDto {
    5.     public TreeDto(String id, String pid, String name, String treeNo){
    6.         this.id=id;
    7.         this.pid = pid;
    8.         this.name = name;
    9.         this.treeNo = treeNo;
    10.     }
    11.     private String id;
    12.     private String pid;//fatherid
    13.     private String name;
    14.     private String treeNo;
    15.     private List<TreeDto> children;
    16.     //省略get和set
    17. }
    1. import dto.TreeDto;
    3. import com.alibaba.fastjson.JSON;
    4. import java.util.ArrayList;
    5. import java.util.HashMap;
    6. import java.util.List;
    7. import java.util.Map;
    9. public class listToTreeTest {
    11.     public static void main(String[] args) {
    12.         TreeDto treeDto1 = new TreeDto("1","0","学生1","01");
    13.         TreeDto treeDto2 = new TreeDto("11","1","家长1","0101");
    14.         TreeDto treeDto3 = new TreeDto("12","1","家长2","0102");
    15.         TreeDto treeDto4 = new TreeDto("2","0","学生2","02");
    16.         TreeDto treeDto5 = new TreeDto("3","0","学生3","03");
    17.         TreeDto treeDto6 = new TreeDto("4","11","第3层","010101");
    18.         List<TreeDto> testTree = new ArrayList<>();
    19.         testTree.add(treeDto1);
    20.         testTree.add(treeDto2);
    21.         testTree.add(treeDto3);
    22.         testTree.add(treeDto4);
    23.         testTree.add(treeDto5);
    24.         testTree.add(treeDto6);
    25.         System.out.println(JSON.toJSON(listToTree(testTree)));
    26.     }
    28.     // 列表转树结构
    29.     private static List<TreeDto> listToTree(List<TreeDto> oldList){
    30.         Map<String,Object> newMap = new HashMap<>();
    31.         List<TreeDto> newList = new ArrayList<>();
    32.         for (TreeDto treeDto : oldList){
    33.             newMap.put(treeDto.getId(),treeDto);
    34.         }
    36.         for (TreeDto treeDto : oldList){
    37.             TreeDto parent = (TreeDto) newMap.get(treeDto.getPid());
    38.             if (parent != null){
    39.                 if (parent.getChildren() == null){
    40.                     List<TreeDto> ch = new ArrayList<>();
    41.                     ch.add(treeDto);
    42.                     parent.setChildren(ch);
    43.                 }else {
    44.                     List<TreeDto> ch = parent.getChildren();
    45.                     ch.add(treeDto);
    46.                     parent.setChildren(ch);
    47.                 }
    48.             }else {
    49.                 newList.add(treeDto);
    50.             }
    51.         }
    52.         return newList;
    53.     }
    54. }

    把方法里面需要用到的字段放到父类里面，需要转成树的类继承父类，就能改成通用的。考虑到如果需要转换的类都已经继承了某一公共类不能再继承了，改成抽象，抽象出id，父id和子集，重写就能用。

    1. package myBaseTree;
    3. import java.util.ArrayList;
    4. import java.util.HashMap;
    5. import java.util.List;
    6. import java.util.Map;
    8. public abstract class list2tree<N> {
    10.     /**
    11.      * 获取节点唯一标识方法
    12.      * @param node
    13.      * @return
    14.      */
    15.     protected abstract String getKey(N node);
    17.     /**
    18.      * 获取节点父节点唯一标识方法
    19.      * @param node
    20.      * @return
    21.      */
    22.     protected abstract String getParentId(N node);
    24.     /**
    25.      * 子节点
    26.      * @param node
    27.      * @return
    28.      */
    29.     protected abstract List<N> getChildrens(N node);
    31.     protected abstract void setChildrens(List<N> nodes,N node);
    34.     /**
    35.      * 生成树方法
    36.      * @param oldList
    37.      * @return
    38.      */
    39.     //@Override
    40.     public List<N> listToTree(List<N> oldList) {
    41.         Map<String,Object> newMap = new HashMap<>();
    42.         List<N> newList = new ArrayList<>();
    43.         for (N tree : oldList){
    44.             newMap.put(getKey(tree),tree);
    45.         }
    46.         for (N tree : oldList){
    47.             N parent = (N) newMap.get(getParentId(tree));
    48.             if (parent != null){
    49.                 if (getChildrens(parent) == null){
    50.                     List<N> ch = new ArrayList<>();
    51.                     ch.add(tree);
    52.                     setChildrens(ch,parent);
    53.                 }else {
    54.                     List<N> ch = getChildrens(parent);
    55.                     ch.add(tree);
    56.                     setChildrens(ch,parent);
    57.                 }
    58.             }else {
    59.                 newList.add(tree);
    60.             }
    61.         }
    62.         return newList;
    63.     }
    64. }

    测试：

    1. package finTree;
    3. import com.alibaba.fastjson.JSON;
    4. import dto.TreeDto;
    5. import myBaseTree.list2tree;
    7. import java.util.ArrayList;
    8. import java.util.List;
    10. public class mainTest {
    12.     private static final list2tree list2tree = new list2tree<TreeDto>() {
    14.            @Override
    15.         protected String getKey(TreeDto node) {
    16.             return node.getId();
    17.         }
    19.         @Override
    20.         protected String getParentId(TreeDto node) {
    21.             return node.getPid();
    22.         }
    24.         @Override
    25.         protected List<TreeDto> getChildrens(TreeDto node) {
    26.             return node.getChildren();
    27.         }
    29.         @Override
    30.         protected void setChildrens(List<TreeDto> nodes, TreeDto node) {
    31.             node.setChildren(nodes);
    32.         }
    33.     };
    35.     public static void main(String[] args) {
    36.         TreeDto treeDto1 = new TreeDto("1","0","学生1","01");
    37.         TreeDto treeDto2 = new TreeDto("11","1","家长1","0101");
    38.         TreeDto treeDto3 = new TreeDto("12","1","家长2","0102");
    39.         TreeDto treeDto4 = new TreeDto("2","0","学生2","02");
    40.         TreeDto treeDto5 = new TreeDto("3","0","学生3","03");
    41.         TreeDto treeDto6 = new TreeDto("4","11","第3层","010101");
    43.         List<TreeDto> testTree = new ArrayList<>();
    44.         testTree.add(treeDto1);
    45.         testTree.add(treeDto2);
    46.         testTree.add(treeDto3);
    47.         testTree.add(treeDto4);
    48.         testTree.add(treeDto5);
    49.         testTree.add(treeDto6);
    51.         System.out.println(JSON.toJSON(list2tree.listToTree(testTree)));
    53.     }
    54. }

    接口式通用方法

    1. import java.util.List;
    3. public interface List2TreeField<T> {
    5.     String getKey(T node);
    7.     String getParentId(T node);
    9.     List<T> getChildrens(T node);
    11.     void setChildrens(List<T> nodes, T node);
    13. }
    1. import java.util.ArrayList;
    2. import java.util.HashMap;
    3. import java.util.List;
    4. import java.util.Map;
    7. public class List2TreeUtil<T> {
    9.     public List<T> runTest(List<T> oldList, List2TreeField<T> t) {
    10.         Map<String,Object> newMap = new HashMap<>();
    11.         List<T> newList = new ArrayList<>();
    12.         for (T tree : oldList){
    13.             newMap.put(t.getKey(tree),tree);
    14.         }
    15.         for (T tree : oldList){
    16.             T parent = (T) newMap.get(t.getParentId(tree));
    17.             if (parent != null){
    18.                 if (t.getChildrens(parent) == null){
    19.                     List<T> ch = new ArrayList<>();
    20.                     ch.add(tree);
    21.                     t.setChildrens(ch,parent);
    22.                 }else {
    23.                     List<T> ch = t.getChildrens(parent);
    24.                     ch.add(tree);
    25.                     t.setChildrens(ch,parent);
    26.                 }
    27.             }else {
    28.                 newList.add(tree);
    29.             }
    30.         }
    31.         return newList;
    32.     }
    34. }
    1.     public static void main(String[] args) {
    2.         TreeDto treeDto1 = new TreeDto("1","0","学生1","01");
    3.         TreeDto treeDto2 = new TreeDto("11","1","家长1","0101");
    4.         TreeDto treeDto3 = new TreeDto("12","1","家长2","0102");
    5.         TreeDto treeDto4 = new TreeDto("2","0","学生2","02");
    6.         TreeDto treeDto5 = new TreeDto("3","0","学生3","03");
    7.         TreeDto treeDto6 = new TreeDto("4","11","第3层","010101");
    8.         List<TreeDto> testTree = new ArrayList<>();
    9.         testTree.add(treeDto1);
    10.         testTree.add(treeDto2);
    11.         testTree.add(treeDto3);
    12.         testTree.add(treeDto4);
    13.         testTree.add(treeDto5);
    14.         testTree.add(treeDto6);
    16.         List<TreeDto> list = new List2TreeUtil().runTest(testTree, new List2TreeField<TreeDto>() {
    17.             @Override
    18.             public String getKey(TreeDto node) {
    19.                 return node.getId();
    20.             }
    21.             @Override
    22.             public String getParentId(TreeDto node) {
    23.                 return node.getPid();
    24.             }
    25.             @Override
    26.             public List<TreeDto> getChildrens(TreeDto node) {
    27.                 return node.getChildren();
    28.             }
    29.             @Override
    30.             public void setChildrens(List<TreeDto> nodes, TreeDto node) {
    31.                 node.setChildren(nodes);
    32.             }
    33.         });
    34.         System.out.println(JSON.toJSON(list));
    35.     }