Improving performance of JTree ?

[Steven Rombauts]

Hello all,

I have written a TreeNode which holds all local & removable discs, and creates an entire tree of the directories (not the files!) underneath it (working on windows xp).
I get the desired results (eg. the right directories etc), but performance really seems to be an issue. It's not that it won't work well, but I do believe it should be faster for a nice user experience

I listed the code here, I am hoping some of you experienced Java coders could give me some pointers and tips to improve performance? When I click on a node, it takes a while before it opens up sometimes, especially if there are a lot of subdirectories. The JTree is put inside a JScrollPane, and scrolling doesn't go as fast as it should be sometimes. And could setOpaque( false ) also be a huge problem? It's ok that the first time a directory is opened, it takes a little while, but it should work faster as soon as the Children have been loaded into memory, no?

		// this is how I set up the JTree:
		directoryTree = new JTree(new FileTreeNode());
		directoryTree.setRootVisible(false);
		DefaultTreeCellRenderer treeCellRenderer = new DefaultTreeCellRenderer();
		treeCellRenderer.setLeafIcon(treeCellRenderer.getClosedIcon());
		directoryTree.setCellRenderer(treeCellRenderer);
		directoryTree.setOpaque(false);

		JScrollPane scrollPaneTree = new JScrollPane(directoryTree);

/**
* This is the FileTreeNode class which handles all the data
*/
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.ArrayList;
import java.util.List;

import javax.swing.tree.TreeNode;
import javax.swing.filechooser.FileSystemView;

public class FileTreeNode implements TreeNode
{
	private TreeNode parent;
	private File file;
	private Hashtable<String, TreeNode> children;

	private boolean isTreeRoot = false;
	private boolean isSystemRoot = false;
	private FileSystemView fileSystemView;
	private ArrayList<File> sysRoots;
	private String sysRootName;
	
	public FileTreeNode() 
	{
		this("tree_root", null);
	}

	public FileTreeNode(String path, TreeNode parent)
	{
		if(path.equals("tree_root"))
		{
			this.isTreeRoot = true;
			fileSystemView = FileSystemView.getFileSystemView();
			
			// only removable or local disks!
			sysRoots = new ArrayList<File>();
			List <File>files = Arrays.asList(File.listRoots());
			for(File f : files)
			{
				String s2 = FileSystemView.getFileSystemView().getSystemTypeDescription(f);
				if(s2.equals("Local Disk") || s2.equals("Removable Disk") )
					sysRoots.add(f);
			}
		}
		else
		{
			file = new File(path);
		}
		
		children = new Hashtable<String, TreeNode>();
	}
	public TreeNode getChildAt(int childIndex) 
	{
		String name = "";
		
		if(isTreeRoot)
		{
			name = sysRoots.get(childIndex).getAbsolutePath();
		}
		else
		{
			String[] names = file.list(new FileListFilter());
			name = names[childIndex];
		}
		
		return getChild(name);
	}

	public int getChildCount() 
	{
		if(isTreeRoot)
		{
			return sysRoots.size();
		}
		else if (file.isDirectory()) 
		{
			return file.list(new FileListFilter()).length;
		}
		
		return 0;
	}

	public TreeNode getParent()
	{
		return parent;
	}

	public int getIndex(TreeNode node) 
	{
		String name = ((FileTreeNode)node).file.getName();
		String[] names = file.list(new FileListFilter());
		
		if(names == null)
			return -1;
		
		for (int i=0; i<names.length; i++)
		{
			if (names[i].equals(name))
				return i;
		}
		
		return -1;
	}

	public boolean getAllowsChildren() 
	{
		if(isTreeRoot)
			return true;
		
		String[] names = file.list(new FileListFilter());
		
		if(names == null)
			return false;
		
		return (names.length > 0);
	}

	public boolean isLeaf()
	{
		if(isTreeRoot)
			return false;
		
		String[] names = file.list(new FileListFilter());
		
		if(names == null)
			return true;
		
		return !(names.length > 0);
	}

	public Enumeration children()
	{
		return new ChildrenEnumeration();
	}

	public String toString()
	{
		if(isTreeRoot)
		{
			return "System";
		}
		else if(isSystemRoot)
		{
			if(sysRootName == null)
			{
				sysRootName = fileSystemView.getSystemDisplayName(file);
				if(sysRootName.equals(""))
					sysRootName = "(" + file.getAbsolutePath().replace("\\", "") + ")";
			}

			return sysRootName;
		}
		else
		{
			return file.getName();
		}
	}

	private FileTreeNode getChild(String name)
	{		
		if (children.containsKey(name))
			return (FileTreeNode)children.get(name);
		
		try 
		{
			FileTreeNode child;
			
			if(isTreeRoot)
			{				
				String path = name;
				child = new FileTreeNode(path, this);
				child.setAsSystemRoot(true);
				children.put(path, child);
			}
			else
			{
				String path = file.getCanonicalPath() + "/" + name;
				child = new FileTreeNode(path, this);
				children.put(name, child);
			}
			
			return child;
		} 
		catch (IOException e)
		{
			return null;
		}
	}

	public File getFile()
	{
		return file;
	}
	
	public void setAsSystemRoot(boolean b)
	{
		this.isSystemRoot = true;
		fileSystemView = FileSystemView.getFileSystemView();
	}
	
	private class ChildrenEnumeration implements Enumeration 
	{
		String[] names;
		int index;
	
		public ChildrenEnumeration()
		{
			String names[];
			
			if(isTreeRoot)
			{
				names = new String[sysRoots.size()];
				for(int i=0;i<sysRoots.size();i++)
					names[i] = sysRoots.get(i).getAbsolutePath();
			}
			else
			{
				names = file.list(new FileListFilter());
			}
		}
	
		public boolean hasMoreElements()
		{
			return index < names.length - 1;
		}
	
		public Object nextElement() 
		{
			String name = names[index];
			index++;
			
			return getChild(name);
		}
	}
	
	private class FileListFilter implements FilenameFilter
	{			
		public boolean accept(File directory, String filename) 
		{				
			File f = new File(directory.getAbsolutePath() + "/" + filename);
			if(f.isDirectory())
				return true;
			
			return false;
		}
	}
}

I am becoming a bit worried because the computers at school on which I have to showcase this application aren't even as fast as my own system here at home, whoops :-)

Thank you in advance for any pointers and tips :-)

Regards,
Steven

[Mathias Nilsson]

What about not adding childs to a node before expanding?

Let's say we have a root node that is c:\

you need to implement the hasChild, childCount. When clicking the root you load the next step into the tree. This can be done with all the nodes.
If you use java.io.File as an object in DefaultMutableTree node you should get this to work.

[Rob Spoor]

You should also consider caching the results of File.list calls. I've created my own FileTreeModel (not TreeNode but similar), and ran into the same problem. The cause was the number of calls to File.list:
- in getChildCount()
- in getChildAt() for all children
- in isLeaf() for all children

As the number of visible nodes increases, the number of calls to File.list increases even harder. By caching the results and using that cached value, your tree will be a lot faster already. That does cause your tree to be out-dated at times, but by refreshing the cache (e.g. on each call to getChildCount()) you can solve that.

[Steven Rombauts]

Thank you both for the useful tips!

Caching the results of the file.list() method did improve the performance of my tree quite a bit! It runs great now :-)

[Kriss Reddy]

...
[MG]Removed hijack

[Kriss Reddy]

...
[MG]Removed hijack

[Maneesh Godbole]

Kriss,
Please do not hijack other people's threads.
You can start a new thread to post your question
http://faq.javaranch.com/java/UseOneThreadPerQuestion

[Kriss Reddy]

Hi,

Sorry for hijacking, My intention was to take advantage of the problem described here. I will not hijack again.

Thanks.