java List递归排序，无序的列表按照父级关系进行排序（两种排序类型）

Posted 2020-10-30 漂流的老妖怪

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java List递归排序，无序的列表按照父级关系进行排序（两种排序类型）相关的知识，希望对你有一定的参考价值。

当有一个List列表是无序的，List中的数据有parentid进行关联，通过java排序成两种排序类型：

所用的测试列表最顶级无parentid，若为特殊值，修改下判断方法即可。

第一种排序：按照树结构进行排序

排序前：122,13,121,1,131,12,132...
无序的
[TestSort [id=122, name=三级b, parentid=12], TestSort [id=13, name=二级b, parentid=1], TestSort [id=121, name=三级a, parentid=12], TestSort [id=1, name=一级, parentid=null], TestSort [id=131, name=三级c, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=132, name=三级d, parentid=13]]

排序后：1,13,131,132,12,122,121...
按照层级排序
[TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]

测试实体类：

/**
 * <p>部门列表排序测试类<p>
 * @version 1.0
 * @author li_hao
 * @date 2018年4月12日
 */
public class Dept {

	private String id;  //id
	private String name;  //名称
	private String parentid;  //父级id
	
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getParentid() {
		return parentid;
	}
	public void setParentid(String parentid) {
		this.parentid = parentid;
	}
	@Override
	public String toString() {
		return "TestSort [id=" + id + ", name=" + name + ", parentid=" + parentid + "]";
	}
	
	
}

排序代码（第一种排序）：

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.apache.commons.lang.StringUtils;

/**
 * <p>列表排序，按照树结构排序list（顶级无父节点）<p>
 * 排序前：122,13,121,1,131,12,132...
 * 无序的
 * [TestSort [id=122, name=三级b, parentid=12], TestSort [id=13, name=二级b, parentid=1], TestSort [id=121, name=三级a, parentid=12], TestSort [id=1, name=一级, parentid=null], TestSort [id=131, name=三级c, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=132, name=三级d, parentid=13]]
 * 
 * 排序后：1,13,131,132,12,122,121...
 * 按照树结构排序
 * [TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]
 * @version 1.0
 * @author li_hao
 * @date 2018年4月12日
 */
public class DeptSort {

	private List<Dept> resultList = new ArrayList<>();  //输出列表
	private List<Dept> deptList;  //输入列表
	
	/**
	 * 排序
	 * @param deptList
	 */
	public DeptSort(List<Dept> deptList){
		this.deptList = deptList;
		
		for(Dept dept : this.deptList){
			if(StringUtils.isBlank(dept.getParentid())){  //当父级为空
				resultList.add(dept);  //当父级为空时即顶级，首先放入输出列表
				findChildren(dept);  //查询下级
			}
		}
	}
	
	/**
	 * 查询下级
	 * @param dept
	 */
	private void findChildren(Dept dept){
		List<Dept> childrenList = new ArrayList<>();
		//遍历输入列表，查询下级
		for(Dept d : deptList){
			if(Objects.equals(dept.getId(), d.getParentid()))
				childrenList.add(d);
		}
		//遍历到最末端，无下级，退出遍历
		if(childrenList.isEmpty()){
			return;
		}
		//对下级进行遍历
		for(Dept d : childrenList){
			resultList.add(d);
			findChildren(d);
		}
	}
	
	public List<Dept> getResultList(){
		return resultList;
	}
	
	public static List<Dept> sort(List<Dept> originalList){
		return new DeptSort(originalList).getResultList();
	}
	
	/**
	 * 测试
	 * @param args
	 */
	public static void main(String[] args) {
		List<Dept> originalList = new ArrayList<>();
		Dept dept = new Dept();
		
		dept = new Dept();
		dept.setId("122");
		dept.setName("三级b");
		dept.setParentid("12");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("13");
		dept.setName("二级b");
		dept.setParentid("1");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("121");
		dept.setName("三级a");
		dept.setParentid("12");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("1");
		dept.setName("一级");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("131");
		dept.setName("三级c");
		dept.setParentid("13");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("12");
		dept.setName("二级a");
		dept.setParentid("1");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("132");
		dept.setName("三级d");
		dept.setParentid("13");
		originalList.add(dept);
		
		List<Dept> resultList = sort(originalList);
		System.out.println("输入列表："+ originalList);
	        System.out.println("输出列表："+ resultList);
	}
}

测试结果：

排序前：

[TestSort [id=122, name=三级b, parentid=12], TestSort [id=13, name=二级b, parentid=1], TestSort [id=121, name=三级a, parentid=12], TestSort [id=1, name=一级, parentid=null], TestSort [id=131, name=三级c, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=132, name=三级d, parentid=13]]

排序后：

[TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]

第二种排序：按照层级从上到下进行排序，同级的放一块

排序前：122,13,121,1,131,12,132...
无序的
[TestSort [id=122, name=三级b, parentid=12], TestSort [id=13, name=二级b, parentid=1], TestSort [id=121, name=三级a, parentid=12], TestSort [id=1, name=一级, parentid=null], TestSort [id=131, name=三级c, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=132, name=三级d, parentid=13]]

排序后：1,13,12,131,132,122,121...
按照层级排序
[TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=12, name=二级a, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]

排序代码（第二种排序）：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.TreeMap;
import org.apache.commons.lang.StringUtils;

/**
 * 
 * <p>列表排序，按照层级从上到下排序list，同级的放一块（顶级无父节点）<p>
 * * 排序前：122,13,121,1,131,12,132...
 * 无序的
 * [TestSort [id=122, name=三级b, parentid=12], TestSort [id=13, name=二级b, parentid=1], TestSort [id=121, name=三级a, parentid=12], TestSort [id=1, name=一级, parentid=null], TestSort [id=131, name=三级c, parentid=13], TestSort [id=12, name=二级a, parentid=1], TestSort [id=132, name=三级d, parentid=13]]
 * 
 * 排序后：1,13,12,131,132,122,121...
 * 按照层级排序
 * [TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=12, name=二级a, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]
 * @version 1.0
 * @author li_hao
 * @date 2018年4月12日
 */
public class DeptSort2 {

	private TreeMap<Integer, List<Dept>> treeMap;  //定义一个treeMap，key是等级，value是当前的等级对应的所有对象list
    private Integer level = 2;  //定义
    private List<Dept> resultList = new ArrayList();  //输出列表
    private List<Dept> deptList;  //输入列表
    
    /**
     * 排序
     * @param deptList
     */
    public DeptSort2(List<Dept> deptList) {
        this.deptList = deptList;

        for (Dept dept : this.deptList) {
            if (StringUtils.isBlank(dept.getParentid())) {  //当父级为空
                resultList.add(dept);  ////当父级为空时即顶级，首先放入输出列表
                treeMap = new TreeMap<>();
                findChildren(dept);  //查询下级
                Iterator it = treeMap.keySet().iterator();  //迭代treeMap
                while (it.hasNext()) {  //检查序列中是否还有元素,如果迭代中还有元素返回true(因为treeMap中放的是2级和2级下面的所有list，所以只需要判断it.hashNext)
                    resultList.addAll(treeMap.get(it.next()));  //把treeMap中所有的list按照层级顺序添加到resultList中
                }
            }
        }
    }

    /**
     * 查询下级部门
     * 方法进去的时候就记录当前层级数，findchildren方法走完的时候，表示这一层已经没有逻辑了，递归回上一层，所以 this点level减一
     * @param dept
     */
    private void findChildren(Dept dept) {
        Integer level = this.level++;  ////第一次进来时level值为2，this.level值为3
        try {
            List<Dept> childrenList = new ArrayList<>();
            //遍历输入列表，查询下级
            for (Dept d : deptList) {
                if (Objects.equals(dept.getId(), d.getParentid()))
                    childrenList.add(d);
            }
            //遍历到最末端，无下级，退出遍历
            if (childrenList.isEmpty()) {
                return;
            }
            //对下级进行遍历
            for (Dept d : childrenList) {
                addToMap(level, d); //给treeMap中添加等级和对应dept(第一次执行的level值为2)
                findChildren(d);  //查询下级，(比如：第一次进来时level值为2，this.level值为3，在进入此方法后，level为3，this.level为4，没查到则跳出，level减一)
            }
        } finally {
            this.level--;  //由于再次执行findChildren时，this.level的值+1了，那么在执行完毕后需要finally：this.level--
        }
    }
    
    void addToMap(Integer level, Dept dept) {
        if (Objects.isNull(treeMap.get(level)))  
            treeMap.put(level, new ArrayList<Dept>());  //若treeMap中无等级
        treeMap.get(level).add(dept);  //若treeMap中有等级，则添加dept
    }

    public List<Dept> getResultList() {
        return resultList;
    }
    
    public static List<Dept> sort(List<Dept> originalList) {
        return new DeptSort2(originalList).getResultList();
    }

    public static void main(String[] args) {
        List<Dept> originalList = new ArrayList<>();
        Dept dept = new Dept();
        
        dept = new Dept();
		dept.setId("122");
		dept.setName("三级b");
		dept.setParentid("12");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("13");
		dept.setName("二级b");
		dept.setParentid("1");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("121");
		dept.setName("三级a");
		dept.setParentid("12");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("1");
		dept.setName("一级");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("131");
		dept.setName("三级c");
		dept.setParentid("13");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("12");
		dept.setName("二级a");
		dept.setParentid("1");
		originalList.add(dept);
		
		dept = new Dept();
		dept.setId("132");
		dept.setName("三级d");
		dept.setParentid("13");
		originalList.add(dept);

        List<Dept> resultList = DeptSort2.sort(originalList);
        System.out.println("输入列表："+ originalList);
	    System.out.println("输出列表："+ resultList);
    }
}

测试结果：

排序前：

排序后：

[TestSort [id=1, name=一级, parentid=null], TestSort [id=13, name=二级b, parentid=1], TestSort [id=12, name=二级a, parentid=1], TestSort [id=131, name=三级c, parentid=13], TestSort [id=132, name=三级d, parentid=13], TestSort [id=122, name=三级b, parentid=12], TestSort [id=121, name=三级a, parentid=12]]

以上是关于java List递归排序，无序的列表按照父级关系进行排序（两种排序类型）的主要内容，如果未能解决你的问题，请参考以下文章

python 快速排序的实现

JAVA的集合类型都有哪些

Java面试题｜ListSetMap 之间的区别是什么？

题解 P1706 全排列问题

Java MySQL递归子级父级，构建树结构