To run this program, you will need to modify the references to the history file and two image files to match your configuration.  If you wish to run this program two or more times without loading the history file, find and delete the file named junk.dat from your disk.

public class Tree06 extends JFrame{
  Hashtable theHashtable = new Hashtable();
  JLabel display = new JLabel("Display Selection Here");
  String historyFile = "/jnk/junk.dat";
  String unSelectedImage = "blue-ball.gif";
  String selectedImage = "red-ball.gif";
  int frameWidth = 350;
  int frameHeight = 350;

  int numberRows = 19;
  JTree tree;
  MyData myData;
  TheData[] data;
  TreePanel treePanel;
  String plafClassName 
    = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";

  public static void main(String args[]) {
    new Tree06();
  }//end main

  public Tree06 () {//constructor
    setTitle("Copyright 1998, R.G.Baldwin");  

    myData = new MyData();//ref to object containing array
    data = myData.getData();//ref to the array

    // Create an array of references to tree nodes.  
    DefaultMutableTreeNode[] theTreeNodes = 
                    new DefaultMutableTreeNode[numberRows];
    for(int cnt = 0; cnt < numberRows; cnt++){
      theTreeNodes[cnt] = new DefaultMutableTreeNode("");
    }//end for loop

    //Construct the tree using the nodes created above.
    // These statements establish ParentChild relationships
    // among the nodes.
    theTreeNodes[0].add(theTreeNodes[1]);
    theTreeNodes[1].add(theTreeNodes[2]);
    theTreeNodes[1].add(theTreeNodes[3]);
    theTreeNodes[1].add(theTreeNodes[4]);
    theTreeNodes[0].add(theTreeNodes[5]);
    theTreeNodes[5].add(theTreeNodes[6]);
    theTreeNodes[6].add(theTreeNodes[7]);
    theTreeNodes[6].add(theTreeNodes[8]);
    theTreeNodes[6].add(theTreeNodes[9]);
    theTreeNodes[5].add(theTreeNodes[10]);
    theTreeNodes[10].add(theTreeNodes[11]);
    theTreeNodes[10].add(theTreeNodes[12]);
    theTreeNodes[10].add(theTreeNodes[13]);
    theTreeNodes[0].add(theTreeNodes[14]);
    theTreeNodes[14].add(theTreeNodes[15]);
    theTreeNodes[14].add(theTreeNodes[16]);
    theTreeNodes[14].add(theTreeNodes[17]);
    theTreeNodes[14].add(theTreeNodes[18]);

    for(int cnt = 0; cnt < numberRows; cnt++){
      theHashtable.put(theTreeNodes[cnt],new Integer(cnt));
    }//end for loop

    CellRenderer cell = new CellRenderer();
    treePanel = new TreePanel(theTreeNodes[0], cell);

    tree.addTreeSelectionListener(new MyTreeListener());

  private class CellRenderer implements TreeCellRenderer {
    public Component getTreeCellRendererComponent(
                JTree tree, Object value, boolean selected, 
                   boolean expanded, boolean leaf, int row, 
                                        boolean hasFocus) {

      TreePath thePath = tree.getPathForRow(row);

      if(thePath != null){
        DefaultMutableTreeNode theNode = 
                           (DefaultMutableTreeNode)thePath.
                                    getLastPathComponent();

        int theProperDataID = 
           ((Integer)theHashtable.get(theNode)).intValue();

        return data[theProperDataID].theJLabel;
      }//end if

      else return new JLabel("Dummy");

    }//end getTreeCellRendererComponent()
  }//end inner class CellRenderer

  class MyTreeListener implements TreeSelectionListener{
    public void valueChanged(TreeSelectionEvent e) {
      DefaultMutableTreeNode theNode =
                    (DefaultMutableTreeNode)
                      (e.getPath().getLastPathComponent());

      int theProperDataID = 
           ((Integer)theHashtable.get(theNode)).intValue();

      if (theNode.isLeaf()) {
          data[theProperDataID].theJLabel.setIcon(
                             new ImageIcon(selectedImage));

        invalidate();

        display.setText(data[theProperDataID].
                                      theSupplementalInfo);
      }//end if
    }//end valueChanged() method
  }//end inner class MyTreeListener

  class TreePanel extends JPanel {
    public TreePanel(TreeNode root, 
                                TreeCellRenderer renderer){

      tree = new JTree(root);
      tree.setCellRenderer(renderer);

      //Put the tree in a scrollable pane
      //Set the look and feel to emulate Windows
      //Set to BorderLayout
      //Expand the tree
      //Code omitted for brevity
    }//end constructor
  }//end inner class TreePanel

  class MyData implements Serializable{
    //Instantiate an array of objects of type TheData
    TheData[] theData = new TheData[numberRows];
    
    TheData[] getData(){
      System.out.println("Attempt to find and read " 
                                            + historyFile);
      if(new File(historyFile).exists()){
        System.out.println("File exists, read it");
        try{//try to read the file as a serialized object
          ObjectInputStream in = new ObjectInputStream(
                         new FileInputStream(historyFile));
          myData = (MyData)in.readObject();
          System.out.println("Read completed");
          return myData.theData;
        }catch(Exception e){
          e.printStackTrace();
          System.out.println("Aborting program");
          System.exit(0);
        }//end catch

      }else
      System.out.println(historyFile 
                            + " doesn't exist, create it");
      theData[0] = new TheData(
        "----------------SAMPLE TREE-----------------","");
      theData[1] = new TheData("Vegetables           ","");
      theData[2] = new TheData("Cabbage",
                                       "Selected Cabbage");
      theData[2].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));

//omit most of the code here

      theData[18] = new TheData(
                               "Orange","Selected Orange");
      theData[18].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));

      return theData;
      
    }//end method getData()
  }//end class MyData

/*File Tree06.java
Revised 9/27/98

This program has a problem some of the labels being
chopped off.  Some newsgroup articles indicate that this
may be a bug in the JDK or the Swing library.

This program provides a simple-minded approach to creating
and maintaining a tree structure using the Swing JTree.

The program doesn't make any explicit use of the Swing
model concept.

The program creates a tree that has a Windows look and 
feel.  The tree can be collapsed and expanded by clicking
on the + and - boxes in the typical Windows Explorer style.

Each leaf on the tree has both an icon and a label.  When
a leaf is selected, the icon changes to indicate that it
has been selected.  When the program terminates, a history
file is created and saved containing the state of each
leaf.  When the program is restarted, the history file
is read and used to restore the state of each leaf to its
previous value.

Object serialization is used to save and restore the
history data file.

When a leaf is selected, an event is generated and handled
to cause the identification of the leaf that was selected
to appear on the bottom of the JFrame containing the 
tree.

Tested using JDK 1.1.6 and Swing 1.0.3 under Win95.
**********************************************************/

import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.tree.*;
import com.sun.java.swing.event.*;

//=======================================================//
public class Tree06 extends JFrame{
  //The following hashtable is used to maintain a link
  // between the nodes/leaves in the tree and the JLabel
  // object that is used to render them.  
  Hashtable theHashtable = new Hashtable();
  
  //The following object is used to display the selection
  // at the bottom of the JFrame object
  JLabel display = new JLabel("Display Selection Here");

  //Paths and filenames.  Modify as you see fit.
  String historyFile = "/jnk/junk.dat";
  //Following image displayed when leaf is not selected
  String unSelectedImage = "blue-ball.gif";
  //Following image displayed when leaf is selected
  String selectedImage = "red-ball.gif";
  
  //Absolute coordinate info in pixels.
  int frameWidth = 350;
  int frameHeight = 350;
  
  //The number of rows in the tree when it is fully
  // expanded
  int numberRows = 19;

  //Reference to the JTree object
  JTree tree;
  
  //The following object of type MyData contains an array
  // of objects of type TheData.  Each of these objects 
  // represents a node in the tree.  Each object contains
  // two instance variables:  a JLabel object that contains
  // the text and icon for a node, and a String that
  // contains the supplementary information to be accessed
  // when that node is selected.  This object is written
  // to disk when the user terminates the program, and is
  // read from the disk when the user starts the program.
  // If a file containing the object doesn't exist when the
  // program is started, a new object is created with
  // initialized data.
  MyData myData;

  
  //The following is a reference to the array contained
  // in the object described above.
  TheData[] data;

  
  //The following is a reference to a panel which contains
  // the tree.
  TreePanel treePanel;
  
  //The following is a reference to a class which is used
  // to cause the look & feel of the program to emulate
  // Windows.  This is necessary to get the + and - boxes
  // that are used to expand and collapse the nodes in
  // the tree. Otherwise, the tree would default to the
  // metal look and feel with buttons instead of + and -
  // boxes.
  String plafClassName 
    = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  
  //-----------------------------------------------------//

  //The following main method that can be used to test 
  // this class on a stand-alone basis.
  public static void main(String args[]) {
    //Instantiate the top-level JFrame object.
    new Tree06();
  }//end main
  //-----------------------------------------------------//

  public Tree06 () {//constructor
    setTitle("Copyright 1998, R.G.Baldwin");  

    //Create new data object, or get historical data object
    // from disk. Put references to the object and the
    // data array contained in that object in variables
    // for later access.
    myData = new MyData();//ref to object containing array
    data = myData.getData();//ref to the array

    // Create an array of references to tree nodes.  
    DefaultMutableTreeNode[] theTreeNodes = 
                    new DefaultMutableTreeNode[numberRows];
    for(int cnt = 0; cnt < numberRows; cnt++){
      theTreeNodes[cnt] = new DefaultMutableTreeNode("");
    }//end for loop

    //Construct the tree using the nodes created above.
    // These statements establish ParentChild relationships
    // among the nodes.
    theTreeNodes[0].add(theTreeNodes[1]);
    theTreeNodes[1].add(theTreeNodes[2]);
    theTreeNodes[1].add(theTreeNodes[3]);
    theTreeNodes[1].add(theTreeNodes[4]);
    theTreeNodes[0].add(theTreeNodes[5]);
    theTreeNodes[5].add(theTreeNodes[6]);
    theTreeNodes[6].add(theTreeNodes[7]);
    theTreeNodes[6].add(theTreeNodes[8]);
    theTreeNodes[6].add(theTreeNodes[9]);
    theTreeNodes[5].add(theTreeNodes[10]);
    theTreeNodes[10].add(theTreeNodes[11]);
    theTreeNodes[10].add(theTreeNodes[12]);
    theTreeNodes[10].add(theTreeNodes[13]);
    theTreeNodes[0].add(theTreeNodes[14]);
    theTreeNodes[14].add(theTreeNodes[15]);
    theTreeNodes[14].add(theTreeNodes[16]);
    theTreeNodes[14].add(theTreeNodes[17]);
    theTreeNodes[14].add(theTreeNodes[18]);

    
    //Load the hash table with keys corresponding to
    // each of the nodes in the above array and values
    // which are Integer objects containing the int values
    // from 0 through numberRows-1.  Later, when it is
    // time to render a node or a leaf, the hashcode of
    // the node to be rendered will be obtained, that
    // hashcode will be used to determine the corresponding
    // int value, and the int value will be used to index
    // into an array containing the JLabel object to be
    // used to render the node.  This is one way to deal
    // with the problem of the row numbers changing when
    // the tree is collapsed.
    for(int cnt = 0; cnt < numberRows; cnt++){
      theHashtable.put(theTreeNodes[cnt],new Integer(cnt));
    }//end for loop

    //Get a cell renderer object that is used to render the
    // image and label for each node.  This CellRenderer 
    // object is designed to cause each node to consist of 
    // a JLabel which can contain both a String and an 
    // image icon.
    CellRenderer cell = new CellRenderer();
    
    //Pass the CellRenderer object along with the root node
    // to the constructor for a TreePanel object.  This 
    // will construct a JTree object in a scrollpane in
    // a JPanel container.
    treePanel = new TreePanel(theTreeNodes[0], cell);
    
    //Instantiate a TreeSelectionListener object and 
    // register it to listen for events caused by the user
    // selecting a node in the tree with the mouse or the 
    // arrow keys.  An event is processed each time the 
    // user selects a different node.  Note that nodes that
    // were previously selected can be selected again if 
    // another node is selected in between.  However, once
    // the icon on a node is modified to indicate that the
    // node has been selected, it does not change back if
    // the node is selected again. (It wouldn't be 
    // difficult, however to cause it to toggle.)
    tree.addTreeSelectionListener(new MyTreeListener());
    
    //Display the TreePanel object in the top-level frame.
    Container content = getContentPane();
    content.add(treePanel,BorderLayout.CENTER);

    //Place a JLabel at the bottom of the JFrame to display
    // the identity of the node that is selected.
    content.add(display,BorderLayout.SOUTH);
    
    //Set the size of the frame and make it visible.
    setSize(frameWidth, frameHeight);
    setVisible(true);

    //An anonymous inner class to terminate the program
    // and save the history file when the
    // user clicks the close button on the frame. 
    // The data is saved using object serialization.
    this.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        //Write historical data to disk
        System.out.println("Writing " + historyFile);
        try{
          ObjectOutputStream out =
            new ObjectOutputStream(
              new FileOutputStream(historyFile));
          out.writeObject(myData);
          out.close();
        }catch(Exception ex){
          ex.printStackTrace();
        }//end catch block

        System.exit(0);}//terminate the program
    });
    
  }//end constructor
  //=====================================================//

  //This is an inner class that instantiates a CellRenderer
  // object.  In this case, it returns a reference to a
  // JLabel object from an array containing references to
  // JLabel objects.  The ID of the node to be
  // rendered is obtained.  This ID is used to access
  // a hashtable that associates node hashcodes with int
  // values.  The int value is obtained and used to index
  // into an array containing the objects that are used to
  // render the nodes.  This approach eliminates problems
  // that occur when relying on the row value (which 
  // changes when the tree is collapsed) to index 
  // the array.
   
  private class CellRenderer implements TreeCellRenderer {
    //The following method is declared in the interface and
    // must be defined here.  
    public Component getTreeCellRendererComponent(
                JTree tree, Object value, boolean selected, 
                   boolean expanded, boolean leaf, int row, 
                                        boolean hasFocus) {

      //Use the row value to get the path to the node
      // to be rendered.
      TreePath thePath = tree.getPathForRow(row);

      //Use the path to get the node, and use the ID
      // of the node as a hashtable key to get the int 
      // value required to index the array discussed above.
      // Note that the int values are stored in the 
      // hashtable as Integer objects and therefore must
      // be extracted from those objects using intValue().
      if(thePath != null){//sometimes it is null
        DefaultMutableTreeNode theNode = 
                           (DefaultMutableTreeNode)thePath.
                                    getLastPathComponent();
        int theProperDataID = 
           ((Integer)theHashtable.get(theNode)).intValue();
        //Access the data array, get and return the JLabel
        // contained in the object referenced in that 
        // array.
        return data[theProperDataID].theJLabel;
      }//end if
      //Sometimes this method is called with a null path
      // but I don't know why.  In that case, return a 
      // dummy JLabel.
      else return new JLabel("Dummy");

    }//end getTreeCellRendererComponent()
  }//end inner class CellRenderer
  //=====================================================//

  //This inner class is used to instantiate a 
  // TreeSelectionListener object and register it on the
  // JTree object.  The method in this object is invoked
  // whenever the user selects a new node in the tree.
  // A previously-selected node can be selected again if
  // another node is selected in between.  The first time
  // a node is selected, an image of a red ball replaces
  // an image of a blue ball that was placed on the node
  // when it was originally instantiated.  Selecting the
  // node again does not change it back to a blue ball,
  // but it wouldn't be too difficult to cause it to
  // toggle between the two.

  class MyTreeListener implements TreeSelectionListener{
    public void valueChanged(TreeSelectionEvent e) {
      //Get the node that was selected.
      DefaultMutableTreeNode theNode =
                    (DefaultMutableTreeNode)
                      (e.getPath().getLastPathComponent());
    
      //Use the node as the key and go to the hashtable to 
      // get the index of the element in the data array 
      // that corresponds to the node.
      int theProperDataID = 
           ((Integer)theHashtable.get(theNode)).intValue();

      //If the node is a leaf, change the image for that 
      // node from a blue ball to a red ball in the data
      // array.
      if (theNode.isLeaf()) {
          data[theProperDataID].theJLabel.setIcon(
                             new ImageIcon(selectedImage));
        
        //Force a redraw to cause the red ball to be
        // displayed.
        invalidate();

        
        //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%//
        //This is the place to insert any code that should
        // be executed when the user selects a node.  In
        // this sample program, the action is to simply to
        // display information about the node in a JLabel
        // at the bottom of the frame.
        display.setText(data[theProperDataID].
                                      theSupplementalInfo);
        //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%//
      }//end if
    }//end valueChanged() method
  }//end inner class MyTreeListener
  //=====================================================//
  
  //This inner class is used to instantiate the actual
  // JTree object and place it in a scrollable pane in a
  // JPanel container.  The JPanel can then be placed in 
  // any other container.

  class TreePanel extends JPanel {
    public TreePanel(TreeNode root, 
                                TreeCellRenderer renderer){
      setLayout(new BorderLayout());

      //Create tree
      tree = new JTree(root);
      
      //Specify the cell renderer to be used whenever the
      // system needs to redraw the tree.
      tree.setCellRenderer(renderer);

      // Put the tree in a scrollable pane and add the
      // scrollable pane to the JPanel container.
      JScrollPane sp = new JScrollPane();
      sp.getViewport().add(tree);
      add(sp, BorderLayout.CENTER);
      
      //Set the look and feel to emulate Windows
      try{
        UIManager.setLookAndFeel(plafClassName);
      }catch(Exception ex){System.out.println(ex);}
      SwingUtilities.updateComponentTreeUI(this);

      //Expand the tree
      for(int cnt = 0; cnt < numberRows; cnt++){
        tree.expandRow(cnt);
      }//end for loop
    }//end constructor
  }//end inner class TreePanel
  //=====================================================//

  //Inner class to construct a data object containing the
  // text for each node, the icon for each node, and the
  // supplementary information associated with each node.
  // The getData method of this class searches for a
  // specific disk file containing historical 
  // tree-navigation data, and returns an object from
  // that file if it exists.  Object serialization 
  // is used to retrieve the object from the disk file.
  // Otherwise, it constructs a new object and returns the
  // array that it contains.  
  class MyData implements Serializable{
    //Instantiate an array of objects of type TheData
    TheData[] theData = new TheData[numberRows];
    
    TheData[] getData(){
      //Test for the disk file containing the historical
      // data here.  If it exists, read and return it.
      // Otherwise, create a new initial set of data.
      
      System.out.println("Attempt to find and read " 
                                            + historyFile);
      if(new File(historyFile).exists()){
        System.out.println("File exists, read it");
        try{//try to read the file as a serialized object
          ObjectInputStream in = new ObjectInputStream(
                         new FileInputStream(historyFile));
          myData = (MyData)in.readObject();
          System.out.println("Read completed");
          return myData.theData;
        }catch(Exception e){
          e.printStackTrace();
          System.out.println("Aborting program");
          System.exit(0);
        }//end catch
      }else
      //Historical data file doesn't exist, create it.
      // Initialize text data and initialize the icon
      // to the unselected image for each leaf node.
      // As of JDK 1.1.6 and Swing 1.0.3, some of the
      // labels on the JLable object are truncated and
      // replaced by ...  Sometimes, but not always, it is
      // possible to minimize this by inserting spaces to
      // cause the label to be longer than required.
      System.out.println(historyFile 
                            + " doesn't exist, create it");
      theData[0] = new TheData(
        "----------------SAMPLE TREE-----------------","");
      theData[1] = new TheData("Vegetables           ","");
      theData[2] = new TheData("Cabbage",
                                       "Selected Cabbage");
      theData[2].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[3] = new TheData("Squash","Selected Squash");
      theData[3].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[4] = new TheData("Onion","Selected Onion");
      theData[4].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[5] = new TheData(
        "Animals                                     ","");
      theData[6] = new TheData(
        "Forrest                                     ","");
      theData[7] = new TheData("Squirrel",
                                      "Selected Squirrel");
      theData[7].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[8] = new TheData("Rabbit","Selected Rabbit");
      theData[8].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[9] = new TheData("Fox","Selected Fox");
      theData[9].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[10] = new TheData(
        "Farm                                        ","");
      theData[11] = new TheData("Horse","Selected Horse");
      theData[11].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[12] = new TheData("Pig","Selected Pig");
      theData[12].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[13] = new TheData("Cow","Selected Cow");
      theData[13].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[14] = new TheData(
        "Fruit                                       ","");
      theData[15] = new TheData(
                                 "Peach","Selected Peach");
      theData[15].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[16] = new TheData("Grape","Selected Grape");
      theData[16].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[17] = new TheData("Apple","Selected Apple");
      theData[17].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));
      theData[18] = new TheData(
                               "Orange","Selected Orange");
      theData[18].theJLabel.setIcon(
                           new ImageIcon(unSelectedImage));

      return theData;
      
    }//end method getData()
  }//end class MyData
  //===================================================//

  //The following inner class is used to create an object
  // in which to maintain the JLabel and the
  // supplementary information for each node in the tree.
  class TheData implements Serializable{
    JLabel theJLabel = new JLabel();
    String theSupplementalInfo;
    
    //constructor
    TheData(String theLabel,String theSupplementalInfo){
      this.theJLabel.setText(theLabel);
      this.theSupplementalInfo = theSupplementalInfo;
    }//end constructor
  }//end class TheData
  //=====================================================//

}//end class Tree06