performance of Tree

public class SmartNodeTreeModel extends AbstractTreeModel<Node> implements TreeDataListener {
  private final Set<Node> visible = new HashSet<Node>();

  /**
   * Create a new tree model with the given list of resources as the root.
   * @param root the root of the model
   */
  public SmartNodeTreeModel(Node root) {
    super(root);
    this.addTreeDataListener(this);
    visible.add(root);                  // actually, the root is never visible but for correctness we add it
    visible.addAll(root.getChildren()); // these are the only nodes visible when first opening the tree
  }
  
  /**
   * @param node the parent tree node
   * @param index the position of the child, starting at 0
   * @return the child of the given input node at the given position
   */
  @Override
  public Node getChild(Node node, int index) {
    // calling this method if the node is not visible is a bug
    assert( visible.contains(node) );
    return node.getChildren().get(index);
  }

  /**
   * @param node the parent node the number of children of which is requested
   * @return the number of children of the given input node
   */
  @Override
  public int getChildCount(Node node) {
    if ( node == null ) {
      return 0;
    }
    // calling this method if the node is not visible is a bug
    assert( visible.contains(node) );    
    return node.getChildren().size();
  }
    
  @Override
  public boolean isLeaf(Node node) {    
    // pretend the node to be a leaf if it is not  visible, this prunes the iteration when building Treeitems
    return !visible.contains(node) || getChildCount(node) == 0;
  }

  @Override
  public void onChange(TreeDataEvent event) {
    if ( event.getType() != TreeDataEvent.OPEN_CHANGED ) { return; }
    // get the domain object represented by the node
    Node node = getChild(event.getPath()); 
    // fetch its children from the database (children is a lazy property)
    for ( Node child : node.getChildren() ) {
      // if the child is not yet visible somewhere 
      if ( !visible.contains(child) ) {
        // now it is visible
        visible.add(child);
        // if the node has children (these are fetched from the database lazily)
        if ( child.getChildren().size() > 0 ) {
          // for each occurrence (recall, we have a DAG)
          Set<Treeitem> occurrences = ExplorerUtils.getTreeitems(child); // a mapping from domain object to several Treeitems
          for ( Treeitem occurrence : occurrences ) {
            // tell ZK to add the little triangel for expanding it
            // ( this is not actually a change in the data but ZK thought 'child' to be a leaf up to now )
            fireEvent(
                TreeDataEvent.INTERVAL_ADDED, 
                ExplorerUtils.getPath(occurrence), // our getPath method 
                0,
                child.getChildren().size() - 1);
          }
        }
      }
    }
  }    
  ...
}