JTree的對象？

Question

我如何實現動態Jtree，它顯示創建的clases實例？

例如，我可以在我的應用程序中創建新書（名稱）。在每本書中可以分章節= ArrayList。現在我怎麼能從它做一個jtree？參與的JTree使用

Answer 1

類有以下幾種：

• 的JTree類本身它提供你所需要的顯示項目，它的工作原理完全一樣擺動表格和列表：他們有一個模型！
• DefaultTableModel implements TableModel它用作JTree的數據容器。它與根節點隔離開來，然後每個孩子都被添加到根節點或樹中包含的其他節點。
• DefaultMutableTreeNode這是通用JTree節點的通用默認實現。

如何混合這些東西？首先，我建議你檢查Java的太陽引導它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; 
    } 

}