Parsing a TreeModel structure

[Trevor Price]

Say I have a very large tree structure (7000+ nodes) and I need to parse it. What's the fastest way to accomplish this? I've been toying with the code below, but it's just too slow.

public static void parseTree(DefaultMutableTreeNode root)
{
  System.out.println(root.getUserObject());
  for (java.util.Enumeration e = root.children(); e.hasMoreElements() :wink: 
  {
    DefaultMutableTreeNode one = (DefaultMutableTreeNode)e.nextElement();
    System.out.println("  " + one);
    for (Enumeration f = one.children(); f.hasMoreElements() :wink: 
    {
      DefaultMutableTreeNode two = (DefaultMutableTreeNode)f.nextElement();
      System.out.println("    " + two);
      for (Enumeration g = two.children(); g.hasMoreElements() :wink: 
      {
        DefaultMutableTreeNode three = (DefaultMutableTreeNode)g.nextElement();
        System.out.println("      " + three);
        for (Enumeration h = three.children(); h.hasMoreElements() :wink: 
        {
          DefaultMutableTreeNode four = (DefaultMutableTreeNode)h.nextElement();
          System.out.println("        " + four);
          for (Enumeration i = four.children(); i.hasMoreElements() :wink: 
          {
            DefaultMutableTreeNode five = (DefaultMutableTreeNode)i.nextElement();
            System.out.println("          " + five);
            for (Enumeration j = five.children(); j.hasMoreElements() :wink: 
            {
              DefaultMutableTreeNode six = (DefaultMutableTreeNode)j.nextElement();
              System.out.println("            " + six);
            }
          }
        }
      }
    }
  }
}

[Paul Clapham]

I'm going to assume that "fastest" refers to how fast you can get the code written:

public static void parseTree(DefaultMutableTreeNode root)
{
  System.out.println(root.getUserObject());
  for (java.util.Enumeration e = root.postOrderEnumeration(); e.hasMoreElements()  
  {
    DefaultMutableTreeNode node = (DefaultMutableTreeNode)e.nextElement();
    System.out.println("  " + node);
  }
}

I'm just guessing at what "parse" means in this context, by the way. I'm guessing it means you want to list out all of the nodes in some order. There are several other enumerations you can choose from if you don't like post order.

[Trevor Price]

Sorry, should have been more clear. By "fast", I mean "optimized", i.e., parsing 7000 nodes is hitting my server hard for about 6 seconds. Ultimately, I'm going to need to be able to manipulate the data in multiple ways. Maybe Enumeration isn't the most optimized code for this.

For example:

Root
  Node
  Node
  Node
  Node
  Node
    Child Node
    Child Node
    Child Node
    Child Node
    Child Node
    Child Node
    Child Node
    Child Node
    Child Node

-----OR-----

Root
  Node
    Child Node
    Child Node
  Node
    Child Node
    Child Node
    Child Node
  Node
    Child Node

[Jaap Vermeer]

Well... Paul Clapham's code is definitely the way to go if you want any sort of maintainability. Then to make it faster, you'll have to profile the code and see what it is doing in thos 6 seconds.
Although 1000 iterations a second does not sound absurd, you might be able to make it faster.

The direction you are going, given your example, sounds bad. The order in which the nodes are processed will (likely) not have a major effect on performance, you still need to go through 7000 nodes.