一个简单的java Tree

一个Node实体类:

package com.design.patterns.composite;

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

public class Node {
	  // 编号
	  private long id;

	  // 标题
	  private String title;

	  // 下级列表
	  private List<Node> children = new ArrayList<Node>();

	  // 上级，顶层为null
	  private Node parent;

	  // 前一个节点
	  private Node prev;

	  // 后一个节点
	  private Node next;

	  // 当前处理的节点
	  private Node current;

	  /**
	   * 默认的构造器
	   */
	  public Node() {
	  }

	  /**
	   * 推荐使用的构造器
	   * 
	   * @param id 编号
	   * @param title 文本
	   */
	  public Node(long id, String title) {
	    this.id = id;
	    this.title = title;
	  }

	  /**
	   * 增加一个下属。<br>
	   * 自动对应上级和兄弟结点
	   * 
	   * @param n 被增加的节点
	   */
	  public void addChild(Node n) {
	    children.add(n);
	    n.setParent(this);
	    if (current != null) {
	      current.next = n;
	    }
	    n.prev = current;
	    current = n;
	  }

	  /**
	   * 输出为下拉列表的方法
	   * 
	   * @param selectedId 被选中的编号
	   * @return 下拉列表的字符串。可以直接放到<select></select>里面
	   */
	  public String getOption(long selectedId) {
	    return "<option>" + toStringOption("", "", selectedId);
	  }

	  /**
	   * 输出为Text的方法。<br>
	   * 应网友建议，更改toString为toStringText方法。
	   * 
	   * @param lftStr 左侧额外的字符串
	   * @param append 右侧显示的字符串
	   * @return 文本形式的字符串
	   */
	  public String toStringText(String lftStr, String append) {
	    StringBuilder b = new StringBuilder();
	    b.append(append + title);
	    b.append(" ");
	    if (children.size() > 0) {
	      for (int i = 0; i < children.size() - 1; i++) {
	        b.append(lftStr + children.get(i).toStringText(lftStr + "│", "├"));
	      }
	      b.append(lftStr + children.get(children.size() - 1).toStringText(lftStr + " ", "└"));
	    }
	    return b.toString();
	  }

	  public static void main(String[] args) {
	    Node root = new Node(0, "菜单列表");
	    Node f1 = new Node(1, "开始菜单");
	    root.addChild(f1);
	    Node f1_1 = new Node(11, "程序");
	    f1.addChild(f1_1);
	    Node f1_1_1 = new Node(111, "附件");
	    f1_1.addChild(f1_1_1);
	    Node f1_1_1_1 = new Node(1111, "娱乐");
	    f1_1_1.addChild(f1_1_1_1);
	    Node f1_1_1_2 = new Node(1112, "娱乐2");
	    f1_1_1.addChild(f1_1_1_2);
	    Node f1_2 = new Node(12, "辅助工具");
	    f1.addChild(f1_2);
	    Node f2 = new Node(2, "My Documents ");
	    root.addChild(f2);
	    Node f3 = new Node(3, "My Documents2 ");
	    root.addChild(f3);
	    System.out.println(root.toStringText(" ", ""));
	    System.out.println(root.getOption(111));
	    System.out.println(f1_1_1_2.getPrev().getTitle());
	    System.out.println(f1_1_1_2.getPrev().getParent().getTitle());
	  }

	  public List<Node> getChildren() {
	    return children;
	  }

	  public long getId() {
	    return id;
	  }

	  /**
	   * 得到下一个兄弟结点。
	   * 
	   * @return 如果是最后一个，则返回null
	   */
	  public Node getNext() {
	    return next;
	  }

	  public Node getParent() {
	    return parent;
	  }

	  /**
	   * 得到前一个兄弟结点。
	   * 
	   * @return 如果是第一个，则返回null
	   */
	  public Node getPrev() {
	    return prev;
	  }

	  public String getTitle() {
	    return title;
	  }

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

	  public void setNext(Node next) {
	    this.next = next;
	  }

	  public void setParent(Node parent) {
	    this.parent = parent;
	  }

	  public void setPrev(Node prev) {
	    this.prev = prev;
	  }

	  public void setTitle(String title) {
	    this.title = title;
	  }

	  /**
	   * 构造下拉列表.
	   * 
	   * @param lftStr 左侧的字符
	   * @param append 增加的字符
	   * @param idSelected 被选中的编号
	   * @return 下拉列表字符串
	   */
	  private String toStringOption(String lftStr, String append, long idSelected) {
	    StringBuilder b = new StringBuilder();
	    b.append(append + title + "</option>");
	    b.append(" ");
	    if (children.size() > 0) {
	      for (int i = 0; i < children.size() - 1; i++) {
	        b.append("<option value='" + children.get(i).getId() + "'" + (idSelected == children.get(i).getId() ? " selected" : "")
	            + ">" + lftStr + children.get(i).toStringOption(lftStr + "│", "├", idSelected));
	      }
	      b.append("<option value='" + children.get(children.size() - 1).getId() + "'"
	          + (idSelected == children.get(children.size() - 1).getId() ? " selected" : "") + ">" + lftStr
	          + children.get(children.size() - 1).toStringOption(lftStr + " ", "└", idSelected));
	    }
	    return b.toString();
	  }
}

 树形结构的构造类:

package com.design.patterns.composite;

import java.util.ArrayList;
import java.util.List;
/*
 * 树形结构
 */
public class TreeNode<T> {
	
	public T t;
	private String id;  
	private String nodeName;  
    private TreeNode<T> parent;  
    private List<TreeNode<T>> childrenList = new ArrayList<TreeNode<T>>();
    
    
    public TreeNode(String id,String nodeName) {
		// TODO Auto-generated constructor stub
    	this.id=id;
    	this.nodeName=nodeName;
	}
    
    /*
     * 添加一个节点
     */
    public void add(TreeNode<T> node) {
    	this.childrenList.add(node);
    	node.setParent(this);
	}
    
    /*
     * 删除一个节点
     */
    public void remove(TreeNode<T> node) {
    	childrenList.remove(node);
    }
    
   //取得孩子节点  
    public List<TreeNode<T>> getChildren(){ 
    	
    	return childrenList;
    } 
    
    //展示该节点下的所有孩子节点  
    public void showAllNodes(TreeNode<T> node){ 
    	
    	if (node != null) {
    		System.out.println(node.getNodeName().toString());
				
			for (int i = 0; i < node.childrenList.size(); i++) {
				TreeNode<T> nodes=node.childrenList.get(i);
//				System.out.println(nodes.getNodeName());
				showAllNodes(nodes);
			}
		}
    }  
    
    //展示该节点下的下层节点  
    public void showNextNodes(TreeNode<T> node){ 
    	
    	if (node != null) {
//    		System.out.println(node.getNodeName().toString());
    		
    		for (int i = 0; i < node.childrenList.size(); i++) {
    			TreeNode<T> nodes=node.childrenList.get(i);
//				System.out.println(nodes.getNodeName());
    			
    			if (this.id.equals(nodes.getParent().getId())) {
					System.out.println(nodes.getNodeName());
				}
//    			if (nodes.id.startsWith((this.id))&&nodes.id.length()==2) {
//					System.out.println(nodes.getNodeName());
//				}
//    			if (nodes.id.startsWith((this.id))&&nodes.id.length()==4) {
//    				System.out.println(nodes.getNodeName());
//    			}
//    			showNextNodes(nodes);
    		}
    	}
    }  
    
    
	public String getNodeName() {
		return nodeName;
	}
	
	
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public void setNodeName(String nodeName) {
		this.nodeName = nodeName;
	}

	public TreeNode<T> getParent() {
		return parent;
	}
	public void setParent(TreeNode<T> parent) {
		this.parent = parent;
	}

	public String getId() {
		return id;
	}

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

 一个测试类：

package com.design.patterns.composite;

import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class Tree {
	
	TreeNode root=null;
	public Tree(String id,String name) {
		// TODO Auto-generated constructor stub
		this.root= new TreeNode(id,name);
	}
	
	public static void main(String[] args) {
		Tree tree=new Tree("0","根目录");
		
		TreeNode nodeB=new TreeNode("01","B");
		tree.root.add(nodeB);
		
		TreeNode nodeC=new TreeNode("01_1","C");
		nodeB.add(nodeC);
		
		TreeNode nodeD=new TreeNode("01_2","D");
		nodeB.add(nodeD);
		
		TreeNode nodeF=new TreeNode("01_3","F");
		nodeB.add(nodeF);
		
		TreeNode nodeE=new TreeNode("02","E");
		
		
		tree.root.add(nodeE);
		
//		nodeC.remove(nodeD);
		
//		TreeNode nodes =tree.root;
//		nodes.showNextNodes(nodes);
		nodeB.showNextNodes(nodeB);
		
		nodeB.remove(nodeF);
		
		List list = nodeB.getChildren();
		
		List list2 = tree.root.getChildren();
		
		
		TreeNode nodes =tree.root;
		nodes.showAllNodes(nodes);
		
		Vector v = new Vector();//是同步的，多线程情况下可以用这个，ArrayList 是非同步的，效率要比Vector高一些
		//向Vector中添加元素 
		//使用add方法直接添加元素 
		v.add("Test0"); 
		v.add("Test1"); 
		v.add("Test0"); 
		v.add("Test2"); 
		v.add("Test2");
		
		//从Vector中删除元素 
		v.remove("Test0"); //删除指定内容的元素 
		v.remove(0); //按照索引号删除元素
		//获得Vector中已有元素的个数 
		int size = v.size(); 
		System.out.println("size:" + size);
		//遍历Vector中的元素 
		for(int i = 0;i < v.size();i++){ 
			System.out.println(v.get(i)); 
		} 
		
	}
	
}