实现Comparable接口对树形结构数据进行排序

标签：

背景：

数据库中无序的数据要按树形结构出输出，

如图所示：

每一个记录 对应 一条数据库的 数据，

需求来了，那么怎么实现呢，首先最简单的是直接从数据库 按顺序 查出，然后依次打印，

简单点说吧，oracle数据库有相应的语句可以实现，很容易，但是sql server 没有，尝试了下没有成功，

考虑数据库的兼容性，就像把数据到后台去排序，

那么，这也就是这篇雯所说的内容了，排序。至于排序规则就如图所示很明确了。

。。。割......

刚开始说只需要3级结垢，就是每一个节点下面最多只有两个节点，那好，就直接在

compareTo 写 dept.getParnt().getParent() 这样判断，

过了一段时间又说要4级结构....凌乱... 这个方法我又要重写，

现在写一个通用的，不管多少级都可以

compareTo方法：

@Override
    	public int compareTo(Dept d) {
		
    		if( this.getRootParent().getId().intValue() != d.getRootParent().getId().intValue() ){
    			//没有相同的parent,那么在不同的根节点之下，按根节点的order排序
    			if(this.getRootParent().getOrder() > d.getRootParent().getOrder()){
    				return 1;
    			}else if(this.getRootParent().getOrder() < d.getRootParent().getOrder()){
    				return -1;
    			}
    			
    			
    		}else{
    			//在同一个根节点下
    			if(isSameBranchAtABranch(d) != null){//在一条线上
    				if( this.getId().intValue() == isSameBranchAtABranch(d).getId().intValue() ){
    					return -1;
    				}else{
    					return 1;
    				}
    			}else{
    				Dept togetherParentFirst = haveSameParentsButBotABranch(d);
    				if(this.getParent().getId().intValue() == togetherParentFirst.getId().intValue() 
    					//都是level 2
    						&& d.getParent().getId().intValue() == togetherParentFirst.getId().intValue()){
    					if(this.getOrder().intValue() > d.getOrder().intValue()){
    						return -1;
    					}else if(this.getOrder().intValue() < d.getOrder().intValue()){
    						return 1;
    					}else{
    						return 0;
    					}
    				}
    				Dept temp = this;
    				int orderThis = 0;
    				int orderD = 0;
    				while(temp.getParent() != null){
    					if(temp.getId().intValue() == togetherParentFirst.getId().intValue()){
    						orderThis = temp.getOrder();
    					}else{
    						temp = temp.getParent();
    					}
    				}
    				temp = d;
    				while(temp.getParent() != null){
    					if(temp.getId().intValue() == togetherParentFirst.getId().intValue()){
    						orderD = temp.getOrder();
    					}else{
    						temp = temp.getParent();
    					}
    				}
    				if(orderThis > orderD){
    					return -1;
    				}else if(orderThis < orderD){
    					return 1;
    				}
    			}
    			
    		}
    		
    		return 0;
    		
    		
    	}

完整测试代码：

打印结果如上图所示：

package test;

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

public class Jtest{
	
	static ArrayList<Dept> deptList = new ArrayList<Dept>();
	static{
		initData();
	}
	
	/**
	 * 主程序入口
	 * @param args
	 */
	public static void main(String[] args) {
    	
    	print("===应该的顺序===");
    	iteratorPrintDeptList(deptList);//打印
    	
    	print("===打乱顺序后===");
    	radomSwapList(deptList);
    	
    	iteratorPrintDeptList(deptList);//打印
    	Collections.sort(deptList);//排序
    	
    	print("===排序后===");
    	iteratorPrintDeptListWithLevel(deptList);//打印
    	
    }
	
    //初始化测试数据
    private static void initData() {
		Jtest jtest = new Jtest();
		//这里写为内部类是因为当时想做个其他的测试，忽略
		Dept deptLevel01_1 = jtest.new Dept(1, "level01_deptLevel01_1", 5, null,null);
		Dept deptLevel01_2 = jtest.new Dept(2, "level01_deptLevel01_2", 4, null,null);
		Dept deptLevel01_3 = jtest.new Dept(3, "level01_deptLevel01_3", 3, null,null);
		Dept deptLevel01_4 = jtest.new Dept(4, "level01_deptLevel01_4", 5, null,null);
		
		Dept deptLevel02_1 = jtest.new Dept(5, "level02_deptLevel02_1", 9, 1,deptLevel01_1);
		Dept deptLevel02_2 = jtest.new Dept(6, "level02_deptLevel02_2", 5, 1,deptLevel01_1);
		Dept deptLevel02_3 = jtest.new Dept(7, "level02_deptLevel02_3", 6, 1,deptLevel01_1);
		
		Dept deptLevel02_4 = jtest.new Dept(8, "level02_deptLevel02_4", 6, 2,deptLevel01_2);
		
		Dept deptLevel02_5 = jtest.new Dept(9, "level02_deptLevel02_5", 6, 3,deptLevel01_3);
		Dept deptLevel02_6 = jtest.new Dept(10, "level02_deptLevel02_6", 8, 3,deptLevel01_3);
		
		Dept deptLevel03_1 = jtest.new Dept(11, "level03_deptLevel03_1", 6, 8,deptLevel02_4);
		Dept deptLevel03_2 = jtest.new Dept(12, "level03_deptLevel03_2", 8, 8,deptLevel02_4);
		Dept deptLevel03_3 = jtest.new Dept(13, "level03_deptLevel03_3", 6, 5,deptLevel02_1);
		Dept deptLevel03_4 = jtest.new Dept(14, "level03_deptLevel03_4", 8, 5,deptLevel02_1);
		
		
		deptList.add(deptLevel01_3);
			deptList.add(deptLevel02_5);
			deptList.add(deptLevel02_6);
		deptList.add(deptLevel01_1);
			deptList.add(deptLevel02_3);		
			deptList.add(deptLevel02_2);
			deptList.add(deptLevel02_1);
				deptList.add(deptLevel03_3);
				deptList.add(deptLevel03_4);
		deptList.add(deptLevel01_2);
			deptList.add(deptLevel02_4);	
				deptList.add(deptLevel03_1);
				deptList.add(deptLevel03_2);
		deptList.add(deptLevel01_4);
	}
    
	/**
	 * 打乱list的顺序
	 * @param deptList
	 */
	static void radomSwapList(List<Dept> deptList){
		int size = deptList.size();
		for(int i = 0; i < 30; i++){
			int randomNum = (int)(Math.random()*10);
			if(randomNum >= size){
				continue;
			}
			Dept temp = deptList.get(randomNum);
			deptList.set(randomNum, deptList.get(size - 1 - randomNum));
			deptList.set(size - 1 - randomNum, temp);
		}
	}
	
	/**
	 * 遍历打印Arraylist
	 * @param deptList
	 */
	static void iteratorPrintDeptList(List<Dept> deptList){
		for(Dept dept : deptList) {
			System.out.println("deptId: "+""+dept.getId() + ", " + dept.getName() + ", " + dept.getParentId());
		}
		print();
	}
	
	/**
	 * 遍历打印Arraylist(按级别缩进)
	 * @param deptList
	 */
	static void iteratorPrintDeptListWithLevel(List<Dept> deptList){
		for(Dept dept : deptList) {
			int level = dept.getLevel();
			for(int i= 1; i< level; i++){
				System.out.print("--");
			}
			System.out.println("deptId: "+""+dept.getId() + ", " + dept.getName() + ", " + dept.getParentId());
		}
		print();
	}
	
	/**
	 * 遍历打印Arraylist
	 * @param deptList
	 */
	static void simpleIteratorPrintDeptList(List<Dept> deptList){
		for(Dept dept : deptList) {
			System.out.print(dept.getId() + ", ");
		}
		System.out.println();
	}
	
	static void print(){
		System.err.println("------------------------");
	}
	static void print(String str){
		System.err.println(str);
	}
	
  

    
    class Dept implements Comparable<Dept>{
    	private Integer id;
    	private String name;
    	private Integer order;
    	private Integer parentId;
    	
    	private Dept parent;
    	
    	/**
    	 * 得到当前部门是第几级部门，parent为null的为 1 级，有一个parent的为2级，依次类推
    	 */
    	private int getLevel(){
    		int temp = 1;
    		Dept tempDept = this;
    		while(tempDept.getParent() != null){
    			tempDept = tempDept.getParent();
    			temp = temp +1;
    		}
    		return temp;
    	}
    	
    	private Dept sameParents(Dept d){
    		
			Dept temp1 = this;
			while(temp1 != null){
				Dept temp2 = d;
				while(temp2 != null){
					if( temp1.getId() == temp2.getId() ){
						return temp1;
					}
					temp2 = temp2.getParent();
				}
				temp1 = temp1.getParent();
			}
			
			return null;
    	
    	}
    	
    	/**
    	 * 获得根节点的parent
    	 * @return
    	 */
    	private Dept getRootParent(){
    		if(this.getParent() == null){
    			return this;
    		}else{
    			Dept tmp = this;
    			while(tmp.getParent() != null){
    				tmp = tmp.getParent();
        		}
    			return tmp;
    		}
    		
    	}
    	
    	/**
    	 * 得到某个level的parent
    	 * @param level
    	 * @return
    	 */
    	private Dept getParent(int level){
    		
    		int thisLevel = this.getLevel();
    		Dept deptTemp = this;
    		while(deptTemp.getParent() != null){
    			thisLevel = thisLevel - 1;
    			deptTemp = deptTemp.getParent();
    			if(level == thisLevel){
    				return deptTemp;
    			}
    		}
    		return null;
    	}
    	
    	@Override
    	public int compareTo(Dept d) {
		
    		if( this.getRootParent().getId().intValue() != d.getRootParent().getId().intValue() ){
    			//没有相同的parent,那么在不同的根节点之下，按根节点的order排序
    			if(this.getRootParent().getOrder() > d.getRootParent().getOrder()){
    				return 1;
    			}else if(this.getRootParent().getOrder() < d.getRootParent().getOrder()){
    				return -1;
    			}
    			
    			
    		}else{
    			//在同一个根节点下
    			if(isSameBranchAtABranch(d) != null){//在一条线上
    				if( this.getId().intValue() == isSameBranchAtABranch(d).getId().intValue() ){
    					return -1;
    				}else{
    					return 1;
    				}
    			}else{
    				Dept togetherParentFirst = haveSameParentsButBotABranch(d);
    				if(this.getParent().getId().intValue() == togetherParentFirst.getId().intValue() 
    					//都是level 2
    						&& d.getParent().getId().intValue() == togetherParentFirst.getId().intValue()){
    					if(this.getOrder().intValue() > d.getOrder().intValue()){
    						return -1;
    					}else if(this.getOrder().intValue() < d.getOrder().intValue()){
    						return 1;
    					}else{
    						return 0;
    					}
    				}
    				Dept temp = this;
    				int orderThis = 0;
    				int orderD = 0;
    				while(temp.getParent() != null){
    					if(temp.getId().intValue() == togetherParentFirst.getId().intValue()){
    						orderThis = temp.getOrder();
    					}else{
    						temp = temp.getParent();
    					}
    				}
    				temp = d;
    				while(temp.getParent() != null){
    					if(temp.getId().intValue() == togetherParentFirst.getId().intValue()){
    						orderD = temp.getOrder();
    					}else{
    						temp = temp.getParent();
    					}
    				}
    				if(orderThis > orderD){
    					return -1;
    				}else if(orderThis < orderD){
    					return 1;
    				}
    			}
    			
    		}
    		
    		return 0;
    		
    		
    	}
    	/**
    	 * 判断是否两个节点有一个共同的父节点(1)(并且两个节点是在一条分支上，就是一个节点是另一个节点的父节点)
    	 * @param d 要和当前节点比较的节点
    	 * @return 返回父节点（此父节点就是其中的一个节点 ）
    	 */
    
    	private Dept isSameBranchAtABranch(Dept d){
    		Dept temp = this;
    		while(temp.getParent() != null){
    			if( temp.getParent().getId().intValue() == d.getId() ){
    				return d;
    			}
    			temp = temp.getParent();
    		}
    		temp = d;
    		while(temp.getParent() != null){
    			if( temp.getParent().getId().intValue() == this.getId() ){
    				return this;
    			}
    			temp = temp.getParent();
    		}
    		return null;
    	}
    	/**
    	 * 判断是否有相同的父节点(2)（两个节点不位于不同的小分支，此节点不是其中的的任意一个节点,也就是除去1的情况）
    	 * @param d
    	 * @return
    	 */
    	private Dept haveSameParentsButBotABranch(Dept d){
    		
    		Dept temp = this;
    		while(temp.getParent() != null){
    			if(temp.getParent().isSameBranchAtABranch(d) != null){
    				return temp.getParent();
    			}
    			temp = temp.getParent();
    		}
    		return null;
    	}
    	
    	@Override
    	public String toString() {
    		return this.getId()+", "+this.getParent().getParentId()+", "+this.getName();
    	}
    	
    	/**
    	 * 构造函数
    	 * @param id
    	 * @param name
    	 * @param order
    	 * @param parentId
    	 * @param parent
    	 */
    	public Dept(Integer id, String name, Integer order, Integer parentId,Dept parent) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.order = order;
    		this.parentId = parentId;
    		this.parent = parent;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Integer getOrder() {
    		return order;
    	}
    	public void setOrder(Integer order) {
    		this.order = order;
    	}
    	public Dept getParent() {
    		return parent;
    	}
    	public void setParent(Dept parent) {
    		this.parent = parent;
    	}
    	public Integer getParentId() {
    		return parentId;
    	}
    	public void setParentId(Integer parentId) {
    		this.parentId = parentId;
    	}
    }
}

实现Comparable接口对树形结构数据进行排序

标签：

原文地址：http://blog.csdn.net/wufengui1315/article/details/43538717