正反建树工具类

package com.tianee.webframe.util.tree;

import java.beans.IntrospectionException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class TreeUtils {

	/**
	 * 使用递归方法建树
	 * 
	 * @param list
	 *            树的单个节点组成List，没有树结构（parent、children为null）
	 * @param idAttr
	 *            树节点id的属性名
	 * @param parentIdAttr
	 *            树节点的parentId的属性名
	 * @return tree<T>
	 * @throws InvocationTargetException
	 * @throws IllegalAccessException
	 * @throws NoSuchMethodException
	 * @throws IntrospectionException
	 */
	public static <T> List<T> buildTree(List<T> list, String idAttr, String parentIdAttr) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, IntrospectionException {
		List<T> trees = new ArrayList<>();
		for (T treeNode : list) {
			Method method = treeNode.getClass().getMethod("get" + firstUpperCase(parentIdAttr), null);
			Object value = method.invoke(treeNode, null);
			if (null == value) {
				trees.add(findChildren(treeNode, list, idAttr, parentIdAttr));
			}
		}
		return trees;
	}

	/**
	 * 
	 * @param t
	 * @param treeNodes
	 * @return
	 * @throws NoSuchMethodException
	 * @throws InvocationTargetException
	 * @throws IllegalAccessException
	 * @throws IntrospectionException
	 */
	public static <T> T findChildren(T t, List<T> treeNodes, String idAttr, String parentIdAttr) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException,
			IntrospectionException {
		Method getIdMethod = t.getClass().getMethod("get" + firstUpperCase(idAttr));
		String id = String.valueOf(getIdMethod.invoke(t, null));
		for (T it : treeNodes) {
			Method getParentIdMethod = it.getClass().getMethod("get" + firstUpperCase(parentIdAttr));
			Object parentId = getParentIdMethod.invoke(it, null);
			if (id.equals(String.valueOf(parentId))) {
				Method getChildrenMethod = t.getClass().getMethod("getChildren");
				Object children = getChildrenMethod.invoke(t, null);
				if (null == children) {
					Method setChildrenMethod = t.getClass().getMethod("setChildren", Set.class);
					setChildrenMethod.invoke(t, new LinkedHashSet<T>());
				}
				((HashSet<T>) getChildrenMethod.invoke(t, null)).add(findChildren(it, treeNodes, idAttr, parentIdAttr));
			}

		}
		return t;
	}

	/**
	 * 
	 * @param childrens
	 *            叶子节点组成的List，没有树结构（parent、children为null）
	 * @param list
	 *            树所有的单个节点组成List，没有树结构（parent、children为null）
	 * @param idAttr
	 *            树节点id的属性名
	 * @param parentIdAttr
	 *            树节点的parentId的属性名
	 * @return
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws IntrospectionException
	 */
	public static <T> List<T> reverseBuildTree(List<T> childrens, List<T> list, String idAttr, String parentIdAttr) throws NoSuchMethodException, SecurityException, IllegalAccessException,
			IllegalArgumentException, InvocationTargetException, IntrospectionException {
		Set<Object> path = new HashSet<>();
		for (T treeNode : childrens) {
			findParent(treeNode, list, idAttr, parentIdAttr, path);
		}

		List<T> newList = new ArrayList<>();
		for (T node : list) {
			Method method = node.getClass().getMethod("get" + firstUpperCase(idAttr), null);
			Object id = method.invoke(node, null);
			for (Object nodeId : path) {
				if (id.equals(nodeId)) {
					newList.add(node);
				}
			}
		}

		List<T> trees = buildTree(newList, idAttr, parentIdAttr);
		return trees;
	}

	/**
	 * 
	 * @param <T>
	 * @param t
	 *            当前节点
	 * @param treeNodes
	 *            树所有的单个节点组成List，没有树结构（parent、children为null）
	 * @param idAttr
	 * @param parentIdAttr
	 * @return
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 */
	public static <T> void findParent(T t, List<T> treeNodes, String idAttr, String parentIdAttr, Set<Object> path) throws IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, NoSuchMethodException, SecurityException {
		Method getTIdMethod = t.getClass().getMethod("get" + firstUpperCase(idAttr), null);
		Object tId = getTIdMethod.invoke(t, null);
		path.add(tId);

		Method getParentIdMethod = t.getClass().getMethod("get" + firstUpperCase(parentIdAttr), null);
		Object parentId = getParentIdMethod.invoke(t, null);

		if (null == parentId) {
			return;
		}

		for (T node : treeNodes) {
			Method getIdMethod = node.getClass().getMethod("get" + firstUpperCase(idAttr));
			Object id = getIdMethod.invoke(node, null);
			if (parentId.equals(id)) {
				/*
				 * Method getParentMethod = t.getClass().getMethod("getParent",
				 * null); T parent = (T) getParentMethod.invoke(t, null);
				 * 
				 * if(null == parent){ }
				 * 
				 * Method setParentMethod = t.getClass().getMethod("setParent",
				 * t.getClass()); setParentMethod.invoke(t, node);
				 */

				findParent(node, treeNodes, idAttr, parentIdAttr, path);
			}
		}
	}

	/**
	 * 字符串首字母大写
	 * 
	 * @param str
	 * @return String 如果首位不是字母，返回空字符串
	 */
	public static String firstUpperCase(String str) {
		char[] ch = str.toCharArray();
		if (ch[0] >= 'a' && ch[0] <= 'z') {
			ch[0] = (char) (ch[0] - 32);
		} else if (ch[0] >= 'A' && ch[0] <= 'Z') {
		} else {
			return "";
		}
		return new String(ch);
	}
}