Question

如何实现动态Jtree，它显示了已创建的clases实例？

例如，我可以在我的应用中创建新书（名称）。在每本书中都可以有章节= ArrayList的章节。现在我怎么能从它做一个jtree？

Answer 1

JTree 使用中涉及的类如下：

JTree类本身提供了您需要的可显示项目，它的工作原理与表格和列表完全相同：它们有一个模型！
DefaultTableModel implements TableModel作为JTree的数据容器。它通过根节点进行了验证，然后将每个子节点添加到根节点或树中包含的其他节点。
DefaultMutableTreeNode，它是通用JTree节点的通用默认实现。

如何混淆这些东西？首先，我建议你查一下关于它的java sun guide here，但是为了快速浏览你可以考虑做这样的事情：

// this is the root of your tree
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Books");

for (Book b : books)
{
  // this adds every book to the root node
  DefaultMutableTreeNode curBook = new DefaultMutableTreeNode(b);

  root.add(curBook);

  // this adds every chapter to its own book
  for (Chapter c : b.chapters())
    curBook.add(new DefaultMutableTreeNode(c));
}

// at this point you have your tree ready, you just have to setup the model and create the effective JTree

DefaultTreeModel treeModel = new DefaultTreeModel(root);
JTree tree = new JTree(treeModel);

//now you tree is ready to be used

如果数据结构（和模型）不同，方法与用于JTable或JList的方法完全相同。考虑一下这是默认的方法，但您可以根据自己的需要轻松编写自己的TreeNode或TreeModel类。

我想告诉你，关于java的sun指南几乎包含了基本JDK中包含的每个主题，所以在感到迷失之前先看看它是一件好事。

Answer 2

您也可以实现自己的模型，这是我为群组和用户群制作的模型：

public class GrupoUserTreeModel implements TreeModel
{
    private String raiz;
    private ArrayList<Grupo> grupos = new ArrayList<Grupo>();
    private List<TreeModelListener> listeners = new ArrayList<TreeModelListener>();

    public GrupoUserTreeModel(String raiz)
    {
        this.raiz = raiz;
    }

    public Object getRoot()
    {
        return raiz;
    }

    private void fireTreeStructureChanged()
    {
        Object[] o = {raiz};
        TreeModelEvent e = new TreeModelEvent(this, o);
        for(TreeModelListener l : listeners)
            l.treeStructureChanged(e);
    }

    public void addGrupo(Grupo grupo)
    {
        grupos.add(grupo);
        fireTreeStructureChanged();
    }

    public void addUsuario(Grupo grupo, Usuario usuario)
    {
        Grupo g = grupos.get(grupos.indexOf(grupo));
        g.getUsuarios().add(usuario);
        TreePath p = new TreePath(new Object[]{g});
        this.fireTreeStructureChanged();
    }

    public void limpar()
    {
        grupos.clear();
        this.fireTreeStructureChanged();
    }

    public void removeGrupo(Grupo grupo)
    {
        if(!grupos.remove(grupo))
            throw new NullPointerException("Grupo: "+grupo+" inexistente na Tree");
        this.fireTreeStructureChanged();
    }

    public ArrayList<Grupo> getGrupos()
    {
        return this.grupos;
    }

    public void setGrupos(ArrayList<Grupo> grupos)
    {
        this.grupos = grupos;
        this.fireTreeStructureChanged();
    }

    public ArrayList<Usuario> getUsuarios(Grupo grupo)
    {
        Grupo g = grupos.get(grupos.indexOf(grupo));
        return g.getUsuarios();
    }

    public void removeUsuario(Grupo grupo, Usuario usuario)
    {
        Grupo g = grupos.get(grupos.indexOf(grupo));
        if(!(g.getUsuarios()).remove(usuario))
            throw new NullPointerException("Usuário: "+usuario+" inexistente no Grupo: "+
                    grupo+" na Tree");
        TreePath p = new TreePath(new Object[]{g});
        this.fireTreeStructureChanged();
    }

    public Object getChild(Object parent, int index)
    {
        if(parent == raiz)
        {
            return grupos.get(index);
        }
        if(parent instanceof Grupo)
        {
            Grupo g = grupos.get(grupos.indexOf(parent));
            return g.getUsuarios().get(index);
        }
        throw new IllegalArgumentException("Parent não é de um tipo suportado pela Tree");
    }

    public int getChildCount(Object parent)
    {
        if(parent == raiz)
            return grupos.size();
        if(parent instanceof Grupo)
        {
            Grupo g = grupos.get(grupos.indexOf(parent));
            return g.getUsuarios().size();
        }
        throw new IllegalArgumentException("Parent não é de um tipo suportado pela Tree");
    }

    public boolean isLeaf(Object node)
    {
        return node instanceof Usuario;
    }

    public void valueForPathChanged(TreePath path, Object newValue)
    {

    }

    public int getIndexOfChild(Object parent, Object child)
    {
        if(parent == raiz)
            return grupos.indexOf(child);
        if(parent instanceof Grupo)
            return grupos.get(grupos.indexOf(child)).getUsuarios().size();
        return 0;
    }

    public void addTreeModelListener(TreeModelListener l)
    {
        listeners.add(l);
    }

    public void removeTreeModelListener(TreeModelListener l)
    {
        listeners.remove(l);
    }

}

public class Grupo
{
    private ArrayList<Usuario> usuarios = new ArrayList<Usuario>();
    private String nome;

    public Grupo(String nome)
    {
        this.nome = nome;
    }

    /**
     * @return the usuarios
     */
    public ArrayList<Usuario> getUsuarios() {
        return usuarios;
    }

    /**
     * @param usuarios the usuarios to set
     */
    public void setUsuarios(ArrayList<Usuario> usuarios) {
        this.usuarios = usuarios;
    }

    /**
     * @return the nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * @param nome the nome to set
     */
    public void setNome(String nome) {
        this.nome = nome;
    }

    public String toString()
    {
        return this.nome;
    }

    public boolean equals(Object outro)
    {
        if(outro instanceof Grupo)
        {
            Grupo o = (Grupo) outro;
            return o.getNome().equals(this.getNome());
        }
        return false;
    }
}

public class Usuario
{
    private String nome;

    public Usuario(String nome)
    {
        this.nome = nome;
    }

    /**
     * @return the nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * @param nome the nome to set
     */
    public void setNome(String nome) {
        this.nome = nome;
    }

    public String toString()
    {
        return this.nome;
    }

    public boolean equals(Object outro)
    {
        if(outro instanceof Usuario)
        {
            Usuario o = (Usuario) outro;
            return o.getNome().equals(this.getNome());
        }
        return false;
    }

}

JTree的对象？

2 个答案: