到處找樹狀結構的容器都沒找到，TreeMap和TreeSet是什么紅-黑樹沒看明白，沒時間仔細研究了，干脆簡單寫一個吧，反正并發要求不是很高，也不怎么排序，就是內存緩存用。代碼如下：

/**
 * 樹操作類，定義樹型數據結構的常用操作，其中包括定位樹結點，插入樹結點 刪除樹結點，修改樹結點等。 注意：樹根節點的標志從0開始
 */
public class DataTree implements Serializable {

 private DataTreeNode rootDataTreeNode = null; //定義樹根
 private Hashtable nodeList = new Hashtable();

 /**
  * 設置根節點
  * @param nodeID 節點nodeid
  * @param node   節點數據對象
  */
 private void setRoot(String nodeID, Object node) {

  DataTreeNode treeNode = new DataTreeNode();
  treeNode.setLevel(0);
  treeNode.setNode(node);
  treeNode.setNodeID(nodeID);
  treeNode.setUpNodeID("0");
  this.rootDataTreeNode = treeNode;
  nodeList.put(nodeID, treeNode);
 }

 /**
  * 設置根節點
  * @param node Object，節點包含數據對象
  */
 public void setRoot(Object node) {
  String nodeID = DataAccess.getCode();
  setRoot(node);
 }
 /**
  * 取得根節點
  * @return 樹型節點
  */
 public DataTreeNode getRoot(){
  return rootDataTreeNode;
 }
 /**
  * 取得節點數據對象
  * @return 數據對象
  */
 public Object getRootNode(){
  return rootDataTreeNode.getNode() ;
 }
 
 /**
  * 給一個節點添加子節點
  * @param supNode 父節點
  * @param node 數據對象
  * @return 封裝過的樹型節點
  */
 public DataTreeNode addSubNode(DataTreeNode supNode,Object node){
  DataTreeNode newTreeNode =  supNode.addSubNode(node);
  this.nodeList.put( newTreeNode.getNodeID() ,newTreeNode);
  return newTreeNode;
 }
 /**
  * 刪除一個子節點
  * @param supNode 父節點
  * @param subNode 子節點
  * @return 成功，失敗
  */
 public boolean removeSubNode(DataTreeNode supNode,DataTreeNode subNode){
  if(supNode.removeSubNode( subNode)){
   this.nodeList.remove( subNode.getNodeID() );
   return true;
  }else{
   return false;
  }
 }
 /**
  * 刪除一個子節點
  * @param supNode 父節點
  * @param orderid 序號，從0開始
  * @return 成功，失敗
  */
 public boolean removeSubNode(DataTreeNode supNode,int orderid){
  DataTreeNode subNode = supNode.getSubNode( orderid);
  if(supNode.removeSubNode( orderid)){
   this.nodeList.remove( subNode.getNodeID() );
   return true;
  }else{
   return false;
  }
 }
 
 public static DataTree creatDataTree(ArrayList nodeList,
   String upNodeIDName,
   String nodeIDName,
   Object root){
  
  String getNodeIDMethodName = "get"+nodeIDName;
  String getUpNodeIDMethodName = "get"+upNodeIDName;
  String rootNodeid = getValue(root ,getNodeIDMethodName);
  String nodeid = "";
  String upnodeid = "";
  
  
  
  Object[][] nodes = new Object[nodeList.size()][3];

  int count =0;
  //將arraylist數據存儲到兩個Hashtable中
  for(int i=0;i<nodeList.size();i++){
   Object obj = nodeList.get(i);
   if (obj != null){
    nodeid = new String(getValue(obj,getNodeIDMethodName));
    if (nodeid != null ){
     upnodeid = new String(getValue(obj ,getUpNodeIDMethodName));
     if (upnodeid != null){
      nodes[count][0] = nodeid;
      nodes[count][1] = upnodeid;
      nodes[count][2] = nodeList.get(i);
      count ++;
     }
    }
   }
  }  
  DataTree dataTree = new DataTree();
  dataTree.setRoot( rootNodeid,root);
  findChildNodeAndAdd(dataTree.getRoot(),nodes);
  return dataTree;
 }
 
 private static void findChildNodeAndAdd(DataTreeNode treeNode,Object[][] nodes){
  String nodeid = treeNode.getNodeID() ;
  for (int i=0;i<nodes.length ;i++){
   if (nodeid.equals(nodes[i][1])){
    DataTreeNode childTreeNode = treeNode.addSubNode( (String)nodes[i][0],nodes[i][2]);
    findChildNodeAndAdd(childTreeNode,nodes);
   }
  }  
 }
 
 private static String getValue(Object obj, String functionName){
  return (String)ObjectTool.invokeMethod(obj,null,null,functionName);
 }
 /**
  * 樹型數據結構定義類。定義樹型數據結構的基本單元--樹型節點的結構。
  * 
  */
 public class DataTreeNode  {

  private String upNodeID; //父節點ID

  private String nodeID; //屬性節點標志ID

  private int level; //層號

  private Object node; //存儲用數據對象

  private ArrayList subNodes; //所有子節點

  /**
   * 空構造
   * 
   */
  private DataTreeNode() {
   subNodes = new ArrayList();
  }

  /**
   * @return Returns the level.
   */
  public int getLevel() {
   return level;
  }

  /**
   * @param level
   *            The level to set.
   */
  private void setLevel(int level) {
   this.level = level;
  }

  /**
   * @return Returns the node.
   */
  public Object getNode() {
   return node;
  }

  /**
   * @param node
   *            The node to set.
   */
  private void setNode(Object node) {
   this.node = node;
  }

  /**
   * @return Returns the nodeID.
   */
  public String getNodeID() {
   return nodeID;
  }

  /**
   * @param nodeID
   *            The nodeID to set.
   */
  private void setNodeID(String nodeID) {
   this.nodeID = nodeID;
  }

  /**
   * @return Returns the orderid.
   */
  public int getSubNodeOrderid(DataTreeNode treeNode) {
   for (int i = 0; i < subNodes.size(); i++) {
    if (this.getSubNode(i).equals(treeNode)) {
     return i;
    }
   }
   return -1;
  }

  /**
   * @return Returns the subNode.
   */
  public ArrayList getSubNodes() {
   return (ArrayList) subNodes.clone();
  }

  /**
   * @param subNode
   *            The subNode to set.
   */
  private void setSubNodes(ArrayList subNodes) {
   this.subNodes = subNodes;
  }

  /**
   * @return Returns the subNodeNo.
   */
  private int getSubNodeNo() {
   return this.subNodes.size();
  }

  /**
   * @return Returns the upNodeID.
   */
  public String getUpNodeID() {
   return upNodeID;
  }

  /**
   * @param upNodeID
   *            The upNodeID to set.
   */
  private void setUpNodeID(String upNodeID) {
   this.upNodeID = upNodeID;
  }

  /**
   * 增加一個子節點
   *
   * @param treeNode
   *            帶樹結構的節點
   */
  private void addSubTreeNode(DataTreeNode treeNode) {
   this.subNodes.add(treeNode);
  }

  /**
   * 增加一個子節點，指定nodeid
   *
   * @param nodeID
   *            指定的nodeid
   * @param node
   *            節點附帶數據對象
   */
  private DataTreeNode addSubNode(String nodeID, Object node) {
   DataTreeNode treeNode = new DataTreeNode();
   treeNode.setLevel(this.level + 1);
   treeNode.setNode(node);
   treeNode.setNodeID(nodeID);
   //treeNode.setOrderid( getSubNodeNo() );
   treeNode.setUpNodeID(this.nodeID);
   addSubTreeNode(treeNode);
   return treeNode;
  }

  /**
   * 增加一個子節點，自動分配nodeid
   *
   * @param node
   *            節點附帶數據對象
   */
  private DataTreeNode addSubNode(Object node) {
   String nodeID = DataAccess.getCode();
   return addSubNode(nodeID, node);
  }

  /**
   * 按序號取出節點
   *
   * @param orderid
   *            序號
   * @return
   */
  private DataTreeNode getSubNode(int orderid) {
   return (DataTreeNode) this.subNodes.get(orderid);
  }

  private boolean removeSubNode(int orderid) {
   try {
    subNodes.remove(orderid);
    return true;
   } catch (Exception ex) {
    return false;
   }
  }

  private boolean removeSubNode(DataTreeNode treeNode) {
   return subNodes.remove(treeNode);
  }

  /*
   * (non-Javadoc)
   *
   * @see java.lang.Object#equals(java.lang.Object)
   */
  public boolean equals(Object treeNode) {
   if (treeNode instanceof DataTreeNode) {
    if (this.nodeID.equals(((DataTreeNode) treeNode).getNodeID())) {
     return true;
    } else {
     return false;
    }
   } else {
    return false;
   }
  }

  /*
   * (non-Javadoc)
   *
   * @see java.lang.Object#toString()
   */
  public String toString() {
   return this.nodeID + " " + node.toString();
  }
 }

}