按字母順序排序Jtree節點

Question

我已經加載了我的JTree來查看我的目錄結構，如我的代碼和輸出圖像所示。 這里，Tree節點默認按字母順序排序，但我的另一個要求是我想根據目錄名的第二個名稱對所有節點進行排序，而不實際重命名目錄。 我已經在下面列出了我需要對JTree節點進行排序的名稱。 請給我一些建議。

import java.io.File;
import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

public class FILE_NAME {
public static void main(String[] args) {
       JFrame frame = new JFrame("My Jtree");

       File root = new File("C:/java");
       JTree tree = new JTree(new FileTreeModel(root));
       frame.setSize(300, 300);
       frame.setVisible(true);
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       frame.add(tree);
       frame.setVisible(true);            
      }
    }

class FileTreeModel implements TreeModel {

protected File root;

public FileTreeModel(File root) {
    this.root = root;
}

@Override
public Object getRoot() {
    return root;
}

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

@Override
public int getChildCount(Object parent) {
    String[] children = ((File) parent).list();
    if (children == null) {
        return 0;
    }
    return children.length;
}

@Override
public Object getChild(Object parent, int index) {
    String[] children = ((File) parent).list();
    if ((children == null) || (index == children.length)) {
        return null;
    }
    return new File((File) parent, children[index]);
}

@Override
public int getIndexOfChild(Object parent, Object child) {
    String[] children = ((File) parent).list();
    String childname = ((File) child).getName();
    if (children == null) {
        return -1;
    }
    for (int i = 0; i == children.length; i++) {
        if (childname.equals(children[i])) {
            return i;
        }
    }
    return -1;
}

@Override
public void valueForPathChanged(TreePath path, Object newvalue) {
}

@Override
public void addTreeModelListener(TreeModelListener l) {
}

@Override
public void removeTreeModelListener(TreeModelListener l) {
}
}

OUTPUT

Answer 1

它是這樣的：

public void sortTree() {
    treeModel.reload(sort(rootNode));
}

public DefaultMutableTreeNode sort(DefaultMutableTreeNode node) {

    //sort alphabetically
    for(int i = 0; i < node.getChildCount() - 1; i++) {
        DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(i);
        String nt = child.getUserObject().toString();

        for(int j = i + 1; j <= node.getChildCount() - 1; j++) {
            DefaultMutableTreeNode prevNode = (DefaultMutableTreeNode) node.getChildAt(j);
            String np = prevNode.getUserObject().toString();

            System.out.println(nt + " " + np);
            if(nt.compareToIgnoreCase(np) > 0) {
                node.insert(child, j);
                node.insert(prevNode, i);
            }
        }
        if(child.getChildCount() > 0) {
            sort(child);
        }
    }

    //put folders first - normal on Windows and some flavors of Linux but not on Mac OS X.
    for(int i = 0; i < node.getChildCount() - 1; i++) {
        DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(i);
        for(int j = i + 1; j <= node.getChildCount() - 1; j++) {
            DefaultMutableTreeNode prevNode = (DefaultMutableTreeNode) node.getChildAt(j);

            if(!prevNode.isLeaf() && child.isLeaf()) {
                node.insert(child, j);
                node.insert(prevNode, i);
            }
        }
    }

    return node;

}

Answer 2

最靈活的解決方案是構建一個DefaultMutableTreeNode的簡單擴展，每次添加一個新元素時對該節點的子節點進行排序（對於一般的想法， 這歸功於本文 ）：

public class SimpleTreeNode
extends DefaultMutableTreeNode
{
    private final Comparator comparator;

    public SimpleTreeNode(Object userObject, Comparator comparator)
    {
        super(userObject);
        this.comparator = comparator;
    }

    public SimpleTreeNode(Object userObject)
    {
        this(userObject,null);
    }

    @Override
    public void add(MutableTreeNode newChild)
    {
        super.add(newChild);
        if (this.comparator != null)
        {
            Collections.sort(this.children,this.comparator);
        }
    }
}

此解決方案非常靈活，因為它允許您為樹的每個級別甚至每個文件夾使用不同的排序方法。 （當然，你也可以很容易地在任何地方使用相同或不同的Comparator 。）

如果這有助於任何人，請參閱下面兩個我使用SimpleTreeNode排序方法：

public class Comparators
{
    /** Allows alphabetical or reverse-alphabetical sorting
     * 
     */

    public static class AlphabeticalComparator
    implements Comparator
    {
        private final boolean order;

        public AlphabeticalComparator()
        {
            this(true);
        }

        public AlphabeticalComparator(boolean order)
        {
            this.order = order;
        }

        @Override
        public int compare(Object o1, Object o2)
        {
            if (order)
            {
                return o1.toString().compareTo(o2.toString());
            }
            else
            {
                return o2.toString().compareTo(o1.toString());
            }
        }
    }

    /** Allows sorting according to a pre-defined array
     * 
     */

    public static class OrderComparator
    implements Comparator
    {
        private final String[] strings;

        public OrderComparator(String[] strings)
        {
            this.strings = strings;
        }

        @Override
        public int compare(Object o1, Object o2)
        {
            String s1 = o1.toString();
            String s2 = o2.toString();
            int i1 = -1;
            int i2 = -1;
            for (int j = 0; j < strings.length; j++)
            {
                if (s1.equals(strings[j]))
                {
                    i1 = j;
                }
                if (s2.equals(strings[j]))
                {
                    i2 = j;
                }
            }
            if (i1 == -1 || i2 == -1)
            {
                throw new Error("Can't use this comparator to compare "+o1+" and "+o2);
            }
            else
            {
                return Integer.compare(i1,i2);
            }
        }
    }
}

Answer 3

你可以使用使用Comparator的Arrays.sort（）方法，並編寫自己的比較器，按照你自己的規則比較條目，如：

String[] children = ((File) parent).list();
Arrays.sort(children, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        // do your comparison
    }
});

在模型方法中它將是重載，因此您可以考慮將目錄列表保存在某個模型專用字段中，並檢查模型方法調用中是否未更改目錄（比較File.lastModified（）將有所幫助）。 如果是 - 保存新的列表。