在处理无限树分类中，因为子类中的pid 是重复出现的，所以在获取所有子类的父类时使用了list.contains来判断父类是否已经保存在，如果存在，则不往list中添加，来过滤重复的pid，得到一个唯一的pid列表。为了能正确判断是否存丰父类，重写了AllTree的equals方法。

AllTree实现Comparable接口为了给树排序用，但此处并没有用来排序，感觉这样排序来代码量大，不如在数据表中直接用sql语名根据一定的规则先把所有的树排好序来的简单。

经过测试，总体还算基本满意，能完成我项目 的

package cn.guhai.tree.test;

//树对象
public class AllTree implements Comparable<AllTree> {
	
	private int  id;
	
	private String name;
	
	private int pid;

	@Override
	public String toString() {
		return "AllTree [id=" + id + ", name=" + name + ", pid=" + pid + "]";
	}
	//重写equals方法，过滤重复的父类时使用
	//在使用list.contains()方法会调用此方法比较
	@Override
	public boolean equals(Object obj) {
		AllTree at = (AllTree) obj;
		
              //业务需要：当前的pid等于传过来的id时，即说明父类对象已经add到了list中
		if(this.pid==at.id){
			return true;
		}
			return false;
	}

	public AllTree() {
		super();
		// TODO Auto-generated constructor stub
	}

	public AllTree(int id, String name, int pid) {
		super();
		this.id = id;
		this.name = name;
		this.pid = pid;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPid() {
		return pid;
	}

	public void setPid(int pid) {
		this.pid = pid;
	}

	@Override
	public int compareTo(AllTree at) {
		return (this.id>at.id)?1:((this.id<at.id)?-1:0);
	}

}

package cn.guhai.tree.test;

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

import org.junit.Before;
import org.junit.Test;

public class AllTreeService {
 private List<AllTree> at ;
 
 @Before
 public void listTree(){
  at= new ArrayList<AllTree>();
  at.add(new AllTree(1,"A父栏目",0));
  at.add(new AllTree(2,"B父栏目",0));
  at.add(new AllTree(4,"A子栏目",1));
  at.add(new AllTree(5,"A子栏目",1));
  at.add(new AllTree(7,"B子栏目",2));
  at.add(new AllTree(8,"B子栏目",2));
  at.add(new AllTree(9,"B子栏目",2));
  at.add(new AllTree(3,"A子栏目",1));
  at.add(new AllTree(6,"A子栏目",1));
  at.add(new AllTree(11,"B9子栏目",9));
  at.add(new AllTree(12,"B9子栏目",9));
  at.add(new AllTree(10,"B9子栏目",9));
  at.add(new AllTree(13,"B2子栏目",2));
  at.add(new AllTree(14,"B2子栏目",2));
  at.add(new AllTree(15,"B2子栏目",2));
  at.add(new AllTree(16,"B2子栏目",2));
 }
 /**
  * 
  * @param parentTree 父节点树
  * @param ats  所有的树
  * @param pids  所有树父类 ID
  * @param tree  已经保存的树结构，初始传入时为null
  */
 public List<AllTree> listChildren(AllTree parentTree ,List<AllTree> ats ,List<Integer> pids,List<AllTree> tree){
  if(tree==null){
   tree  = new ArrayList<AllTree>();
  }
  for(AllTree atr :ats){
   if(atr.getPid()!=0){
    if(atr.getPid()==(parentTree.getId())){
     tree.add(atr);
     //如果父类树列表中包含当前树节点
     if(pids.contains(atr.getPid())){
      List<Integer> pbs = pids;
      pbs.remove(Integer.valueOf(atr.getId()));
      //递归再进行处理
      listChildren(atr , ats ,pbs,tree );
     }
    }
   }
  }
  
  return tree;
  
 }
 
 /**
  * 获取所有父类
  * @param ats   所有分类 父和子
  * @return
  */
 public List<AllTree>  listParent(List<AllTree> ats ){
  List<AllTree> ptrees = new ArrayList<AllTree>();
  for(AllTree at :ats){
   if(!ptrees.contains(at)){
    ptrees.add(at);
   }
  }
  
  return ptrees;
  
 }
 
 /**
  * 获取所有父节点的ID值
  * @param ats
  * @return
  */
 private List<Integer> getParentids(List<AllTree> ats) {
  List<Integer> pids = new ArrayList<Integer>();
  for(AllTree a : ats){
    pids.add(a.getId());
  }
  return pids;
 }
 
 @Test
 public void getTrees(){
  List<AllTree> atree = new ArrayList<AllTree>();
  List<AllTree> ats= listParent( at );
    
  Iterator<AllTree> atsiter = ats.iterator();
  while (atsiter.hasNext()){
   AllTree aa= atsiter.next();
   List<Integer> pids = getParentids(ats);
   List<AllTree> tree = null;
   
    tree =  listChildren(aa,at,pids,null);
    if(tree.size()>1){
     tree.add(0,aa);
    }
    
    atree.addAll(tree);
  }
  
  System.out.println(atree);
  
 }
 
 
}

List 无限分类生成树结构