Swing 中实现带有JComboBox的树

package tree;

import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.Enumeration;

import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.tree.DefaultMutableTreeNode;

/**
 * 选项面板中导入导出时，选择树节点
 *
 * @version 1.0 01/11/99
 *
 */
public class CheckNode extends DefaultMutableTreeNode {

 public final static int SINGLE_SELECTION = 0;

 public final static int DIG_IN_SELECTION = 4;

 protected int selectionMode;

 protected boolean isSelected;

 public CheckNode() {
  this(null);
 }

 public CheckNode(Object userObject) {
  this(userObject, true, false);

 }

 public CheckNode(Object userObject, boolean allowsChildren,
   boolean isSelected) {
  super(userObject, allowsChildren);

  this.isSelected = isSelected;
  setSelectionMode(SINGLE_SELECTION);
 }

 public void setSelectionMode(int mode) {
  selectionMode = mode;
 }

 public int getSelectionMode() {
  return selectionMode;
 }

 /**
  * 是否为自己手动选择树节点
  */
 static boolean stateFlag = true;

 /**
  * 是否为从叶子节点选择树
  */
 static boolean tempFlag = false;

 public void setSelected(boolean isSelected) {
  this.isSelected = isSelected;

  CheckNode nodeComBox = null;

  // 获得下拉列表框中数据
  String comBox = SelectNumber.teljComboBox.getSelectedItem().toString();

  if (stateFlag) {

   if (children == null) {
    tempFlag = true;
   }
   stateFlag = false;

   if (isSelected) {
    // 判断是否有子节点
    if ((selectionMode == SINGLE_SELECTION) && (null != children)) {

     setNodeSelectView(isSelected, comBox);
    }
    else {
     setParentNodeSelectView();
    }
   } else {
    // 判断是否有子节点
    if ((selectionMode == SINGLE_SELECTION) && (null != children)) {
     setChildrenNotSelect(isSelected);
    }
    else {

     // 获得父节点
     CheckNode node = (CheckNode) this.getParent();

     if (node != null) {
      // 查找父节点中的所有子节点
      Enumeration vec = node.children();
      boolean nodeFlag = false;
      while (vec.hasMoreElements()) {
       CheckNode nodeValue = (CheckNode) vec.nextElement();

       // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
       if (nodeValue.isSelected) {
        nodeFlag = true;
        break;
       }
      }

      // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
      if (!nodeFlag) {
       node.setSelected(false);
      }
     }
    }
   }

  } else {
   if (isSelected) {

    if (tempFlag) {
     
     //设置父节点选中
     setParentNodeSelectView();
    } else {
     // 判断是否有子节点
     if ((selectionMode == SINGLE_SELECTION)
       && (null != children)) {

      //设置节点选中
      setNodeSelectView(isSelected, comBox);
     } else {
      tempFlag = true;
      
      //设置父节点选中
      setParentNodeSelect();
     }
    }
   } else {

    if (tempFlag) {
     // 获得父节点
     CheckNode node = (CheckNode) this.getParent();

     if (node != null) {
      // 查找父节点中的所有子节点
      Enumeration vec = node.children();
      boolean nodeFlag = false;
      while (vec.hasMoreElements()) {
       CheckNode nodeValue = (CheckNode) vec.nextElement();

       // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
       if (nodeValue.isSelected) {
        nodeFlag = true;
        break;
       }
      }

      // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
      if (!nodeFlag) {
       node.setSelected(false);
      }
     }
    } else {
     // 判断是否有子节点
     if ((selectionMode == SINGLE_SELECTION)
       && (null != children)) {

      //设置子节点不选中
      setChildrenNotSelect(isSelected);
     } else {
      tempFlag = true;
      // 获得父节点
      CheckNode node = (CheckNode) this.getParent();

      if (node != null) {
       //设置父节点不选中
       setParentNotSelect(node);
      }
     }
    }
   }
  }
 }

 private void setParentNodeSelectView() {
  // 获得父节点
  CheckNode node = (CheckNode) this.getParent();

  if (node != null) {
   node.setSelected(true);
  }
 }

 private void setChildrenNotSelect(boolean isSelected) {
  // 获得选择节点的所有子节点
  Enumeration enumer = children.elements();
  while (enumer.hasMoreElements()) {
   // 获得具体子节点对象
   CheckNode node = (CheckNode) enumer.nextElement();

   // 判断是否为叶子节点
   if (node.isLeaf()) {

    // 判断该节点是否与下拉列表中的值相同。如果父节点被选中，则让相同该节点处于选中状态
    node.setSelected(isSelected);
   } else {
    node.setSelected(isSelected);
   }
  }
 }

 private void setParentNotSelect(CheckNode node) {
  // 查找父节点中的所有子节点
  Enumeration vec = node.children();
  boolean nodeFlag = false;
  while (vec.hasMoreElements()) {
   CheckNode nodeValue = (CheckNode) vec
     .nextElement();

   // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
   if (nodeValue.isSelected) {
    nodeFlag = true;
    break;
   }
  }

  // 判断所有子节点是否被选中，如果有选中则父节点被选中。否则父节点不选中
  if (!nodeFlag) {
   node.setSelected(false);
  }
 }

 private void setParentNodeSelect() {
  // 获得父节点
  CheckNode node = (CheckNode) this.getParent();

  if (node != null) {
   node.setSelected(true);
  }
 }

 private void setNodeSelectView(boolean isSelected, String comBox) {
  // 获得选择节点的所有子节点
  Enumeration enumer = children.elements();
  while (enumer.hasMoreElements()) {
   // 获得具体子节点对象
   CheckNode node = (CheckNode) enumer.nextElement();

   // 判断是否为叶子节点
   if (node.isLeaf()) {

    // 判断该节点是否与下拉列表中的值相同。如果父节点被选中，则让相同该节点处于选中状态
    if (node.toString().indexOf(comBox) != -1) {
     node.setSelected(isSelected);
    }
   } else {
    node.setSelected(isSelected);
   }
  }
 }

 public boolean isSelected() {
  return isSelected;
 }
}

package tree;

 

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class MainTest {
  static JFrame jFrame;
 public static void main(String[] args) {
   jFrame = new JFrame();
   JButton db = new JButton("hello");
   db.addActionListener(new ActionListener(){

   public void actionPerformed(ActionEvent e) {
    // TODO Auto-generated method stub
//    SelectNumber test =  SelectNumber.getSelectNumber(jFrame);
    SelectNumber test = new SelectNumber(jFrame);
//    test.teljComboBox =null;
    test.setVisible(true);
   }
   
   });
   jFrame.add(db);
   jFrame.setSize(200,200);
   jFrame.setLocation(200,300);
   jFrame.setVisible(true);
   jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 }
}

package tree;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
//节点被选中，鼠标监听
class NodeSelectionListener extends MouseAdapter
{
    JTree tree;

    NodeSelectionListener(JTree tree)
    {
 this.tree = tree;
    }

    public void mouseClicked(MouseEvent e)
    {
 int x = e.getX();
 int y = e.getY();
 int row = tree.getRowForLocation(x, y);
 TreePath path = tree.getPathForRow(row);
 // TreePath path = tree.getSelectionPath();
 if (null != path)
 {
     CheckNode node = (CheckNode) path.getLastPathComponent();
     boolean isSelected = !(node.isSelected());
     node.setSelected(isSelected);
     if (node.getSelectionMode() == CheckNode.SINGLE_SELECTION)
     {
  if (isSelected)
  {
   CheckNode.stateFlag = true;
   CheckNode.tempFlag = false;
   System.out.println("uuuuuuuuuuuu");
      tree.expandPath(path);
  } else
  {
   CheckNode.stateFlag = true;
   CheckNode.tempFlag = false;
   System.out.println("kkkkkkkkkkkkk");
      tree.collapsePath(path);
  }
     }
     ((DefaultTreeModel) tree.getModel()).nodeChanged(node);
     // I need revalidate if node is root. but why?
     if (row == 0)
     {
  tree.revalidate();
  tree.repaint();
     }
 }
    }
}

package tree;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;

import javax.swing.JCheckBox;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.tree.TreeCellRenderer;

//设置节点被选中
class CheckTreeRenderer2  extends JPanel implements TreeCellRenderer{
    private CheckTreeSelectionModel selectionModel;
    private TreeCellRenderer delegate ;
//    private JCheckBox checkBox = new JCheckBox();
    protected   boolean   m_selected; 
    CheckNode[] nodes = null;
    protected JCheckBox check ;
//    = new JCheckBox();

    protected TreeLabel label ;
//    = new TreeLabel();
    public CheckTreeRenderer2()
    {
// setLayout(null);
     this.setBackground(Color.WHITE);
 add(check = new JCheckBox());
 add(label = new TreeLabel());
 
    }

    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus){
     String stringValue = tree.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
     setEnabled(tree.isEnabled());
//     System.out.println("======"+((CheckNode) value).isSelected());
     check.setSelected(((CheckNode) value).isSelected());
     label.setFont(tree.getFont());
     label.setText(stringValue+"fff");
     label.setSelected(selected);
     label.setFocus(hasFocus);
//     DefaultMutableTreeNode   node   =  
//            (DefaultMutableTreeNode)value;
//     System.out.println(node);
//     System.out.println(value);
//     Object   obj   =   node.getUserObject();  
//     checkBox.setText(obj.toString());
//     m_selected   =   selected;
//     checkBox.setSelected(m_selected);
        return this;
      
    }
    public Dimension getPreferredSize()
    {
 Dimension d_check = check.getPreferredSize();
 Dimension d_label = label.getPreferredSize();
 return new Dimension(d_check.width + d_label.width, (d_check.height < d_label.height ? d_label.height
  : d_check.height));
    }
//
    public void doLayout()
    {
 Dimension d_check = check.getPreferredSize();
 Dimension d_label = label.getPreferredSize();
 int y_check = 0;
 int y_label = 0;
 if (d_check.height < d_label.height)
 {
     y_check = (d_label.height - d_check.height) / 2;
 } else
 {
     y_label = (d_check.height - d_label.height) / 2;
 }
 check.setLocation(0, y_check);
 check.setBounds(0, y_check, d_check.width, d_check.height);
 check.setBackground(Color.WHITE);
 label.setLocation(d_check.width, y_label);
 label.setBackground(Color.WHITE);
// label.setDoubleBuffered(true);
// label.setBackground(Color.WHITE);
 label.setBounds(d_check.width, y_label, d_label.width, d_label.height);
    }
}

package tree;

import java.util.ArrayList;
import java.util.Stack;

import javax.swing.tree.DefaultTreeSelectionModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
/**
 * 选项面板中导入导出时,设置树节点模型

 * @version 1.0 01/11/99
 * @author XZQ
 *
 */
public class CheckTreeSelectionModel extends DefaultTreeSelectionModel
{
    private TreeModel model;

    public CheckTreeSelectionModel(TreeModel model)
    {
 this.model = model;
 setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
    }

    // tests whether there is any unselected node in the subtree of given
    // path
    public boolean isPartiallySelected(TreePath path)
    {
 if (isPathSelected(path, true))
     return false;
 TreePath[] selectionPaths = getSelectionPaths();
 if (null == selectionPaths)
     return false;
 for (int j = 0; j < selectionPaths.length; j++)
 {
     if (isDescendant(selectionPaths[j], path))
  return true;
 }
 return false;
    }

    // tells whether given path is selected.
    // if dig is true, then a path is assumed to be selected, if
    // one of its ancestor is selected.
    public boolean isPathSelected(TreePath path, boolean dig)
    {
 if (!dig)
     return super.isPathSelected(path);
 while (null != path && !super.isPathSelected(path))
     path = path.getParentPath();
 return path != null;
    }

    // is path1 descendant of path2
    private boolean isDescendant(TreePath path1, TreePath path2)
    {
 Object obj1[] = path1.getPath();
 Object obj2[] = path2.getPath();
 for (int i = 0; i < obj2.length; i++)
 {
     if (obj1[i] != obj2[i])
  return false;
 }
 return true;
    }

    public void setSelectionPaths(TreePath[] pPaths)
    {
 throw new UnsupportedOperationException("not implemented yet!!!");
    }

    public void addSelectionPaths(TreePath[] paths)
    {
 // unselect all descendants of paths[]
 for (int i = 0; i < paths.length; i++)
 {
     TreePath path = paths[i];
     TreePath[] selectionPaths = getSelectionPaths();
     if (null == selectionPaths)
  break;
     ArrayList toBeRemoved = new ArrayList();
     for (int j = 0; j < selectionPaths.length; j++)
     {
  if (isDescendant(selectionPaths[j], path))
      toBeRemoved.add(selectionPaths[j]);
     }
     super.removeSelectionPaths((TreePath[]) toBeRemoved.toArray(new TreePath[0]));
 }

 // if all siblings are selected then unselect them and select parent
 // recursively
 // otherwize just select that path.
 for (int i = 0; i < paths.length; i++)
 {
     TreePath path = paths[i];
     TreePath temp = null;
     while (areSiblingsSelected(path))
     {
  temp = path;
  if (null == path.getParentPath())
      break;
  path = path.getParentPath();
     }
     if (null != temp)
     {
  if (null != temp.getParentPath())
      addSelectionPath(temp.getParentPath());
  else
  {
      if (!isSelectionEmpty())
   removeSelectionPaths(getSelectionPaths());
      super.addSelectionPaths(new TreePath[]
      { temp });
  }
     } else
  super.addSelectionPaths(new TreePath[]
  { path });
 }
    }

    // tells whether all siblings of given path are selected.
    private boolean areSiblingsSelected(TreePath path)
    {
 TreePath parent = path.getParentPath();
 if (null == parent)
     return true;
 Object node = path.getLastPathComponent();
 Object parentNode = parent.getLastPathComponent();

 int childCount = model.getChildCount(parentNode);
 for (int i = 0; i < childCount; i++)
 {
     Object childNode = model.getChild(parentNode, i);
     if (childNode == node)
  continue;
     if (!isPathSelected(parent.pathByAddingChild(childNode)))
  return false;
 }
 return true;
    }

    public void removeSelectionPaths(TreePath[] paths)
    {
 for (int i = 0; i < paths.length; i++)
 {
     TreePath path = paths[i];
     if (path.getPathCount() == 1)
  super.removeSelectionPaths(new TreePath[]
  { path });
     else
  toggleRemoveSelection(path);
 }
    }

    // if any ancestor node of given path is selected then unselect it
    // and selection all its descendants except given path and descendants.
    // otherwise just unselect the given path
    private void toggleRemoveSelection(TreePath path)
    {
 Stack stack = new Stack();
 TreePath parent = path.getParentPath();
 while (null != parent && !isPathSelected(parent))
 {
     stack.push(parent);
     parent = parent.getParentPath();
 }
 if (null != parent)
     stack.push(parent);
 else
 {
     super.removeSelectionPaths(new TreePath[]
     { path });
     return;
 }

 while (!stack.isEmpty())
 {
     TreePath temp = (TreePath) stack.pop();
     TreePath peekPath = stack.isEmpty() ? path : (TreePath) stack.peek();
     Object node = temp.getLastPathComponent();
     Object peekNode = peekPath.getLastPathComponent();
     int childCount = model.getChildCount(node);
     for (int i = 0; i < childCount; i++)
     {
  Object childNode = model.getChild(node, i);
  if (childNode != peekNode)
      super.addSelectionPaths(new TreePath[]
      { temp.pathByAddingChild(childNode) });
     }
 }
 super.removeSelectionPaths(new TreePath[]
 { parent });
    }
} 

package tree;

import javax.swing.JPanel;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.BorderLayout;
import java.awt.Graphics;

import javax.swing.JDialog;
import javax.swing.JComboBox;
import java.awt.Rectangle;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.UIManager;

import java.awt.GridBagConstraints;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.swing.JTree;
import javax.swing.plaf.ColorUIResource;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import javax.swing.JLabel;

import sun.security.provider.SystemSigner;

/**
 * 选择发送号码
 *
 * @author XZQ
 *
 */
public class SelectNumber extends JDialog {

 private static final long serialVersionUID = 1L;
 
 public static boolean flag = true;

 private JPanel jContentPane = null;

 public static JComboBox teljComboBox = new JComboBox();
// public JComboBox teljComboBox = new JComboBox();

 private JPanel leftjPanel = null;

 private JButton canceljButton = null;

 private JButton okjButton = null;

 private JTable rightjTable = null; // @jve:decl-index=0:visual-constraint="478,155"

 private JButton moverightjButton = null;

 private JButton moveleftjButton = null;

 private JPanel rightjPanel = null;

 private JScrollPane rightjScrollPane = null;

 private JScrollPane leftjScrollPane = null;

 private JTree leftjTree = null;

 private JLabel rightjLabel = null;

 private JFrame jDialog;

 /**
  * @param jFrame
  */
 public static SelectNumber instance = null;
// public static SelectNumber getSelectNumber(JFrame jFrame){
//  if(instance == null){
//   instance = new SelectNumber(jFrame);
//  }
//  return instance;
// }
 public SelectNumber(JFrame jDialog) {
  super(jDialog);
  this.jDialog = jDialog;
  initialize();
 }

 /**
  * This method initializes this
  *
  * @return void
  */
 private void initialize() {
  this.setSize(430, 360);
  this.setLocation(this.jDialog.getX() - 20, this.jDialog.getY() - 30);
  // this.setBackground();
  this.setModal(true);
  this.setContentPane(getJContentPane());
 }

 /**
  * This method initializes jContentPane 右提示面板
  *
  * @return javax.swing.JPanel
  */
 private JPanel getJContentPane() {
  if (jContentPane == null) {
   rightjLabel = new JLabel();
   rightjLabel.setBounds(new Rectangle(209, 3, 206, 29));
   rightjLabel.setText("提示");
   jContentPane = new JPanel();
   jContentPane.setLayout(null);
   jContentPane.add(getTeljComboBox(), null);
   jContentPane.add(getLeftjPanel(), null);
   jContentPane.add(getCanceljButton(), null);
   jContentPane.add(getOkjButton(), null);
   jContentPane.add(getMoverightjButton(), null);
   jContentPane.add(getMoveleftjButton(), null);
   jContentPane.add(getRightjPanel(), null);
   // jContentPane.add(getLeftjTree(), null);
   jContentPane.add(rightjLabel, null);
   // jContentPane.setBackground();
  }
  return jContentPane;
 }

 /**
  * This method initializes teljComboBox 下拉框列表
  *
  * @return javax.swing.JComboBox
  */
 public String st;
 public JComboBox getTeljComboBox() {
//  if (teljComboBox == null) {
//   teljComboBox = new JComboBox();
//   teljComboBox.setBounds(new Rectangle(7, 5, 127, 27));
//  }
  teljComboBox = null;
  teljComboBox = new JComboBox();
  teljComboBox.setBounds(new Rectangle(7, 5, 127, 27));
  teljComboBox.addItem("移动电话");
  teljComboBox.addItem("办公电话");
  teljComboBox.addItem("家庭电话");
  st = (String)teljComboBox.getSelectedItem();
  teljComboBox.addItemListener(new ItemListener(){

   public void itemStateChanged(ItemEvent e) {
    st = (String)teljComboBox.getSelectedItem();
    teljComboBox.getModel().setSelectedItem(st);
    
   } 
  });
  return teljComboBox;
 }

 /**
  * This method initializes leftjPanel 左面板
  *
  * @return javax.swing.JPanel
  */
 private JPanel getLeftjPanel() {
  if (leftjPanel == null) {
   leftjPanel = new JPanel();
   // leftjPanel.setLayout(new GridBagLayout());
   leftjPanel.setBounds(new Rectangle(6, 35, 131, 231));
   // leftjPanel.setSize(120,230);
   leftjPanel.add(getLeftjScrollPane());
   // leftjPanel.setBackground();
  }
  return leftjPanel;
 }

 /**
  * This method initializes canceljButton 取消按钮
  *
  * @return javax.swing.JButton
  */
 private JButton getCanceljButton() {
  if (canceljButton == null) {
   canceljButton = new JButton();
   canceljButton.setBounds(new Rectangle(337, 285, 73, 30));
   canceljButton.setText("取消");
  }
  canceljButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    close();
   }
  });
  return canceljButton;
 }

 /**
  * This method initializes okjButton 确定按钮
  *
  * @return javax.swing.JButton
  */
 private JButton getOkjButton() {
  if (okjButton == null) {
   okjButton = new JButton();
   okjButton.setBounds(new Rectangle(251, 286, 73, 30));
   okjButton.setText("确定");
  }
  okjButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    close();
   }
  });
  return okjButton;
 }

 /**
  * This method initializes moverightjButton 右移按钮
  *
  * @return javax.swing.JButton
  */

 private JButton getMoverightjButton() {
  if (moverightjButton == null) {
   moverightjButton = new JButton();
   moverightjButton.setBounds(new Rectangle(144, 73, 61, 28));
   moverightjButton.setText(">>");
   moverightjButton.addActionListener(new ActionListener() {

    public void actionPerformed(ActionEvent e) {
     // TODO Auto-generated method stub
     CheckNode root = rootNodes[0];
     Enumeration enumer = root.breadthFirstEnumeration();

     while (enumer.hasMoreElements()) {

      CheckNode node = (CheckNode) enumer.nextElement();
      if (node.isLeaf()) {
       if (node.isSelected) {
        if (node.toString().indexOf("家庭电话") > -1
          || node.toString().indexOf("移动电话") > -1
          || node.toString().indexOf("办公电话") > -1) {
         String[] name = node.toString().split(" ");
         CheckNode nodeParent = (CheckNode) node
           .getParent();
         String[] tableDate = {nodeParent.toString(), name[0],name[1] };
         if (rightjTable.getRowCount() == 0) {
          def.addRow(tableDate);
          rightjTable.setModel(def);
         } else {
          boolean flag = false;
          String[] temp = null;
          for (int i = 0; i < rightjTable
            .getRowCount(); i++) {
           String column = (String) rightjTable
             .getValueAt(i, 2);
           if (column
             .equalsIgnoreCase(name[1])) {
            flag = true;
            temp = null;
            break;
           }
           String[]tableDat = {nodeParent.toString(), name[0],name[1] };
           temp = tableDat;
          }
//          System.out.println("temp===="+temp);
          if(temp != null){
           def.addRow(temp);
              rightjTable.setModel(def);
          }
//          if(!flag)
//          {
//              def.addRow(tableDate);
//              rightjTable.setModel(def);
//          }
         }
        }
       }
      }
      // if (node.isSelected())
      // {
      // System.out.println("node.isSelected()=="+node);
      // TreeNode[] nodes = node.getPath();
      //     
      // for (int i = 1; i < nodes.length; i++)
      // {
      //       
      // }
      // }
     }
     // System.out
     // .println("leftjTree.getLastSelectedP========"+leftjTree.getLastSelectedPathComponent());

    }

   });
  }
  return moverightjButton;
 }

 /**
  * This method initializes moveleftjButton 左移按钮
  *
  * @return javax.swing.JButton
  */
 private JButton getMoveleftjButton() {
  if (moveleftjButton == null) {
   moveleftjButton = new JButton();
   moveleftjButton.setBounds(new Rectangle(144, 114, 61, 27));
   moveleftjButton.setText("<<");
   moveleftjButton.addActionListener(new ActionListener() {

    public void actionPerformed(ActionEvent e) {
     // TODO Auto-generated method stub
     DefaultTableModel tableModel = (DefaultTableModel) rightjTable
       .getModel();
     Vector vect = tableModel.getDataVector();
     // System.out.println("rightjTable.getSelectedRows()========"+rightjTable.getSelectedRows().length);
     int[] selectRow = rightjTable.getSelectedRows();

     for (int i = selectRow.length - 1; i >= 0; i--) {
      // System.out.println("selectRow[i]====1===="+selectRow[i]);
      // rightjTable.remove(selectRow[i]);
      tableModel.removeRow(selectRow[i]);

     }
    }
   });
  }
  return moveleftjButton;
 }

 private void close() {
  this.dispose();
 }

 /**
  * This method initializes rightjPanel 右面板
  *
  * @return javax.swing.JPanel
  */
 private JPanel getRightjPanel() {
  if (rightjPanel == null) {
   GridBagConstraints gridBagConstraints = new GridBagConstraints();
   gridBagConstraints.fill = GridBagConstraints.BOTH;
   gridBagConstraints.gridy = 0;
   gridBagConstraints.weightx = 1.0;
   gridBagConstraints.weighty = 1.0;
   gridBagConstraints.gridx = 0;
   rightjPanel = new JPanel();
   rightjPanel.setLayout(new GridBagLayout());
   rightjPanel.setBounds(new Rectangle(210, 33, 205, 236));
   rightjPanel.add(getRightjScrollPane(), gridBagConstraints);
   // rightjPanel.setBackground(ChangeColor.getColor(CustomizeInit.getCustomizeBean()
   // .getNetWorkPanel_1()));
  }
  return rightjPanel;
 }

 /**
  * This method initializes rightjScrollPane 右面板滚动条
  *
  * @return javax.swing.JScrollPane
  */
 private JScrollPane getRightjScrollPane() {
  if (rightjScrollPane == null) {
   rightjScrollPane = new JScrollPane(getRightjTable());
   // rightjScrollPane.getViewport().setView(getRighjTable1());
  }
  return rightjScrollPane;
 }

 /**
  * This method initializes righjTable 右面板表格
  *
  * @return javax.swing.JTable
  */
 DefaultTableModel def;

 String[] title = { "姓名", "电话类型", "电话号码" };

 private JTable getRightjTable() {
  if (rightjTable == null) {

   String[][] data = new String[0][3];
   int value = 1;
   // for (int i = 0; i < data.length; i++) {
   // for (int j = 0; j < data[i].length; j++)
   // data[i][j] = String.valueOf(value++);
   // }
   def = new DefaultTableModel(data, title);

   rightjTable = new JTable(def);
   // Object[][] ob= {};
   // rightjTable = new JTable(ob,title);
   // rightjTable.setBounds(new Rectangle(213, 33, 200, 235));
//   System.out.println("333333333333333333333333333333");

   // righjTable1 = new JTable();
  }
  return rightjTable;
 }

 /**
  * This method initializes rightjScrollPane 左面板滚动条
  *
  * @return javax.swing.JScrollPane
  */
 private JScrollPane getLeftjScrollPane() {
  if (leftjScrollPane == null) {
   leftjScrollPane = new JScrollPane();
   // JTree jtree = new JTree();
   leftjScrollPane.setViewportView(getLeftjTree());
   leftjScrollPane.setPreferredSize(new Dimension(130, 230));

  }
  return leftjScrollPane;
 }

 /**
  * This method initializes leftjTree 左面板树
  *
  * @return javax.swing.JTree
  */
 private String path = "";// xml文件路径

 TreeModel treeModel = null;

 private JTree getLeftjTree() {

  String[] local = { "local" };
  if (leftjTree == null) {

   // leftjTree.setBounds(new Rectangle(85, 176, 78, 72));

   // leftjTree.setPreferredSize(new Dimension(10,100));
   JCheckBox test2 = new JCheckBox();
   // for(int i = 0;i<list.size();i++){
   // System.out.println(list);
   // System.out.println("fdsfsdfsfs");
   // }
   DefaultMutableTreeNode test0 = new DefaultMutableTreeNode("test");
   DefaultMutableTreeNode test1 = new DefaultMutableTreeNode("test1");
   DefaultMutableTreeNode test22 = new DefaultMutableTreeNode("test2");
   DefaultMutableTreeNode test3 = new DefaultMutableTreeNode("test3");
   DefaultMutableTreeNode test4 = new DefaultMutableTreeNode("test4");
   test0.add(test1);
   test0.add(test22);
   test0.add(test3);
   test3.add(test4);

   // TreeModel treeModel = null;
   TreeModel treeModel = getNode();
   leftjTree = new JTree();
   leftjTree.setModel(treeModel);
   // leftjTree.addMouseListener(new MouseEventListener(leftjTree));
   // leftjTree.setModel(treeModel);
   // CheckRenderer aa = new CheckRenderer();
   // aa.add(test2);
   leftjTree.setCellRenderer(new CheckTreeRenderer2());
   leftjTree.getSelectionModel().setSelectionMode(
     TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
   leftjTree.putClientProperty("JTree.lineStyle", "Angled");
   leftjTree.addMouseListener(new NodeSelectionListener(leftjTree));
   leftjTree.setBounds(new Rectangle(112, 45, 78, 220));
  }
  return leftjTree;
 }

 CheckNode[] checkNode;

 List list;

 private TreeModel getNode() {
  list = new ArrayList();
  List list2 = new ArrayList();
  List list3 = new ArrayList();
  List list4 = new ArrayList();
  list2.add("list2");
  list2.add("移动电话 13590356894");
  list2.add("家庭电话 1234567");
  list2.add("办公电话 0755123456");
  list3.add("list31");
  // list3.add("list32");
  // list4.add("root");
  // list.add(list4);
  list.add(list2);
  list.add(list3);

  // for (int i = 0; i < list.size(); i++)
  // {
  // 从电话薄中传入list，获取所有组下的用户电话
  checkNode = addCheckNode(list);
  // }

  return new DefaultTreeModel(checkNode[0]);
 }

 public CheckNode[] rootNodes;

 private CheckNode[] nodes = null;

 private CheckNode[] addCheckNode(List apnList) {
  // System.out.println(apnList.get(2));
  List list = new ArrayList();
  List local = new ArrayList();
  List group = new ArrayList();
  List name = new ArrayList();
  // nodes = new CheckNode[apnList.size()];
  // nodes = new CheckNode[1];
  // nodes[0] = new CheckNode("root");
  // for (int i = 0; i < apnList.size(); i++) {
  // list = (List) apnList.get(i);
  //
  // CheckNode nodes1[] = new CheckNode[list.size()];
  // // 遍历本地，SIM卡，设备节点
  // for (int j = 0; j < list.size(); j++) {
  //
  // nodes1[j] = new CheckNode(list.get(j));
  //
  // System.out.println("nodes1[0]" + nodes1[0]);
  // nodes[0].add(nodes1[0]);
  //
  // if (j > 0) {
  // // 遍历本地节点下面的组节点
  // CheckNode[] groupnode = new CheckNode[local.size()];
  // for (int k = 0; k < local.size(); k++) {
  //      
  // }
  // }
  // }
  //
  // }
//  System.out.println(apnList);
  rootNodes = new CheckNode[apnList.size()];
  rootNodes[0] = new CheckNode("root");
  // 查找根节点属性

  for (int rootIndex = 0; rootIndex < apnList.size(); rootIndex++) {

   // 判断是否为List
   if (apnList.get(rootIndex) instanceof List) {

    // 获得组或者名称对象的list
    List childNode = (List) apnList.get(rootIndex);
    CheckNode[] localNodes = new CheckNode[childNode.size()];

    // 循环名称或者组
    for (int localIndex = 0; localIndex < childNode.size(); localIndex++) {

//     System.out.println("[" + childNode + "]");
     // 不管名称或者是组，第一肯定是父节点
     if (localIndex == 0) {
      localNodes[localIndex] = new CheckNode(childNode
        .get(localIndex));

      // 将该节点增加在父节点中

      rootNodes[0].add(localNodes[localIndex]);
     } else {

      // 判断是否为名称节点值

      if (childNode.get(localIndex) instanceof List) {
       List childGroupNode = (List) childNode
         .get(localIndex);
       CheckNode[] groupNodes = new CheckNode[childGroupNode
         .size()];

       // 循环组节点

       for (int groupIndex = 0; groupIndex < childGroupNode
         .size(); groupIndex++) {

        // 不管名称或者是组，第一肯定是父节点
        if (groupIndex == 0) {
         groupNodes[groupIndex] = new CheckNode(
           childGroupNode.get(groupIndex));
         localNodes[0].add(groupNodes[groupIndex]);
        } else {

         // if (childGroupNode.get(groupIndex)
         // instanceof List) {
         // List childNameNode = (List)
         // childGroupNode
         // .get(groupIndex);
         // for (int nameIndex = 0; nameIndex <
         // childNameNode
         // .size(); nameIndex++) {
         // CheckNode[] nameNodes = new
         // CheckNode[childNameNode
         // .size()];
         // if (localIndex == 0) {
         // nameNodes[localIndex] = new CheckNode(
         // childNameNode
         // .get(nameIndex));
         // groupNodes[0]
         // .add(new CheckNode(
         // nameNodes[localIndex]));
         // } else {
         // nameNodes[0]
         // .add(new CheckNode(
         // childNameNode
         // .get(nameIndex)));
         // }
         // }
         // } else {
//         System.out.println(groupNodes[0]);
         if (groupNodes[0] != null) {
          groupNodes[0]
            .add(new CheckNode(
              childGroupNode
                .get(groupIndex)));
         }
         // }
        }
       }
      } else {
       // System.out.println(localNodes[0]);
       if (localNodes[0] != null) {

        localNodes[localIndex] = new CheckNode(
          childNode.get(localIndex));
//        System.out.println("======="+ new CheckNode(childNode.get(localIndex)));
        localNodes[0].add(new CheckNode(
          localNodes[localIndex]));
       }
      }
     }
    }
   } else {
    rootNodes[0] = new CheckNode(apnList.get(rootIndex));
   }
  }

  return rootNodes;
 }
}

package tree;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.Icon;
import javax.swing.JLabel;
import javax.swing.UIManager;
import javax.swing.plaf.ColorUIResource;

public class TreeLabel extends JLabel
{
boolean isSelected;

boolean hasFocus;

TreeLabel()
{
}

public void setBackground(Color color)
{
    if (color instanceof ColorUIResource)
 color = null;
    super.setBackground(color);
}

public void paint(Graphics g)
{
    String str;
    if (null != (str = getText()))
    {
 if (0 < str.length())
 {
     if (isSelected)
     {
  g.setColor(UIManager.getColor("Tree.selectionBackground"));
     } else
     {
  g.setColor(UIManager.getColor("Tree.textBackground"));
     }
     Dimension d = getPreferredSize();
     int imageOffset = 0;
     Icon currentI = getIcon();
     if (null != currentI)
     {
  imageOffset = currentI.getIconWidth() + Math.max(0, getIconTextGap() - 1);
     }
     g.fillRect(imageOffset, 0, d.width - 1 - imageOffset, d.height);
     if (hasFocus)
     {
  g.setColor(UIManager.getColor("Tree.selectionBorderColor"));
  g.drawRect(imageOffset, 0, d.width - 1 - imageOffset, d.height - 1);
     }
 }
    }
    super.paint(g);
}

public Dimension getPreferredSize()
{
    Dimension retDimension = super.getPreferredSize();
    if (null != retDimension)
    {
 retDimension = new Dimension(retDimension.width + 3, retDimension.height);
    }
    return retDimension;
}

void setSelected(boolean isSelected)
{
    this.isSelected = isSelected;
}

void setFocus(boolean hasFocus)
{
    this.hasFocus = hasFocus;
}
//复选树节点

 
}