swing - 对象的JTree？

Question

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

例如，我可以在我的应用程序中创建新的 Book(name)。在每本书中都可以是champions = ArrayList of Chapter。现在我怎么能从中做一个jtree？

Answer 1

JTree使用中涉及的类如下：

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

这些东西怎么混？首先，我建议您在此处查看有关它的 java sun guide，但要快速浏览一下，您可以考虑使用以下内容：

// 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

我想让您知道，sun 的 java 指南几乎包含基本 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;
    }

}