JTREE

JTree adalah komponen Swing yang menampilkan data dalam

hierarki yang mirip pohon.

Root
Leaf
TREE MODELS
Saat JTree menampilkan pohon, representasi data dari pohon ditangani
oleh TreeModel, TreeNode, dan TreePath. TreeModel mewakili seluruh
pohon, TreeNode merepresentasikan sebuah node, dan TreePath
merepresentasikan path ke node. Berbeda dengan ListModel atau
TableModel, model pohon tidak secara langsung menyimpan atau
mengelola data pohon. Data pohon disimpan dan dikelola di TreeNode dan
TreePath.
TreeNode
javax.swing.JTree

-model: TreeModel TreeModel DefaultTreeModel MutableTreeNode

-anchorPath: TreePath TreePath
DefaultMutableTreeNode
-leadPath: TreePath

-selectionModel: TreeSelectionModel TreeSelectionModel DefaultTreeSelectionModel

-cellEditor: TreeCellEditor TreeCellRenderer DefaultTreeCellRenderer

-cellRenderer: TreeCellEditor TreeCellEditor DefaultTreeCellEditor
DefaultTreeCellEditor
dapat digunakan untuk
Antarmuka Kelas DefaultTreeCellRenderer mengedit sel di bidang
TreeSelectionModel menyediakan perender simpul teks.
menangani pemilihan simpul pohon default yang dapat
pohon. menampilkan label dan / atau ikon
 javax.swing.JTree
#cellEditor: TreeCellEditor
JTREE #cellRenderer: TreeCellRenderer
#editable: boolean
CLASS
#model: TreeModel
#rootVisible: boolean
#rowHeight: int
#scrollsOnExpand: boolean
#selectionModel: TreeSelectionModel
#showsRootHandles: boolean
#toggleClickCount: int
-anchorSelectionPath: TreePath
-expandsSelectedPaths: boolean
-leadSelectionPaths: TreePath
+JTree()
+JTree(value: java.util.Hashtable)
+JTree(value: Object[])
+JTree(newModel: TreeModel)
+JTree(root: TreeNode)
+JTree(root: TreeNode, asksAllowsChildren:
boolean)
+JTree(value: Vector)
+addSelectionPath(path: TreePath): void
+addSelectionPaths(paths: TreePath[]): void
+addSelectionRow(row: int): void
+addSelectionRows(rows: int[]): void
+clearSelection() : void
+collapsePath(path: TreePath): void
+getSelectionPath(): TreePath
+getSelectionPaths(): TreePath[]
+getLastSelectedPathComponent()
+getRowCount():int
+removeSelectionPath(path: TreePath): void
+removeSelectionPaths(paths: TreePath[]):void
Specifies a cell editor used to edit entries in the tree.
Specifies whether individual cells can be selected (Obsolete since JDK 1.3).
Specifies whether the cells are editable (default: false).
Maintains the tree model.
Specifies whether the root is displayed (depending on the constructor).
Specifies the height of the row for the node displayed in the tree
(default: 16 pixels).
If true, when a node is expanded, as many of the descendants are
scrolled to be visible (default: 16 pixels).
Models the set of selected nodes in this tree.
Specifies whether the root handles are displayed (default: true).
Number of mouse clicks before a node is expanded (default: 2).
The path identified as the anchor.
True if paths in the selection should be expanded (default: true).
The path identified as the lead.
Creates a JTree with a sample tree model, as shown in Figure 24.35.
Creates a JTree with an invisible root and the keys in the Hashtable
key/value pairs as its children.
Creates a JTree with an invisible root and the elements in the array as
its children.
Creates a JTree with the specified tree model.
Creates a JTree with the specified tree node as its root.
Creates a JTree with the specified tree node as its root and decides
whether a node is a leaf node in the specified manner.
Creates a JTree with an invisible root and the elements in the vector as
its children.
Adds the specified TreePath to the current selection.
Adds the specified TreePaths to the current selection.
Adds the path at the specified row to the current selection.
Adds the path at the specified rows to the current selection.
Clears the selection.
Ensures that the node identified by the specified path is collapsed and
viewable.
Returns the path from the root to the first selected node.
Returns the paths from the root to all the selected nodes.
Returns the last node in the first selected TreePath.
Returns the number of rows currently being displayed.
Removes the node in the specified path.
Removes the node in the specified paths.
CONTOH : SIMPLE TREE
Permasalahan : Tulis program untuk membuat empat pohon:
pohon default menggunakan konstruktor no-arg, pohon yang
dibuat dari larik objek, pohon yang dibuat dari vektor, dan pohon
yang dibuat dari tabel hash. Memungkinkan pengguna untuk
secara dinamis mengatur properti untuk rootVisible, rowHeight,
dan showsRootHandles.
 TREEMODEL DAN DEFAULTTREEMODEL
TreeModel berisi
informasi struktural
tentang tree, dan javax.swing.tree.TreeModel
+getChild(parent: Object, index: int): Object Returns the child of parent at the index in the parent's child array.
data tree disimpan +getChildCount(parent: Object): int Returns the number of children of the specified parent in the tree model.

dan dikelola oleh +getIndexOfChild(parent: Object, child: Object): int

+getRoot(): Object
Returns the index of child in parent. If parent or child is null, returns –1.
Returns the root of the tree. Returns null if the tree is empty.
TreeNode. +isLeaf(node: Object): boolean Returns true if the specified node is a leaf.
+addTreeModelListener(listener: Adds a listener for the TreeModelEvent posted after the tree changes.
TreeModelListener): void
+removeTreeModelListener(listener: Removes a listener previously added with addTreeModelListener.
TreeModelListener): void
DefaultTreeModel +valueForPathChanged(path: TreePath, newValue:
Object): void
Messaged when the user has altered the value for the item identified by
path to newValue.
adalah implementasi
nyata untuk javax.swing.tree.DefaultTreeModel

TreeModel yang #asksAllowsChildren: Boolean Tells how leaf nodes are determined. True if only nodes that do not allow
children are leaf nodes, false if nodes that have no children are leaf nodes.

menggunakan #root: TreeNode The root of the tree.

TreeNodes. +DefaultTreeModel(root: TreeNode) Creates a DefaultTreeModel with the specified root.

+DefaultTreeModel(root: TreeNode, Creates a DefaultTreeModel with the specified root and decides whether a
asksAllowsChildren: boolean) node is a leaf node in the specified manner.
+asksAllowsChildren(): boolean Returns asksAllowsChildren.
+getPathToRoot(aNode: TreeNode): TreeNode[] Returns the nodes in an array from root to the specified node.
+insertNodeInto(newChild: MutableTreeNode, Inserts newChild at location index in parents children.
parent: MutableTreeNode, index: int): void
+reload(): void Reloads the model (invoke this method if the tree has been modified)
+removeNodeFromParent(node: MutableTreeNode): Removes the node from its parent.
void

TREENODE,
MUTABLETREENODE, AND
DEFAULTMUTABLETREENODE
TreeNode menyimpan
sebuah single node di dalam
tree
MutableTreeNode mendefinisikan
subinterface TreeNode dengan
metode tambahan untuk
mengubah konten dari node,
untuk memasukkan dan
menghapus simpul anak, untuk
menetapkan induk baru, dan
untuk menghapus node itu sendiri
DefaultMutableTreeNode adalah
implementasi nyata dari
MutableTreeNode
javax.swing.tree.TreeNode
+children(): java.util.Enumeration
+getAllowsChildren(): boolean
+getChildAt(childIndex: int): TreeNode
+getChildCount(): int
+getIndex(node: TreeNode): int
+getParent(): TreeNode
+isLeaf():boolean
javax.swing.tree.MutableTreeNode
+insert(child: MutableTreeNode, index: int): void
+remove(index: int): void
+remove(node: MutableTreeNode): void
+removeFromParent(): void
+setParent(newParent: MutableTreeNode): void
+setUserObject(object: Object): void
javax.swing.tree.DefaultMutableTreeNode
#allowsChildren: Boolean
#parent: MutableTreeNode
#userObject: Object
+DefaultMutableTreeNode()
+DefaultMutableTreeNode(userObject: Object)
+DefaultMutableTreeNode(userObject: Object,
allowsChildren: boolean)
+add(MutableTreeNode newChild)
+getChildAfter(aChild: TreeNode): TreeNode
+getChildBefore(aChild: TreeNode): TreeNode
+getFirstChild(): TreeNode
+getLastChild(): TreeNode
+getFirstLeaf(): DefaultMutableTreeNode
+getLastLeaf(): DefaultMutableTreeNode
+getNextLeaf(): DefaultMutableTreeNode
+getPreviousLeaf(): DefaultMutableTreeNode
+getLeafCount(): int
+getDepth(): int
+getLevel(): int
+getNextNode(): DefaultMutableTreeNode
+getPreviousNode(): DefaultMutableTreeNode
+getSiblingCount(): int
+getNextSibling(): DefaultMutableTreeNode
+getPath(): TreeNode[]
+getRoot(): TreeNode
+isRoot(): boolean
+breadthFirstEnumeration(): Enumeration
+depthFirstEnumeration(): Enumeration
+postorderEnumeration(): Enumeration
+preorderEnumeration(): Enumeration
Returns the children of this node.
Returns true if this node can have children.
Returns the child TreeNode at index childIndex.
Returns the number of children under this node.
Returns the index of the specified node in the current node’s children.
Returns the parent of this node.
Returns true if this node is a leaf.
Adds the specified child under this node at the specified index.
Removes the child at the specified index from this node’s child list.
Removes the specified node from this node’s child list.
Removes this node from its parent.
Sets the parent of this node to the specified newParent.
Resets the user object of this node to the specified object.
True if the node is able to have children.
Stores the parent of this node.
Stores the content of this node.
Creates a tree node without user object, and allows children.
Creates a tree node with the specified user object, and allows children.
Creates a tree node with the specified user object and the specified mode to
indicate whether children are allowed.
Adds the specified node to the end of this node's child vector.
Returns the next (previous) sibling of the specified child in this node's child
vector.
These two methods return this node's first (last) child in the child’s vector of
this node.
These four methods return the first (last, next, and previous) leaf that is a
descendant of this node. The first (last, next, and previous) leaf is
recursively defined as the first (last, next, and previous) child’s first (last,
next, and previous) leaf.
Returns the total number of leaves that are descendants of this node.
Returns the depth of the tree rooted at this node.
Returns the distance from the root to this node.
Returns the node that follows (precedes) this node in a preorder traversal of
this node.
Returns the number of siblings of this node.
Returns the next sibling of this node in the parent's child vector.
Returns the path from the root to this node.
Returns the root of the tree that contains this node.
Returns true if this node is the root of the tree.
Creates and returns an enumeration that traverses the subtree rooted at this
node in breadth-first order (depth-first order, postorder, preorder). These
traversals were discussed in Chapter 17, “Data Structure
Implementations.”
CONTOH : TREE MODEL DEMO
Masalah: Menulis program untuk membuat dua tree yang
menampilkan “World”, benua, negara dan negara bagian.
Kedua tree menampilkan konten yang identik. Program ini
juga menampilkan properti dari pohon di area teks.
 TREESELECTIONMODEL DAN
DEFAULTTREESELECTIONMODEL
Pemilihan node Tree
didefinisikan dalam
antarmuka javax.swing.tree.TreeSelectionModel
TreeSelectionModel. +addSelectionPath(path: TreePath): void Adds the specified TreePath to the current selection.
+addSelectionPaths(paths: TreePath[]): void Adds the specified TreePaths to the current selection.
+clearSelection() : void Clears the selection.
+getLeadSelectionPath(): TreePath Returns the last path in the selection.
+getSelectionCount(): int Returns the number of paths in the selection.
+getSelectionPath(): TreePath Returns the first path in the selection.
Class +getSelectionPaths(): TreePath[] Returns all the paths in the selection.
DefaultTreeSelection +getSelectionMode(): int Returns the current selection mode,

Model adalah +removeSelectionPath(path: TreePath): void Removes path from the selection.
+removeSelectionPaths(paths: TreePath[]):void Removes paths from the selection.
implementasi nyata +setSelectionMode(mode: int): void Sets the selection mode.
dari +setSelectionPath(path: TreePath): void Sets the selection to path.
TreeSelectionModel, +setSelectionPaths(paths: TreePath[]): void Sets the selection to paths.
+addTreeSelectionListener(x: TreeSelectionListener): void Register a TreeSelectionListener.
yang +removeTreeSelectionListener(x: TreeSelectionListener): void Remove a TreeSelectionListener.
mempertahankan
array objek TreePath javax.swing.tree.DefaultTreeSelectionModel
yang mewakili pilihan
 CONTOH : MODIFIYING TREES
Masalah: Menulis program untuk membuat dua pohon yang menampilkan
konten yang sama: dunia, benua, negara dan negara bagian, seperti yang
ditunjukkan pada Gambar dibawah. Untuk tree di sebelah kiri, aktifkan
pengguna untuk memilih mode pilihan, tambahkan anak baru di bawah simpul
yang dipilih pertama, dan hapus semua simpul yang dipilih.
TREE NODE RENDERING
DefaultTreeCellRenderer renderer =
(DefaultTreeCellRenderer)jTree1.getCellRenderer();
renderer.setLeafIcon(yourCustomLeafImageIcon);
renderer.setOpenIcon(yourCustomOpenImageIcon);

renderer.setClosedIcon(yourCustomClosedImageIcon);
renderer.setBackgroundSelectionColor(Color.red);
TREE EDITING
// Customize editor
JComboBox jcboColor = new JComboBox();
jcboColor.addItem("red");
jcboColor.addItem("green");
jcboColor.addItem("blue");
jcboColor.addItem("yellow");
jcboColor.addItem("orange");

jTree1.setCellEditor(new DefaultCellEditor(jcboColor));
jTree1.setEditable(true);
TREE RENDERING AND EDITING
jTree1.setCellEditor
(new DefaultTreeCellEditor(jTree1,
new DefaultTreeCellRenderer(),
new DefaultCellEditor(jcboColor)));
JTree dapat mengaktifkan TreeSelectionEvent dan
TreeExpansionEvent, di antara banyak acara lainnya. Setiap kali
simpul baru dipilih, JTree mengaktifkan TreeSelectionEvent.
Setiap kali node diperluas atau diciutkan, JTree mengaktifkan
TreeExpansionEvent. Untuk menangani peristiwa pemilihan
pohon, pendengar harus mengimplementasikan antarmuka
TreeSelectionListener, yang berisi metode valueChanged handler
tunggal. TreeExpansionListener berisi dua penangan bernama
treeCollapsed dan treeExpanded untuk menangani node
expansion atau node closing.
ARRAY + JTABLE
&
DATABASE
JTABLE
 Tabel digunakan untuk menampilkan data dalam mode
spreadsheet
 Jadi konsep-konsep kunci dalam model tabel:
 cell, baris, kolom
 Nilai (s) di masing-masing
 Setiap tabel mendapatkan datanya dari sebuah objek
yang mengimplementasikan TableModel Interface
 Dapat digunakan class DefaultTableModel, atau
 Membuat class baru dimana mengimplementasikan
AbstractTableModel Interface dan mengimplemntasikan
metode berikut
 getColumnName
import
 getRowCount java.swingx.table.*;
 getColumnCount
 getValueAt
JAVA
MENGGUNAKAN DEFAULTTABLEMODEL

Object[][] data = { {"Mary", "Campione","Snowboarding", new Integer(5) ...}

{"Alison", "Huml","Rowing", new Integer(3), new Boolean(true)} ...};

String[] columnNames = {"First Name","Last Name","Sport","# of Years","Vegetarian"};

DefaultTableModel defaultTableModel = new DefaultTableModel(data, columnNames);

...

table = new JTable(defaultTableModel);

JAVA
MENGGUNAKAN ABSTRACTTABLEMODEL
 Langkah-langkah dalam membuat dan menggunakan AbstractTableModel
 Membuat sebuah AbstractTableModel

 Mengimplementasikan method getRowCount(), ,getColumnCount() , and

getValueAt()

JTable table = new JTable(new AbstractTableModel() {

public int getColumnCount() { return 10; }
public int getRowCount() { return 5;}
extends
AbstractTableModel
public Object getValueAt(int row, int col) {
return new Integer((row+1)*(col+1));
}
});

getContentPane().add(table, BorderLayout.CENTER);
LATIHAN