查询条件为 pid

select * from table where pid =？
第一次调用传 0,表示根
getNode(0);

public List getNode(int pid){
   List list = ..查询...(pid); //执行查询,自己写吧
   if(list !=null && list.size()!=0){//判断是否查到,没有了表示小的了
     for(int i=0;i<list.size();i++){
        System.out.print(list.get(i).name);
        getNode(list.get(i).id); //根据当前id查询子
     }
  } 

java poi读取excel这种层级结构的递归写法，思路：同列的循环获取，子级递归获取，想清楚每一个单元格变化的地方，传不同的参数。exel的单元格的值只能先读取行，再获取列。

包括合并单元格的获取并不是有序的，需要根据行列的起始索引来判断是否是合并单元格。每次都要先进行判断。

public List<KnowledgeSystemField> readExcel(String filename, InputStream inputStream) {
		Workbook workbook = null;
		try {
			filename = filepath;
			String filetype = filename.substring(filename.lastIndexOf(".") + 1, filename.length());

			File excelfile = new File(filename);
			if (!excelfile.exists()) {
				log.info("路径为" + filename + "的文件不存在！");
				return null;
			}
			inputStream = new FileInputStream(excelfile);

			workbook = getWorkBook(inputStream, filetype);
			// 读取excel中的数据
			addRowKLevel(workbook);
			List<KnowledgeSystemField> resultDataList = null;
			// resultDataList = parseExcel(workbook);
			return resultDataList;
		} catch (Exception e) {
			log.warn("解析Excel失败，文件名：" + filename + " 错误信息：" + StrFunc.exception2str(e));
			return null;
		} finally {
			try {
				if (null != workbook) {
					workbook.close();
				}
				if (null != inputStream) {
					inputStream.close();
				}
			} catch (Exception e) {
				log.warn("关闭数据流出错！错误信息：" + e.getMessage());
				return null;
			}
		}
	}
public Workbook getWorkBook(InputStream in, String filetype) throws Exception {
		Workbook workbook = null;
		if (StrFunc.compareStr(filetype, XLS)) {
			workbook = new HSSFWorkbook(in);
		} else if (StrFunc.compareStr(filetype, XLSX)) {
			workbook = new XSSFWorkbook(in);
		}
		return workbook;
	}
public void addRowKLevel(Workbook workbook) {
		Sheet sheet = workbook.getSheetAt(0);
		if (sheet == null) {
			return;
		}
		int startRow = STARTROW;
		int endRow = sheet.getLastRowNum();
		endRow = 26;
		String dirId = "";
		getCellValue(startRow, endRow, 1, sheet, dirId);
	}

public void getCellValue(int firstRowIndex, int lastRowIndex, int column, Sheet sheet, String dirid) {
		if (column > 4) {
			return;
		}
		int lastRow = firstRowIndex;
		JSONObject multiRow = isMultiRow(firstRowIndex, lastRowIndex, column, sheet);
		if (multiRow.getBoolean("isMulti")) {
			lastRow = multiRow.getInt("lastRow");
		}
		while (lastRow <= lastRowIndex) {
			Cell cell = sheet.getRow(firstRowIndex).getCell(column);
			String knowId = addKnowOrGroup(column, dirid, cell);
			getCellValue(firstRowIndex, lastRow, column + 1, sheet, StrFunc.isNull(knowId) ? dirid : knowId);
			firstRowIndex = lastRow + 1;
			lastRow = firstRowIndex;
			multiRow = isMultiRow(firstRowIndex, lastRowIndex, column, sheet);
			if (multiRow.getBoolean("isMulti")) {
				lastRow = multiRow.getInt("lastRow");
			}
		}
	}
public JSONObject isMultiRow(int firstRowIndex, int lastRowIndex, int column, Sheet sheet) {
		JSONObject obj = new JSONObject();
		obj.put("isMulti", false);
		List<CellRangeAddress> mergedRegions = sheet.getMergedRegions();
		for (int j = 0; j < mergedRegions.size(); j++) {
			CellRangeAddress cr = mergedRegions.get(j);
			int firstColumn = cr.getFirstColumn();
			int lastColumn = cr.getLastColumn();
			int firstRow = cr.getFirstRow();
			int lastRow = cr.getLastRow();
			if (firstColumn == lastColumn && firstColumn == column) {
				if (firstRowIndex == firstRow && lastRow <= lastRowIndex) {
					obj.put("isMulti", true);
					obj.put("lastRow", lastRow);
					break;
				}
			}
		}
		return obj;
	}
private String addKnowOrGroup(int column, String dirid, Cell cell2) {
		String knowId = "";
		String cellvalue = convertCellValueToString(cell2);
		if (!StrFunc.isNull(cellvalue)) {
			boolean ifKnowExist = ifKnowExist(cellvalue);
			if (!ifKnowExist) {
				if (column == 1) {// 第一级分组
					knowId = addGroup(cellvalue, this.knowledgeSetId);
				} else if (column == 4) {// 最后一级图谱
					knowId = addKnowWithName(cellvalue, dirid);
				} else {
					knowId = addGroup(cellvalue, dirid);
				}
			}
		}
		return knowId;
	}

 

程序实际很简单，是一个递归的过程。过程如下:
括号里是传进去的begin和end参数，而后面跟的数字是进入之后需要循环的次数。
这个程序也更让我理解了，递归程序的过程：
好比是一个人在执行任务，在执行过程中有很多分叉，如果有分叉的情况，就分叉的情况扔到栈中去，因为栈是先进后出的，所以用栈符合要求。同地位的分叉总有先后顺序，这个人走到第一个分叉的第一个分叉，一直到第一个到达的终点，到达终点后，到栈中去看分叉情况，如果还有分叉就继续执行到下一个终点。重点在于到了终点就返回上一层(返回到上一层调用的函数那行)，完成上一层没有执行完的工作，如果上一层没事了，就看上一层的上一层，以此类推。
开始我有疑问，递归函数中，对数组的引用一直是同一个引用，但还一直在swap，这样能对吗？原来是每次循环中，最后一行又把交换的元素换回来了，这样就为下一次循环，即同地位的分叉做好了准备。
代码如下：
package mianshi;
import java.util.ArrayList;
import java.util.List;
public class pailie {
public static List> permute(int[] nums)
{
List> all=new ArrayList>();
allSort(nums, 0, nums.length-1, all);
return all;
}
public static void allSort(int[] array,int begin,int end,List> all)
{
if(begin==end){
List origi=new ArrayList();
for(int a:array)
{
origi.add(a);
}
all.add(origi);
return;
}
for(int i=begin;i<=end;i++){
swap(array,begin,i );
allSort(array, begin+1, end,all);
swap(array,begin,i );
}
}
public static void swap(int[] array,int a,int b){
int tem=array[a];
array[a]=array[b];
array[b]=tem;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a={1,2,3,4};
permute(a);
for(List b:permute(a))
{
for(int c:b)
{
System.out.println(c);
}
}
}
}

查询条件为 parentId 
select * from table where parentId =？ 

第一次调用传 0,表示根 
getNode(0); 

public void getNode(int pid){ 
   List list = ..查询...(pid); //执行查询,自己写吧 
   if(list !=null && list.size()!=0){//判断是否查到,没有了表示小的了 
     for(int i=0;i<list.size();i++){ 
        System.out.print(list.get(i).name); 
        getNode(list.get(i).id); //根据当前id查询子 
     } 
  } 
}