条件:我想做一个树形结构,就是从一个程序接口接受到一个列表ArrayList<subnet>    注:subnet 为一个封装类,内有两个值:(A,B)目的:将左右列表里的A值作为树形目录的一级节点,将所有B值作为相对应的A节点的子节点,要求:B节点可以进行复选框的选择。
大体效果如下+A1
 +口B1
+A2
 +口B2
+A3
 +口B3
+A4
 +口B4谢谢各位大侠了!

解决方案 »

  1.   

    看看这个,你也许就会了:package JTree综合案例;import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import javax.swing.tree.*;
    import javax.swing.event.*;
    import java.io.*;//定义该类继承自JFrame
    public class Test extends JFrame {    private static final long serialVersionUID = 1L;
        // 创建并初始化工具栏中的工具按扭数组
        private JButton[] jbBar = { new JButton("添加"), new JButton("删除") };
        // 创建工具栏
        private JToolBar jtb = new JToolBar();
        // 创建用来显示情况的文本框
        private JTextField jtf = new JTextField();
        // 创建根节点
        private DefaultMutableTreeNode dmtnRoot = new DefaultMutableTreeNode("目录");
        // 创建树的数据模型
        private DefaultTreeModel dtm = new DefaultTreeModel(dmtnRoot);
        // 创建树状列表控件
        private JTree jt = new JTree(dtm);
        // 为树状列表创建滚动窗口
        private JScrollPane jsp = new JScrollPane(jt);
        // 用来记录当前选中节点的成员变量
        private DefaultMutableTreeNode tempNode;
        // 创建弹出式菜单
        private JPopupMenu jpm = new JPopupMenu();
        // 创建菜单项数组
        private JMenuItem[] jmi = { new JMenuItem("定义非叶子节点展开图标"),
                new JMenuItem("定义非叶子节点折叠图标"), new JMenuItem("定义叶子节点图标") };    // 用来作为树相关事件监听器的内部类
        private class MyTreeListener implements TreeExpansionListener,
                TreeModelListener, TreeSelectionListener {
            // 定义用来记录路径的节点数组
            private Object[] tempNodes;
            // 创建StringBuffer对象
            private StringBuffer tempMsg = new StringBuffer();
            // 声明用来记录路径TreePath
            private TreePath tp;        // 处理选中某节点后发生事件的方法
            public void valueChanged(TreeSelectionEvent tse) {
                // 获得根节点到选中节点的路径
                tp = tse.getNewLeadSelectionPath();
                if (tp != null) {
                    // 从路径中获得所有路径中的节点
                    tempNodes = tp.getPath();
                    // 循环对路径中的每个节点进行处理
                    for (int i = 0; i < tempNodes.length; i++) {
                        // 将各个节点的内容连接起来并添加到StringBuffer中
                        tempMsg.append(tempNodes[i]);
                        if (i != tempNodes.length - 1) {// 在各个节点中间添加“>>”符号
                            tempMsg.append(">>");
                        }
                    }
                    // 在文本框中显示相应的信息
                    jtf.setText("您选择了:“" + tempMsg.toString() + "”节点!!!");
                    // 删除StringBuffer中的所有内容
                    tempMsg.delete(0, tempMsg.length());
                    // 记录选中的节点
                    tempNode = (DefaultMutableTreeNode) tp.getLastPathComponent();
                }
            }        // 处理节点折叠后发生事件的方法
            public void treeCollapsed(TreeExpansionEvent tee) {
                // 获得根节点到选中节点的路径
                tp = tee.getPath();
                // 设置文本框显示相应的信息
                jtf.setText("您将" + tp.getLastPathComponent() + "节点折叠了!!!");
            }        // 处理节点展开后发生事件的方法
            public void treeExpanded(TreeExpansionEvent tee) {
                // 获得根节点到选中节点的路径
                tp = tee.getPath();
                // 设置文本框显示相应的信息
                jtf.setText("您将“" + tp.getLastPathComponent() + "”节点展开了!!!");
            }        // 处理当节点名称更改之后发生事件的方法
            public void treeNodesChanged(TreeModelEvent tme) {
                // 设置文本框显示节点名称更改信息
                jtf.setText("您将节点的标题修改了!!!");
            }        // 以下三个方法由于本例中没有使用,所以均为空实现
            public void treeStructureChanged(TreeModelEvent tme) {
            }        public void treeNodesRemoved(TreeModelEvent tme) {
            }        public void treeNodesInserted(TreeModelEvent tme) {
            }
        }   
      

  2.   

    接上面:// 用来作为工具栏中按钮动作事件监听器的内部类
        class MyToolBarButtonListener implements ActionListener {
            // 实现ActionListener监听接口中的方法
            public void actionPerformed(ActionEvent e) {
                // 点击添加按扭执行的动作
                if (e.getSource() == jbBar[0]) {
                    // 检查是否有选中节点
                    if (tempNode == null) {
                        JOptionPane.showMessageDialog(Test.this,
                                "请您选择添加节点所在的目录!!!", "错误",
                                JOptionPane.WARNING_MESSAGE);
                        return;
                    }
                    // 判断节点是否为代表“节”的节点
                    if (tempNode.getLevel() == 2) {
                        JOptionPane.showMessageDialog(Test.this,
                                "对不起,“节”节点不能添加子节点!!!", "错误",
                                JOptionPane.WARNING_MESSAGE);
                        return;
                    }
                    // 弹出输入对话框,要求输入节点名称
                    String tempName = JOptionPane.showInputDialog(Test.this,
                            "请输入添加节点的名称", "请输入:", JOptionPane.INFORMATION_MESSAGE);
                    // 检查输入内容是否为null
                    if (tempName == null) {
                        return;// 若为null方法返回
                    }
                    // 去除输入内容两端的不可见字符
                    tempName = tempName.trim();
                    // 检查输入的字符串是否为空字符串
                    if (tempName.equals("")) {
                        return;// 若为空字符串则方法返回
                    }
                    // 弹出输入对话框,要求输入节点的位置
                    String tempID = JOptionPane.showInputDialog(Test.this,
                            "请输入(例如第一个节点的编号为1):", "请输入添加节点的编号",
                            JOptionPane.INFORMATION_MESSAGE);
                    // 检查输入内容是否为null
                    if (tempID == null) {
                        return;// 若为null方法返回
                    }
                    // 去除输入内容两端的不可见字符
                    tempID = tempID.trim();
                    // 检查输入的字符串是否满足指定的格式要求
                    if (!tempID.matches("[1-9][0-9]*")) {
                        JOptionPane.showMessageDialog(Test.this, "输入数字格式无效!!!",
                                "错误", JOptionPane.WARNING_MESSAGE);
                        return;
                    }
                    // 将输入的字符串转换为数值
                    int id = Integer.parseInt(tempID);
                    // 检查数值是满足范围要求
                    if (id < 1 || id > tempNode.getChildCount() + 1) {
                        JOptionPane.showMessageDialog(Test.this, "输入数字过大或太小!!!",
                                "错误", JOptionPane.WARNING_MESSAGE);
                        return;
                    }
                    // 创建新节点
                    DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(
                            tempName);
                    // 将新节点插入到指定位置
                    tempNode.insert(newNode, id - 1);
                    // 更新树的数据模型
                    ((DefaultTreeModel) jt.getModel()).reload(tempNode);
                    // 设置维持当前的选择路径
                    jt.setExpandsSelectedPaths(true);
                    // 设置文本框中的提示信息
                    jtf.setText("您在" + tempNode + "中添加了" + newNode + "节点!!!");
                } else if (e.getSource() == jbBar[1]) {// 点击删除按扭执行的动作
                    // 检查当前是否选中了某节点
                    if (tempNode == null) {
                        JOptionPane.showMessageDialog(Test.this, "请您选择要删除的节点!!!",
                                "错误", JOptionPane.WARNING_MESSAGE);
                        return;
                    }
                    // 确认是否要删除选中的节点
                    int confirm = JOptionPane.showConfirmDialog(Test.this,
                            "您确定要删除该节点么?", "确认", JOptionPane.YES_NO_OPTION,
                            JOptionPane.WARNING_MESSAGE);
                    // 确认需要删除执行的代码
                    if (confirm == JOptionPane.YES_OPTION) {
                        // 得到选中节点的父节点
                        DefaultMutableTreeNode node = (DefaultMutableTreeNode) tempNode
                                .getParent();
                        if (node == null) {
                            // 若没有父节点说明该节点是根节点,警告不能删除
                            jtf.setText("根目录不能删除!!!");
                            JOptionPane.showMessageDialog(Test.this, "根目录不能删除!!!",
                                    "错误", JOptionPane.WARNING_MESSAGE);
                        } else {// 若具有父节点执行的代码
                            // 设置提示信息
                            jtf.setText(tempNode + "被删除了!!!");
                            // 删除以选中节点为根节点的子树
                            tempNode.removeFromParent();
                            // 更新树的数据模型
                            ((DefaultTreeModel) jt.getModel()).reload(node);
                            // 将记录选中节点的成员变量置为null值
                            tempNode = null;
                        }
                    }
                }
            }
        }    // 用来作为鼠标事件监听器的内部类
        class MyJPopupListener extends MouseAdapter {
            public MyJPopupListener(JPopupMenu j) {// 构造器,初始化弹出式菜单
                for (int i = 0; i < jmi.length; i++) {
                    // 将菜单项添加到弹出式菜单中
                    jpm.add(jmi[i]);
                }
            }        public void mouseReleased(MouseEvent e) {// 当鼠标释放时执行的动作
                // 测试鼠标事件是否为平台无关的触发器
                if (e.isPopupTrigger()) {// 显示弹出式菜单
                    jpm.show(e.getComponent(), e.getX(), e.getY());
                }
            }
        }
    // 用来作为菜单项动作事件监听器的内部类
        class MyPopMenuActionListener implements ActionListener {
            // 文件选择器成员
            private JFileChooser jfc = new JFileChooser();        // 获取图片的getIcon方法
            public ImageIcon getIcon() {
                // 定义图片变量
                ImageIcon icon = null;
                // 弹出打开对话框
                jfc.showOpenDialog(Test.this);
                // 获取选择的文件
                File f = jfc.getSelectedFile();
                if (f != null) {// 若获取的文件不为null,则根据此文件中的信息获取图片
                    icon = new ImageIcon(f.getPath());
                }
                // 返回图片
                return icon;
            }        // 实现ActionListener监听接口中的事件处理方法
            public void actionPerformed(ActionEvent e) {
                // 获取图片
                ImageIcon newIcon = this.getIcon();
                // 获得树状列表当前的节点绘制器
                DefaultTreeCellRenderer dtcr = (DefaultTreeCellRenderer) jt
                        .getCellRenderer();
                if (e.getSource() == jmi[0]) {
                    // 更改展开节点的图标
                    dtcr.setOpenIcon(newIcon);
                    // 设置提示信息
                    jtf.setText("您重新定义了展开节点的图标!!!");
                } else if (e.getSource() == jmi[1]) {
                    // 更改折叠节点的图标
                    dtcr.setClosedIcon(newIcon);
                    // 设置提示信息
                    jtf.setText("您重新定义了折叠节点的图标!!!");
                } else if (e.getSource() == jmi[2]) {
                    // 更改叶子节点的图标
                    dtcr.setLeafIcon(newIcon);
                    // 设置提示信息
                    jtf.setText("您重新定义了叶子节点的图标!!!");
                }
                // 记录当前选中的路径
                TreePath tempTp = jt.getSelectionPath();
                // 更新树的数据模型
                ((DefaultTreeModel) jt.getModel()).reload();
                // 设置维持当前的选中的路径
                jt.setSelectionPath(tempTp);
            }
        }
      

  3.   

    接上面: public Test() {
            for (int i = 0; i < jbBar.length; i++) {// 将按扭添加到工具栏中
                jtb.add(jbBar[i]);
            }
            for (int i = 0; i < 5; i++) {// 向根节点中添加5个预定义的章节点
                dmtnRoot.add(new DefaultMutableTreeNode("第" + (i + 1) + "章"));
            }
            for (int i = 0; i < dmtnRoot.getChildCount(); i++) {
                DefaultMutableTreeNode temp = (DefaultMutableTreeNode) dmtnRoot
                        .getChildAt(i);
                for (int j = 0; j < 2; j++) {// 向每个章节节点中添加2个预定义的小节节点
                    temp.add(new DefaultMutableTreeNode("第" + (j + 1) + "节"));
                }
            }
            // 设置JTree为可编辑状态
            jt.setEditable(true);
            // 设置JTree将显示根节点的控制图标
            jt.setShowsRootHandles(true);
            // 设置文本框为不可编辑状态
            jtf.setEditable(false);
            // 将工具栏添加进窗体
            this.add(jtb, BorderLayout.NORTH);
            // 分别树状列表以及文本框添加进窗体的中间以及下部
            this.add(jsp, BorderLayout.CENTER);
            this.add(jtf, BorderLayout.SOUTH);
            // 设置窗体的标题、大小位置以及可见性
            this.setTitle("目录管理器");
            this.setResizable(false);
            this.setBounds(100, 100, 350, 400);
            this.setVisible(true);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            // 创建监听器对象
            MyTreeListener mtl = new MyTreeListener();
            // 为JTree注册选择事件的监听器
            jt.addTreeSelectionListener(mtl);
            // 为JTree注册选择展开以及折叠事件的监听器
            jt.addTreeExpansionListener(mtl);
            // 为JTree注册数据模型更改事件的监听器
            dtm.addTreeModelListener(mtl);
            // 创建监听器对象
            MyToolBarButtonListener mtbl = new MyToolBarButtonListener();
            // 为添加按扭注册监听器
            jbBar[0].addActionListener(mtbl);
            // 为添加按扭注册监听器
            jbBar[1].addActionListener(mtbl);
            // 创建鼠标事件的监听器
            MyJPopupListener mjpl = new MyJPopupListener(jpm);
            // 为JTree注册鼠标事件的监听器
            jt.addMouseListener(mjpl);
            // 创建菜单项动作事件监听器对象
            MyPopMenuActionListener mpmal = new MyPopMenuActionListener();
            // 为菜单项注册动作事件监听器
            for (int i = 0; i < jmi.length; i++) {
                jmi[i].addActionListener(mpmal);
            }
        }    public static void main(String[] args) {
            // 创建Test窗体对象
            new Test();
        }
    }
      

  4.   

    运行结果:import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Component;
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.util.Enumeration;import javax.swing.Icon;
    import javax.swing.JCheckBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JTree;
    import javax.swing.UIManager;
    import javax.swing.plaf.ColorUIResource;
    import javax.swing.tree.DefaultMutableTreeNode;
    import javax.swing.tree.DefaultTreeModel;
    import javax.swing.tree.TreeCellRenderer;
    import javax.swing.tree.TreePath;
    import javax.swing.tree.TreeSelectionModel;
    /**
     * 作者:李 世贵
     * JDK: 1.6 
     * 来源: http://blog.csdn.net/lishigui 
     * 欢迎转接,请保留作者和来源,谢谢!
     * 2009-5-2 上午11:30:46
     */
    public class TreeExample extends JFrame {
    private static final long serialVersionUID = 1L;
    JTree tree;
    public TreeExample() {
    super("CheckNode TreeExample");
    String[] strs = { "我的联系人", 
    "开发部", 
    "职能部", 
    "张三", 
    "李四",
    "王五",
    "陈六",
    "肖七",
    "刘八"};  CheckNode[] nodes = new CheckNode[strs.length];
    for (int i = 0; i < strs.length; i++) {
    nodes[i] = new CheckNode(strs[i]);
    }
    nodes[0].add(nodes[1]);
    nodes[0].add(nodes[2]);
    nodes[1].add(nodes[3]);
    nodes[1].add(nodes[4]);
    nodes[1].add(nodes[5]);
    nodes[2].add(nodes[6]);
    nodes[2].add(nodes[7]);
    nodes[2].add(nodes[8]);
    tree = new JTree(nodes[0]);
    tree.setCellRenderer(new CheckRenderer());
    tree.getSelectionModel().setSelectionMode(
    TreeSelectionModel.SINGLE_TREE_SELECTION);
    tree.addMouseListener(new NodeSelectionListener(tree));
    JScrollPane sp = new JScrollPane(tree);
    JPanel panel = new JPanel(new BorderLayout());
    getContentPane().add(sp, BorderLayout.CENTER);
    getContentPane().add(panel, BorderLayout.EAST);
    } 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);
    //判断是否单击了节点
    if (path != null) {
    //取得被单击的节点
    CheckNode node = (CheckNode) path.getLastPathComponent();
    boolean isSelected = !(node.isSelected());
    //设置被单击的节点CheckBox,使其状态与原来状态相反
    node.setSelected(isSelected);
    //如果节点是被选中,则展开子节点
    if (isSelected) {
    tree.expandPath(path);
    // tree.collapsePath(path);
    }
    //如果被选节点不是叶节点,将其所有子节点设置为CheckBox状态设成与其相同的状态
    if(!node.isLeaf()){
    node.getNextNode();
    Enumeration enu= node.children();
    while (enu.hasMoreElements()) {
    CheckNode n = (CheckNode) enu.nextElement();
    n.setSelected(node.isSelected());
    if(!n.isLeaf()){
    Enumeration enuc= n.children();
    while (enuc.hasMoreElements()) {
    CheckNode c = (CheckNode) enuc.nextElement();
    c.setSelected(node.isSelected());
    }
    }
    }
    }
    //刷新树(这步是必须的,否则将看不到上面所有设置的效果);
    ((DefaultTreeModel) tree.getModel()).nodeChanged(node); 
    tree.revalidate();
    tree.repaint();
    }
    }
    } public static void main(String args[]) {
    TreeExample frame = new TreeExample();
    frame.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
    System.exit(0);
    }
    });
    frame.setSize(300, 200);
    frame.setVisible(true);
    }
    }
      

  5.   

    class CheckRenderer extends JPanel implements TreeCellRenderer {
    //树的节点JPanel编辑,每个节点都是一个JPanel,JPanel中有一个JCheckBox和一个JLabel
    //TreeCellRenderer从DefaultMutableTreeNode(即CheckNode)中取得数据设置节点
    //TreeCellRenderer主要设置Tree的外观,
    protected JCheckBox check;
    protected TreeLabel label;
    public CheckRenderer() {
    setLayout(null);
    add(check = new JCheckBox());
    add(label = new TreeLabel());
    check.setBackground(UIManager.getColor("Tree.textBackground"));
    label.setForeground(UIManager.getColor("Tree.textForeground"));
    }
    public Component getTreeCellRendererComponent(JTree tree, Object value,
    boolean isSelected, boolean expanded, boolean leaf, int row,
    boolean hasFocus) {
    String stringValue = tree.convertValueToText(value, isSelected,
    expanded, leaf, row, hasFocus);
    setEnabled(tree.isEnabled());
    check.setSelected(((CheckNode) value).isSelected());
    label.setFont(tree.getFont());
    label.setText(stringValue);
    label.setSelected(isSelected);
    label.setFocus(hasFocus);
    if (leaf) {
    if(((CheckNode) value).getIcon()!=null){
    label.setIcon(((CheckNode) value).getIcon());
    }else{
    label.setIcon(UIManager.getIcon("Tree.leafIcon"));
    }

    } else if (expanded) {
    label.setIcon(UIManager.getIcon("Tree.openIcon"));
    } else {
    label.setIcon(UIManager.getIcon("Tree.closedIcon"));
    }
    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));
    }
    //布局check和label
    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);
    label.setLocation(d_check.width, y_label);
    label.setBounds(d_check.width, y_label, d_label.width, d_label.height);
    }
    //设置背景颜色
    public void setBackground(Color color) {
    if (color instanceof ColorUIResource)
    color = null;
    super.setBackground(color);
    } public class TreeLabel extends JLabel {
    boolean isSelected;
    boolean hasFocus;
    public TreeLabel() {
    }
    public void setBackground(Color color) {
    if (color instanceof ColorUIResource)
    color = null;
    super.setBackground(color);
    } public void paint(Graphics g) {
    String str;
    if ((str = getText()) != null) {
    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 (currentI != null) {
    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 (retDimension != null) {
    retDimension = new Dimension(retDimension.width + 3,
    retDimension.height);
    }
    return retDimension;
    } public void setSelected(boolean isSelected) {
    this.isSelected = isSelected;
    } public void setFocus(boolean hasFocus) {
    this.hasFocus = hasFocus;
    }
    }
    }//结点数据类
    class CheckNode extends DefaultMutableTreeNode {
    private int selectionMode = 0;
    private boolean isSelected = false;
    private Icon icon = null;
    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;
    } public int getSelectionMode() {
    return selectionMode;
    } public void setSelected(boolean isSelected) {
    this.isSelected = isSelected;
    } public boolean isSelected() {
    return isSelected;
    }

    public void setIcon(Icon icon){
    this.icon = icon;
    }

    public Icon getIcon(){
    return icon;
    }
    }
      

  6.   

    4楼的,问一下 选择子节点同时父节点也被选中 怎么弄啊(比如说A有个子节点B当我选B时候,A也被选中)