Question

我对文件系统中的目录有一个JTree实现。我遇到的问题是，当删除或重命名目录时，树仍然显示其父目录中的目录。一旦扩展了节点，父树似乎不会针对任何更改进行更新。

我编写的模型没有缓存（我已经注释了它确实有限的缓存） - 就像JTree本身缓存了节点一样。

代码（模型是嵌套的子类）：

public class FileSystemTree
extends JTree
{

// *****************************************************************************
// INSTANCE CREATE/DELETE
// *****************************************************************************

public FileSystemTree() {
    this(new Model(null,null,null));
    }

public FileSystemTree(String startPath) {
    this(new Model(startPath,null,null));
    }

public FileSystemTree(FileSelector inc, FileSelector exc) {
    this(new Model(null,inc,exc));
    }

public FileSystemTree(String startPath, FileSelector inc, FileSelector exc) {
    this(new Model(startPath,inc,exc));
    }

private FileSystemTree(Model model) {
    super(model);

    //setLargeModel(true);
    setRootVisible(false);
    setShowsRootHandles(true);
    putClientProperty("JTree.lineStyle","Angled");
    }

// *****************************************************************************
// INSTANCE METHODS - ACCESSORS
// *****************************************************************************

public Object getRoot() {
    return getModel().getRoot();
    }

// *****************************************************************************
// INSTANCE METHODS
// *****************************************************************************

public String convertValueToText(Object value,boolean selected,boolean expanded,boolean leaf,int row,boolean hasFocus) {
    File                                fil=(File)value;

    return (fil.getName().length()!=0 ? fil.getName() : fil.getPath());
    }

// *****************************************************************************
// STATIC NESTED CLASSES - SUPPORTING MODEL
// *****************************************************************************

    static class Model
    extends Object
    implements TreeModel, FilenameFilter
    {

    private File                        root;                                   // tree root
    //ivate Map                         cache;                                  // caches child counts for directories
    private File[]                      fsRoots;                                // copy of file system roots
    private FileSelector                include;                                // inclusion selector
    private FileSelector                exclude;                                // exclusion selector
    private java.util.List              listeners=new ArrayList();

    public Model(String roo, FileSelector inc, FileSelector exc) {
        super();

        root=(roo==null ? DRIVES : new File(roo));
        //cache=new HashMap();
        fsRoots=(root==DRIVES ? rootList() : null);
        include=inc;
        exclude=exc;
        }

    // *****************************************************************************
    // METHODS - MODEL
    // *****************************************************************************

    public Object getRoot() {
        return root;
        }

    public Object getChild(Object parent, int index) {
        File                            dir=(File)parent;

        if(dir==DRIVES) {
            File[]   chl=fsRoots; //rootList();
            return (index<chl.length ? chl[index] : null);
            }
        else {
            String[] chl=dirList(dir);
            return (index<chl.length ? new File(dir,chl[index]) : null);
            }
        }

    public int getChildCount(Object parent) {
        File                            dir=(File)parent;
        //Integer                         cch=(Integer)cache.get(dir);

        //if(cch!=null) {
        //    return cch.intValue();
        //    }

        if(dir==DRIVES) {
            return fsRoots.length; //rootList().length;
            }
        else if(dir.isDirectory()) {
            return dirList(dir).length;
            }
        else {
            return 0;
            }
        }

    public boolean isLeaf(Object node) {
        return((File)node).isFile();
        }

    public void valueForPathChanged(TreePath path, Object newValue) {
        }

    public int getIndexOfChild(Object parent, Object child) {
        File                            dir=(File)parent;
        File                            fse=(File)child;

        if(dir==DRIVES) {
            File[] ca=fsRoots; //rootList();
            for(int xa=0; xa<ca.length; xa++) {
                if(fse.equals(ca[xa])) { return xa; }
                }
            }
        else {
            String[] ca=dirList(dir);
            for(int xa=0; xa<ca.length; ++xa) {
                if(fse.getName().equals(ca[xa])) { return xa; }
                }
            }
        return -1;
        }

     private File[] rootList() {
        File[]                          lst=File.listRoots();

        if(lst==null) { lst=new File[0]; }
        //cache.put(DRIVES,new Integer(lst.length));
        return lst;
        }

     private String[] dirList(File dir) {
        String[]                        lst=dir.list(this);

        if(lst==null) { lst=new String[0]; }
        //cache.put(dir,new Integer(lst.length));
        return lst;
        }

    // *****************************************************************************
    // METHODS - FILENAME FILTER
    // *****************************************************************************

    public boolean accept(File dir, String nam)  {
        return ((include==null || include.accept(dir,nam)) && (exclude==null || !exclude.accept(dir,nam)));
        }

    // *****************************************************************************
    // METHODS - LISTENER
    // *****************************************************************************

    public void addTreeModelListener(TreeModelListener listener) {
        if(listener != null && !listeners.contains(listener)) {
            listeners.add(listener);
            }
        }

    public void removeTreeModelListener(TreeModelListener listener) {
        if(listener != null) {
            listeners.remove(listener);
            }
        }

    public void fireTreeNodesChanged(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesChanged(evt);
            }
        }

    public void fireTreeNodesInserted(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesInserted(evt);
            }
        }

    public void fireTreeNodesRemoved(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesRemoved(evt);
            }
        }

    public void fireTreeStructureChanged(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeStructureChanged(evt);
            }
        }
    } // END INNER CLASS

// *****************************************************************************
// STATIC PROPERTIES
// *****************************************************************************

static private final File               DRIVES=new File("*DRIVES");             // marker for listing file system drives

} // END PUBLIC CLASS

Answer 1

该模型负责通知监听器树结构中的任何修改。如果没有这样的通知，树将不会刷新。

Answer 2

如果检测到目录已更改，您可以编写一些后台线程来查找文件系统中的更改并触发一些模型修改事件。

Answer 3

如果没有看到Model的代码，你确定它正在被调用，例如getChild方法吗？

我可以停止JTree缓存节点（在文件系统树中）吗？

3 个答案: