java中關於Tree的操作的小例子

1、定義一個cs結構的界面：

import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;

public class Test {
    public void run()
    {
       JFrame frame=new JFrame("樹移動");
          frame.setLayout(null);
          frame.setBounds(400, 150, 600, 500);
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setVisible(true);
          JTree leftTree=new JTree();
          leftTree.setBounds(10, 10, 220, frame.getHeight()-40);
          JScrollPane leftScroll=new JScrollPane(leftTree);
          leftScroll.setBounds(10, 10, 220, frame.getHeight()-40);
          JTree rightTree=new JTree();
          rightTree.setBounds(360, 10, 220, frame.getHeight()-40);
          rightTree.setModel(null);
          JScrollPane rightScroll=new JScrollPane(rightTree);
          rightScroll.setBounds(360, 10, 220, frame.getHeight()-40);
          frame.getContentPane().add(leftScroll);
          frame.getContentPane().add(rightScroll);
          JButton treeToRight=new JButton(">>");
          treeToRight.setBounds(260, 100, 80, 25);
          treeToRight.addActionListener(new TreeToRightActionListener(leftTree,rightTree));
          JButton nodeToRight=new JButton(">");
          nodeToRight.setBounds(260, 140, 80, 25);
          nodeToRight.addActionListener(new NodeToRightActionListener(leftTree,rightTree));
          JButton nodeToLeft=new JButton("<");
          nodeToLeft.addActionListener(new NodeToLeftActionListener(rightTree));
          nodeToLeft.setBounds(260, 180, 80, 25);
          JButton treeToLeft=new JButton("<<");
          treeToLeft.addActionListener(new TreeToLeftActionListener(rightTree));
          treeToLeft.setBounds(260, 220, 80, 25);
          frame.getContentPane().add(treeToLeft);
          frame.getContentPane().add(nodeToLeft);
          frame.getContentPane().add(nodeToRight);
          frame.getContentPane().add(treeToRight);
          frame.setBounds(400, 150, 601, 501);
         
    }
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
        new Test().run();
 }
 /**
  * 移除右邊的樹
  * @author admin
  *
  */
    class TreeToLeftActionListener implements ActionListener
    {
        JTree right;
        public TreeToLeftActionListener(JTree right)
        {
         this.right=right;
        }
  public void actionPerformed(ActionEvent arg0) {
   // TODO Auto-generated method stub
   try {
    TreeUtil.removeTree(right);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
    
    }
    /**
     * 移除右邊的樹上節點
     * @author admin
     *
     */
    class NodeToLeftActionListener implements ActionListener
    {
         JTree right;
         public NodeToLeftActionListener(JTree right)
         {
          this.right=right;
         }
  public void actionPerformed(ActionEvent arg0) {
   // TODO Auto-generated method stub
   try {
    TreeUtil.removeNodeFromTree(right);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
    
    }
    /**
     * 樹節點添加到右邊的樹上
     * @author admin
     *
     */
    class NodeToRightActionListener implements ActionListener
    {

     JTree left;
        JTree right;
        public NodeToRightActionListener( JTree left,JTree right)
        {
         this.left=left;
         this.right=right;
        }
  public void actionPerformed(ActionEvent arg0) {
   // TODO Auto-generated method stub
   try {
    TreeUtil.addNodeToTree(left, right);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
    
    }
    /**
     * 添加節點到右邊的樹
     * @author admin
     *
     */
    class TreeToRightActionListener implements ActionListener
    {

     JTree left;
        JTree right;
        public TreeToRightActionListener( JTree left,JTree right)
        {
         this.left=left;
         this.right=right;
        }
  public void actionPerformed(ActionEvent arg0) {
   // TODO Auto-generated method stub
   try {
    TreeUtil.addTree(left, right);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
    
    }
}

 

2、定義Tree的操作方法：

package com.tree.util;

import java.util.List;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
/**
 * ���Դ��ѡ�е�һ��ڵ���ָ����λ�����¹���һ���ýڵ������?
 * }������ͬһ���û���ݶ���}����Ľڵ�·������?
 * @author chenshuang
 *
 */
public class TreeUtil {
 
  /**
     * ���Դ��Ŀ����?
     * @param sTree Դ��
     * @param dTree Ŀ����
     */
    public static void addTree(JTree sTree,JTree dTree) throws Exception
    {
     if(sTree!=null&&sTree.getRowCount()>0)
     {
      TreeModel model=sTree.getModel();
      DefaultMutableTreeNode sRoot=(DefaultMutableTreeNode) model.getRoot();
      DefaultMutableTreeNode dRoot=new DefaultMutableTreeNode();
      dRoot.setUserObject(sRoot.getUserObject());
      addTree(sRoot,dRoot);
      dTree.setModel(new DefaultTreeModel(dRoot));
      TreePath path=new TreePath(dRoot);
     // dTree.expandPath(path);
      dTree.setSelectionPath(path);
      dTree.repaint();
     }
    }

    /**
     * �Ƴ������?
     */
    public static void removeTree(JTree dTree) throws Exception
    {
     if(dTree!=null&&dTree.getRowCount()>0)
        {
      dTree.setModel(null);
      dTree.repaint();
        }
    }
    /**
     * ���һ���ӽڵ�?
     * @param sTree Դ��
     * @param dTree Ŀ����
     */
    public static void addNodeToTree(JTree sTree,JTree dTree) throws Exception
    {
     if(sTree!=null&&sTree.getRowCount()>0)
     {
      TreePath selectedTreePath=sTree.getSelectionPath();
      if(selectedTreePath!=null)
      {
       DefaultMutableTreeNode selectedNode=(DefaultMutableTreeNode) selectedTreePath.getLastPathComponent();
             if(selectedNode!=null&&selectedNode.isLeaf())
             {
              TreeModel model=dTree.getModel();
              DefaultMutableTreeNode rs=null;
              if(model!=null)
              {
               DefaultMutableTreeNode root=(DefaultMutableTreeNode)model.getRoot();
               int position=selectedNode.getParent().getIndex(selectedNode);
                     rs=addNode(selectedNode,root,position);
                     dTree.setModel(new DefaultTreeModel(rs.getRoot()));
                     TreePath path=new TreePath(rs.getRoot());
                     dTree.expandPath(path);
                     dTree.setSelectionPath(path);
                   //  dTree.expandPath(rs.getPath());
              }
              if(rs==null)
              {
                  model=sTree.getModel();
                  DefaultMutableTreeNode sRoot=(DefaultMutableTreeNode) model.getRoot();
                  DefaultMutableTreeNode dRoot=new DefaultMutableTreeNode();
                  dRoot.setUserObject(sRoot.getUserObject());
                  //��ӵ�һ��ڵ�
                  rs=addToPath(1,dRoot,selectedNode.getPath(),-1,false);
                  dTree.setModel(new DefaultTreeModel(dRoot));
                  TreePath path=new TreePath(dRoot);
                  dTree.expandPath(path);
                  dTree.setSelectionPath(path);
                  //dTree.expandPath(path);
                 
              }
              dTree.repaint();
             }
      }
     
     }
    }
    /**
     * �Ƴ�һ���ӽڵ�
     */
    public static void removeNodeFromTree(JTree dTree) throws Exception
    {
     if(dTree!=null&&dTree.getRowCount()>0)
     {
      TreePath selectedTreePath=dTree.getSelectionPath();
      if(selectedTreePath!=null)
      {
       DefaultMutableTreeNode selectedNode=(DefaultMutableTreeNode) selectedTreePath.getLastPathComponent();
             if(selectedNode!=null&&selectedNode.isLeaf())
             {
              DefaultMutableTreeNode child=removeChild(selectedNode);
                 if(child!=null)
                 {
                  dTree.setModel(new DefaultTreeModel(child.getRoot()));
                      TreePath path=new TreePath(child.getRoot());
                      dTree.expandPath(path);
                      dTree.setSelectionPath(path);
                   /*if(child.getParent()!=null)
                   {
                    dTree.expandPath(path);
                   }
                   */
                   dTree.repaint();
                 }
                 else
                 {
                  dTree.setModel(null);
                  dTree.repaint();
                 }
             }
        }
     }
    }

    /**
     * ��������Ҷ�ڵ��Ӧ���û����
     * @param list �û���ݴ��λ��
     * @param rootNode ��ڵ�?
     */
    public static void getAllChildUserObject(List list,DefaultMutableTreeNode rootNode)
    {
     if(rootNode!=null)
     {
      int count=rootNode.getChildCount();
      if(count>0)
      {
       for(int i=0;i<count;i++)
       {
        DefaultMutableTreeNode child=(DefaultMutableTreeNode) rootNode.getChildAt(i);
        if(!child.isLeaf())
        {
         getAllChildUserObject(list,child);
        }
        else
        {
         list.add(child.getUserObject());
        }
       }
      }
     }
    }
    /**
     * ɾ���ӽڵ�
     * @param parent
     * @return
     */
    private static DefaultMutableTreeNode removeChild(DefaultMutableTreeNode child)
    {
     int count=child.getChildCount();
     if(count==0)
     {
      DefaultMutableTreeNode node=(DefaultMutableTreeNode) child.getParent();
      if(node==null)
      {
       return null;
      }
      node.remove(child);
      count=node.getChildCount();
      child=node;
      if(count==0)
      {
       return removeChild(child);
      }
     }
     return child;
    }
    /**
     * ��ӽڵ�?
     * @param nodeҪ��ӵĽڵ�?
     * @param rootNode ��ڵ�?
     * @return
     */
    private static DefaultMutableTreeNode addNode(DefaultMutableTreeNode node,DefaultMutableTreeNode rootNode,int position)
    {
     if(rootNode!=null)
     {
      int count=rootNode.getChildCount();
      if(count==0)
      {
       return null;
      }
      for(int i=0;i<count;i++)
      {
       DefaultMutableTreeNode child=(DefaultMutableTreeNode)rootNode.getChildAt(i);
                if(child.getUserObject().equals(node.getUserObject()))
                {//���ҵ���
                 return child;
                }
                else
                {
                 DefaultMutableTreeNode rs=addNode(node,child,position);
                 if(rs!=null&&rs.getUserObject().equals(node.getUserObject()))
                 {//�Ѿ��ҵ��˾ͷ���
                  return rs;
                 }
                 else
                 {
                  if(isContains((DefaultMutableTreeNode)child.getParent(),node.getPath()))
                  {//ƥ��·��
                   if(rs==null&&((DefaultMutableTreeNode)child.getParent()).getPath().length==((DefaultMutableTreeNode)node.getParent()).getPath().length)
                      {//��ӵ����һ��ڵ���?
                    if(!enableAdd((DefaultMutableTreeNode)child.getParent(),node))
                    {
                     DefaultMutableTreeNode toAdd=new DefaultMutableTreeNode();
                           toAdd.setUserObject(node.getUserObject());
                           position=addPosition((DefaultMutableTreeNode)child.getParent(),node,position);
                           ((DefaultMutableTreeNode)child.getParent()).insert(toAdd,position);
                           return toAdd;
                    }
                      }
                   else if(rs==null&&((DefaultMutableTreeNode)child.getParent()).getPath().length<((DefaultMutableTreeNode)node.getParent()).getPath().length)
                   {//���м�λ����ӽڵ�?
                    int start=((DefaultMutableTreeNode)child.getParent()).getPath().length;
                    if(!validatePath((DefaultMutableTreeNode)child.getParent(),node.getPath(),start))
                    {
                     return addToPath(start,((DefaultMutableTreeNode)child.getParent()),node.getPath(),position,false);
                    }
                   }
                   else if(rs==null&&((DefaultMutableTreeNode)child.getParent()).getPath().length>((DefaultMutableTreeNode)node.getParent()).getPath().length)
                   {//�����������?
                    int start=((DefaultMutableTreeNode)node.getParent()).getPath().length-1;
                    return addToPath(start,node,((DefaultMutableTreeNode)child.getParent()).getPath(),position,true);
                   }
                      else if(rs.getUserObject().equals(node.getUserObject()))
                      {
                       //�Ѿ���ӹ��ֱ�ӷ���
                    return rs;
                      }
                  
                  }
                 }
                }
      }
     
     }
     return null;
    
    }
    /**
     * ����Ҫ��ӵĽڵ��λ��
     * @param parent
     * @param node
     * @param position
     * @return
     */
    private static int addPosition(DefaultMutableTreeNode parent,DefaultMutableTreeNode node,int position)
    {
     int count=parent.getChildCount();
     int newPosition=-1;
     int po=0;
     int max=-1;
     int maxV=-1;//���λ��?
     int min=-1;
     int minV=-1;//��Сλ��
     for(int i=0;i<count;i++)
     {
      int oldCount=node.getParent().getChildCount();
      for(int j=0;j<oldCount;j++)
      {
       if(((DefaultMutableTreeNode)node.getParent().getChildAt(j)).getUserObject().equals(((DefaultMutableTreeNode)parent.getChildAt(i)).getUserObject()))
       {
        po=node.getParent().getIndex(node.getParent().getChildAt(j));
        break;
       }
      }
      if(position>po)
      {
       if(position==po+1)
       {//�����ڵ�λ��
        newPosition=i+1;
        min=-1;
        break;
       }
       else
       {
        if(minV==-1)
        {//first time
         minV=po;
         min=i+1;
        }
        else if(po<minV)
        {
         minV=po;
         min=i+1;
        }
       }
      }
      else
      {
       if(position==po-1)
       {//�����ڵ�λ��
        newPosition=i-1;
        max=-1;
        break;
       }
       else
       {
        if(po>maxV)
        {
         maxV=po;
         max=i-1;
        }
       
       }
      }
     }
     if(newPosition<0)
     {
      if(minV>=0&&maxV>0)
         {//�м�λ��
          newPosition=max;
         }
         else
         {
          if(minV>=0)
          {//��ӵ���Сֵ�����
           newPosition=min;
          }
          else if(maxV>=0)
          {//��ӵ����ֵ��ǰ��
           newPosition=max;
           if(newPosition<0)
           {
            newPosition+=1;
           }
          }
          else
          {
           newPosition=min+1;
          }
         }
     }
     if(newPosition<0)
     {
      newPosition=count;
     }
     //Ĭ�������һ��λ��?
     return newPosition;
    }
    /**
     * �Ƿ�������
     * @param parent
     * @param child
     * @return
     */
    private static boolean enableAdd(DefaultMutableTreeNode parent,DefaultMutableTreeNode child)
    {
     int count=parent.getChildCount();
     if(count==0)
     {
      return false;
     }
     for(int i=0;i<count;i++)
     {
      DefaultMutableTreeNode node=(DefaultMutableTreeNode) parent.getChildAt(i);
      if(node.getUserObject().equals(child.getUserObject()))
      {
       return true;
      }
     
     }
     return false;
    }
    /**
     * ��֤·���Ƿ����?
     * @param parent
     * @param path
     * @param start
     * @return
     */
    private static boolean validatePath(DefaultMutableTreeNode parent,TreeNode[] path,int start)
    {
     int count=parent.getChildCount();
     if(count==0)
     {
      return false;
     }
     for(int i=0;i<count;i++)
     {
      DefaultMutableTreeNode node=(DefaultMutableTreeNode) parent.getChildAt(i);
      if(!node.isLeaf())
      {
       for(int j=start;j<path.length;j++)
       {
        if(((DefaultMutableTreeNode)path[j]).getUserObject().equals(node.getUserObject()))
        {
         return true;
        }
       }
      }
     }
     return false;
    }
    /**
     * ��ָ��λ�ÿ�ʼ���?
     * @param start ��ʼλ��
     * @param child ���λ��?
     * @param path ·��
     * @param flag��ʾ��(true�������£�false��������)
     */
    private static DefaultMutableTreeNode addToPath(int start,DefaultMutableTreeNode child,TreeNode[] path,int position,boolean flag)
    {
     DefaultMutableTreeNode toAdd=null;
     if(!flag)
     {//�����������?
      if(position!=-1)
      {
       position=path[start].getParent().getIndex(path[start]);
    position=addPosition((DefaultMutableTreeNode)child,(DefaultMutableTreeNode)path[start],position);
    for(int i=start;i<path.length;i++)
          {
     toAdd=new DefaultMutableTreeNode();
           toAdd.setUserObject(((DefaultMutableTreeNode)path[i]).getUserObject());
     if(i==start)
     {//��ӵ�?ָ��λ��
      child.insert(toAdd,position);
      child=toAdd;
     }
     else
     {
      child.add(toAdd);
               child=toAdd;
     }
          }
      }
      else
      {
       for(int i=start;i<path.length;i++)
             {
              toAdd=new DefaultMutableTreeNode();
               toAdd.setUserObject(((DefaultMutableTreeNode)path[i]).getUserObject());
              child.add(toAdd);
              child=toAdd;
             }
      }
     }
     else
     {//�����������?
      if(!enableAdd((DefaultMutableTreeNode)path[start],child))
      {
       toAdd=new DefaultMutableTreeNode();
          toAdd.setUserObject(child.getUserObject());
          if((DefaultMutableTreeNode)path[start].getParent()==null)
          {//��u-32126 ��
           position=addPosition((DefaultMutableTreeNode)path[start],child,position);
          }
          else
          {
           position=addPosition((DefaultMutableTreeNode)path[start].getParent(),child,position);
          }
       ((DefaultMutableTreeNode)path[start]).insert(toAdd,position);
      }
     }
     return toAdd;
    }
    /**
     * �ж�ij���ӽڵ��Ƿ���ָ����·����
     * @param child �ӽڵ�ĸ��ڵ�?
     * @param path ѡ�нڵ��·��?
     * @return
     */
    private static boolean isContains(DefaultMutableTreeNode child,TreeNode[] path)
    {
     if(child.getPath().length<path.length)
     {//����ƥ��
      for(int i=path.length-1;i>=0;i--)
         {
          DefaultMutableTreeNode node=(DefaultMutableTreeNode) path[i];
          if(node.getUserObject().equals(child.getUserObject()))
          {
           return true;
          }
         }
     }
     else
     {//����ƥ��
      path=child.getPath();
      child=(DefaultMutableTreeNode) path[path.length-2];
      for(int i=0;i<path.length;i++)
      {
       DefaultMutableTreeNode node=(DefaultMutableTreeNode) path[i];
          if(node.getUserObject().equals(child.getUserObject()))
          {
           return true;
          }
      }
     
     }
    
     return false;
    }
  
    /**
     * �����ӽڵ�
     * @param sNode Դ��
     * @param dNode Ŀ����
     * @return
     */
    private static void addTree(DefaultMutableTreeNode sNode,DefaultMutableTreeNode dNode)
    {
     if(sNode!=null)
     {
      int count=sNode.getChildCount();
      for(int i=0;i<count;i++)
      {
       DefaultMutableTreeNode child=(DefaultMutableTreeNode) sNode.getChildAt(i);
       DefaultMutableTreeNode parent=null;
       if(!child.isLeaf())
       {
           parent=new DefaultMutableTreeNode();
                 parent.setUserObject(child.getUserObject());
                 dNode.add(parent);
       }
                if(!child.isLeaf())
                {
                 addTree(child,parent);
                }
                else
                {
                 DefaultMutableTreeNode toAdd=new DefaultMutableTreeNode();
              toAdd.setUserObject(child.getUserObject());
              dNode.add(toAdd);
                }
      }
     
     }
    }
}