• 最直接的构造方法：直接建立一个树对象

     构造一个二叉树
  

  class  tree  implements  java.io.Serializable   { 
       public  tree left; 
       public  tree right; 
       public   int  id; 
       public   int  level; 
  
       private   static   int  count  =   0 ;           
  
       public  tree( int  depth)   {                   id  =  count ++ ; 
          level  =  depth; 
           if  (depth  >   0 )   { 
              left  =   new  tree(depth - 1 ); 
              right  =  new  tree(depth - 1 ); 
          }  
      }  
  
       public   void  print( int  levels)   { 
           for  ( int  i  =   0 ; i  <  level; i ++ ) 
              System.out.print( "    " ); 
          System.out.println( " node  "   +  id); 
  
           if  (level  <=  levels  &&  left  !=   null ) 
              left.print(levels); 
  
           if  (level  <=  levels  &&  right  !=   null ) 
              right.print(levels); 
      }  

• 通过建造树的节点构造一棵树：

  叶子节点对象

  public class ResultItem {            

      private String name;
    private String value;
    /** *//**
     * 父目录
     */
    private ResultFolder parent = null;            //父目录节点ResultFolder 
    /** *//**
     * 构造函数
     * @param sName 节点名称
     */
    public ResultItem(String sName) {
      name = sName;
    }
    /** *//**
     * 获取父目录
     * @return 父目录
     */
    public ResultFolder getParent() {
           return parent;
    }
    /** *//**
     * 设置父目录
     * @param folder 父目录
     */
    protected void setParent(ResultFolder folder) {
      parent = folder;
    }
    /** *//**
     * 获取节点名称
     * @return 节点名称
     */
    public String getName() {
      return name;
    }
    /** *//**
     * 获取节点值
     * @return 节点值
     */
    public String getValue() {
      return value;
    }
    /** *//**
     * 设置节点值
     * @param newValue 节点值
     */
    public void setValue(String newValue) {
      value = newValue;
    }
  }

  建造父目录节点以及数的像关操作

public   class  ResultFolder  extends  ResultItem {
   /** */ /**
   * 字对象向量
    */
   private  Vector vtItems  =   new  Vector();
   /** */ /**
   * 构造函数
   *  @param  sName 参数名称
    */
   public  ResultFolder(String sName)  {
     super (sName);
  }

   /** */ /**
   * 设置内容
   *  @param  newValue 内容
    */
   public   void  setValue(String newValue)  {
     //  Can't set value to a ResultFolder
     // System.out.println("Can't set value to a ResultFolder");
  }

   /** */ /**
   * 获取内容
   *  @return  内容
    */
   public  String getValue()  {
     //  Can't get value of a ResultFolder"
     // System.out.println("Can't get value of a ResultFolder");
     return   "" ;
  }
   /** */ /**
   * 增加数据子项
   *  @param  item 子项
    */
   public   void  appendChild(ResultItem item)  {
    vtItems.addElement(item);
    item.setParent( this );
  }

   /** */ /**
   * 从结果树中移去一个节点，不进行进行遍历查找
   *  @param  item 节点
   *  @return  true-成功，flase-失败
    */
   public   boolean  removeChild(ResultItem item)  {
     return  removeChild(item,  false );
  }

   /** */ /**
   * 从结果树中移去一个节点，进行递归查找
   *  @param  item  节点
   *  @param  bRecursive  true-递归查找， false－不作递归查找
   *  @return  true-成功， false－失败
    */
   public   boolean  removeChild(ResultItem item,  boolean  bRecursive)  {
     if ( ! vtItems.removeElement(item)  &&  bRecursive)  {
       for ( int  i = 0 ; i < vtItems.size(); i ++ )  {
        Object o  =  vtItems.elementAt(i);
         if ( o  instanceof  ResultFolder)  {
          ( (ResultFolder) o).removeChild(item,  true );
        }
      }
    }
     return   false ;
  }

   /** */ /**
   * 递归查找具有指定值的ResultItem
   *  @param  sKey 名称
   *  @param  bRecursive 是否递归查找
   *  @return  节点
    */
   public  ResultItem findSingleItem(String sKey,  boolean  bRecursive)  {
    ResultItem item  =   null ;
     for ( int  i = 0 ; i < vtItems.size(); i ++ )  {
      item  =  (ResultItem)vtItems.elementAt(i);
       if (item.getName().equalsIgnoreCase(sKey))  {
         return  item;
      }
       else   if (bRecursive  &&  item  instanceof  ResultFolder)  {
        ResultItem subItem  =  ((ResultFolder)item).findSingleItem(sKey,  true );
         if (subItem  !=   null )  {
           return  subItem;
        }
      }
    }
     return   null ;
  }

   /** */ /**
   * 递归查找具有指定值的ResultItem的值
   *  @param  sKey 名称
   *  @param  bRecursive 是否递归查找
   *  @return  节点的值
    */
   public  String findSingleValue(String sKey,  boolean  bRecursive)  {
    ResultItem item  =  findSingleItem(sKey, bRecursive);
     if (item  !=   null )  {
       return  item.getValue();
    }
     return   null ;
  }
   /** */ /**
   * 非递归查找具有指定值的ResultItem的值
   *  @param  sKey 节点名称
   *  @return  节点值
    */
   public  String findSingleValue(String sKey)  {
     return  findSingleValue(sKey,  false );
  }
   /** */ /**
   * 找到关键字为特定值的Item列表
   *  @param  sKey 节点名称
   *  @return   Item向量
    */
   public  Vector findItems(String sKey)  {
    Vector vt  =   new  Vector();
     for ( int  i = 0 ; i < vtItems.size(); i ++ )  {
      ResultItem item  =  (ResultItem)vtItems.elementAt(i);
       if (item.getName().equalsIgnoreCase(sKey))  {
        vt.addElement(item);
      }
    }
     return  vt;
  }
   /** */ /**
   * 找到关键字为特定值的Item
   *  @param  sKey 节点名称
   *  @return   Item
    */
   public  ResultItem findSingleItem(String sKey)  {
     for ( int  i = 0 ; i < vtItems.size(); i ++ )  {
      ResultItem item  =  (ResultItem)vtItems.elementAt(i);
       if (item.getName().equalsIgnoreCase(sKey))  {
         return  item;
      }
    }
     return   null ;
  }
   /** */ /**
   * 追加子节点
   *  @param  key 子节点名称
   *  @param  value 子节点值
   *  @return  子节点
    */
   public  ResultItem appendChild(String key, String value)  {
    ResultItem item  =   new  ResultItem(key);
    item.setValue(value);
     this .appendChild(item);
     return  item;
  }
   /** */ /**
   * 追加子目录
   *  @param  key 名称
   *  @return  子目录
    */
   public  ResultFolder appendChildFolder(String key)  {
    ResultFolder folder  =   new  ResultFolder(key);
     this .appendChild(folder);
     return  folder;
  }
   /** */ /**
   * 获取子项向量
   *  @return  子项向量
    */
   public  Vector getChildItems()  {
     return  vtItems;
  }
   /** */ /**
   * 非递归方式判断是否含有指定子项
   *  @param  aValue 子项名称
   *  @return  true-是， false－否
    */
   public   boolean  hasValue(String aValue)  {
     return  hasValue(aValue,  false );
  }
   /** */ /**
   * 判断是否含有指定子项
   *  @param  aValue 子项名称
   *  @param  bRecursive 是否以递归方式
   *  @return  true-是， false－否
    */
   public   boolean  hasValue(String aValue,  boolean  bRecursive)  {
     for ( int  i = 0 ; i < vtItems.size(); i ++ )  {
      ResultItem item  =  (ResultItem)vtItems.elementAt(i);
       if (item.getValue().equals(aValue))  {
         return   true ;
      }
       else   if (bRecursive  &&  (item  instanceof  ResultFolder))  {
         boolean  bOK  =  ((ResultFolder)item).hasValue(aValue,  true );
         if (bOK)
           return   true ;
      }
    }
     return   false ;
  }
   /** */ /**
   * 获取Html安全代码
   *  @param  key 原代码
   *  @return  Html安全代码
    */
   public  String getValueByHtml(String key)  {
     return  htmlEscape(findSingleValue(key));
  }

   /** */ /**
   * Html安全代码转换程序
   *  @param  xml 原代码
   *  @return  Html安全代码
    */
   public   static  String htmlEscape(String xml)  {
     if  (xml  ==   null )  return   null ;
    String ret  =  xml;
    StringBuffer sb  =   new  StringBuffer();
     //  do & first
     int  p, q;
     for (q  =  ret.indexOf( " & " ), p  =   0 ; q  >=   0 ; p  =   ++ q, q  =  ret.indexOf( " & " , p))  {
      sb.append(ret.substring(p, q));
      sb.append( " &amp; " );
    }
    sb.append(ret.substring(p));
    ret  =  sb.toString();
    sb  =   new  StringBuffer();
     //  do <
     for (q  =  ret.indexOf( " < " ), p  =   0 ; q  >=   0 ; p  =   ++ q, q  =  ret.indexOf( " < " , p))  {
      sb.append(ret.substring(p, q));
      sb.append( " &lt; " );
    }
    sb.append(ret.substring(p));
    ret  =  sb.toString();
    sb  =   new  StringBuffer();
     //  do >
     for (q  =  ret.indexOf( " > " ), p  =   0 ; q  >=   0 ; p  =   ++ q, q  =  ret.indexOf( " > " , p))  {
      sb.append(ret.substring(p, q));
      sb.append( " &gt; " );
    }
    sb.append(ret.substring(p));
    ret  =  sb.toString();
    sb  =   new  StringBuffer();
     //  do return
     for (q  =  ret.indexOf( " \n " ), p  =   0 ; q  >=   0 ; p  =   ++ q, q  =  ret.indexOf( " \n " , p))  {
      sb.append(ret.substring(p, q));
      sb.append( " <br> " );
    }
    sb.append(ret.substring(p));
    ret  =  sb.toString();
     return  ret;
  }
}