Java 在JTree中排列节点

我有一个JTree，用户可以在其中拖放或重新排列节点， 保存后，我必须重新安排节点，以便文件类型节点必须出现 在文件夹类型节点之前。我不需要对文件/文件夹名称进行排序

用户树：

 -FolderA
   +FFA1
   -FA1
   -FA2
 -FolderB
   -FB1
 -File1
 -File2
 +FolderC
 -File3

结果树：

-File1
 -File2
 -File3
 -FolderA   
   -FA1
   -FA2
   +FAF1
 -FolderB
   -FB1
 +FolderC

我有下面的代码，它起作用了，但我不知道这是正确的方法还是良好的做法。 你能建议这两种解决方案中哪一种更好，或者你能建议其他方法吗

多谢各位

解决方案1：

private void arrange(DefaultMutableTreeNode parent){
    DefaultMutableTreeNode sorted = new DefaultMutableTreeNode();
    List<DefaultMutableTreeNode> files = new ArrayList<DefaultMutableTreeNode>();
    List<DefaultMutableTreeNode> folders = new ArrayList<DefaultMutableTreeNode>();

    for (int i = 0; i < parent.getChildCount(); i++){
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getChildAt(i);
        int type = ((BusinessObject) node.getUserObject()).getType();
        if (type == BusinessObject.FILE)
            files.add(node);
        else{
            arrange(node);
            folders.add(node);
        }
    }
    for (int i = 0; i < files.size(); i++)
        sorted.add((DefaultMutableTreeNode) files.get(i));

    for (int i = 0; i < folders.size(); i++)
        sorted.add((DefaultMutableTreeNode) folders.get(i));

    while (sorted.getChildCount() > 0)
        parent.add((DefaultMutableTreeNode) sorted.getChildAt(0));

    sorted = null;
    files = null;
    folders = null;
}

private void arrange（DefaultMutableTreeNode父级）{
DefaultMutableTreeNode sorted=新的DefaultMutableTreeNode（）；
列表文件=新的ArrayList（）；
列表文件夹=新建ArrayList（）；
对于（int i=0；i0）
add（（DefaultMutableTreeNode）sorted.getChildAt（0））；
排序=空；
files=null；
文件夹=空；
}

解决方案2：

private void arrange(DefaultMutableTreeNode parent){
    DefaultMutableTreeNode sorted = new DefaultMutableTreeNode();
    List<DefaultMutableTreeNode> nodes = new ArrayList<DefaultMutableTreeNode>();

    for (int i = 0; i < parent.getChildCount(); i++){
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getChildAt(i);
        int type = ((BusinessObject) node.getUserObject()).getType();
        if (type == BusinessObject.FILE)
            nodes.add(node);
    }

    for (int i = 0; i < parent.getChildCount(); i++){
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getChildAt(i);
        int type = ((BusinessObject) node.getUserObject()).getType();
        if (type == BusinessObject.FOLDER){
            arrange(node);
            nodes.add(node);
        }
    }

    for (int i = 0; i < nodes.size(); i++)
        sorted.add((DefaultMutableTreeNode) nodes.get(i));

    while (sorted.getChildCount() > 0)
        parent.add((DefaultMutableTreeNode) sorted.getChildAt(0));

    sorted = null;
    nodes = null;
}

private void arrange（DefaultMutableTreeNode父级）{
DefaultMutableTreeNode sorted=新的DefaultMutableTreeNode（）；
列表节点=新的ArrayList（）；
对于（int i=0；i0）
add（（DefaultMutableTreeNode）sorted.getChildAt（0））；
排序=空；
节点=空；
}

我认为两者都是很好的解决方案。很容易判断他们在做什么：取出文件，取出文件夹，按正确的顺序将它们扔回树中。而且，递归调用是直接和直观的

选择你觉得最自然的。第二种似乎更像是我的做法，但那只是我自己，没有太大区别

---

您使用的是Java5还是Java6？如果是，请使用。此外，您不必在方法末尾清除私有变量的值。当方法返回时，它们无论如何都会消失。

当我在应用程序中使用它时，这实际上是有效的。我的节点都是defaultmutabletreenodes，没有任何更改。 将传入并更改要排序的节点。 它生成子节点的arraylist。然后，对其中一个进行排序的节点文本的两个ArrayList进行排序。另一个用于查找arralylist中的节点。 所有节点都从初始节点移出，然后从arraylist重新添加。 使用arraylist可能有点过分，但我喜欢它们

private void sortchildren(DefaultMutableTreeNode node) {
        ArrayList children = Collections.list(node.children());
        // for getting original location
        ArrayList<String> orgCnames = new ArrayList<String>();
        // new location
        ArrayList<String> cNames = new ArrayList<String>();
        //move the child to here so we can move them back
        DefaultMutableTreeNode temParent = new DefaultMutableTreeNode();
        for(Object child:children) {
            DefaultMutableTreeNode ch = (DefaultMutableTreeNode)child;
            temParent.insert(ch,0);
            cNames.add(ch.toString().toUpperCase());
            orgCnames.add(ch.toString().toUpperCase());
        }
        Collections.sort(cNames);
        for(String name:cNames) {
            // find the original location to get from children arrayList
            int indx = orgCnames.indexOf(name);
            node.insert((DefaultMutableTreeNode)children.get(indx),node.getChildCount());
        }
    }

private void sortchildren（DefaultMutableTreeNode节点）{
ArrayList children=Collections.list（node.children（））；
//用于获取原始位置
ArrayList orgCnames=新的ArrayList（）；
//新位置
ArrayList cNames=新的ArrayList（）；
//把孩子移到这里，这样我们就可以把他们移回来
DefaultMutableTreeNode temParent=新的DefaultMutableTreeNode（）；
for（对象子对象：子对象）{
DefaultMutableTreeNode ch=（DefaultMutableTreeNode）子级；
temParent.insert（ch，0）；
cNames.add（ch.toString（）.toUpperCase（））；
orgCnames.add（ch.toString（）.toUpperCase（））；
}
收集.分类（cNames）；
for（字符串名称：cNames）{
//查找要从子arrayList获取的原始位置
int indx=orgCnames.indexOf（名称）；
插入（（DefaultMutableTreeNode）children.get（indx），node.getChildCount（）；
}
}

我稍微修改了Mike的代码示例，以解释重复的名称，并在文件之前对文件夹进行排序。否则它就像一场梦。谢谢你，迈克

public static void sortTreeNode(DefaultMutableTreeNode node) {
List<DefaultMutableTreeNode> children = Collections.list(node.children());
List<String> sortFileNames = new ArrayList<>();
List<String> sortFolderNames = new ArrayList<>();
List<String> sortNames = new ArrayList<>();
List<String> origNames = new ArrayList<>();
DefaultMutableTreeNode temParent = new DefaultMutableTreeNode();
for (int x = 0; x < children.size(); x++) {
    DefaultMutableTreeNode child = children.get(x);
    temParent.insert(child, 0);
    if (!child.isLeaf()) {
    sortFolderNames.add(ViewMethods.getStringForNode(child).toUpperCase() + x);
    origNames.add(ViewMethods.getStringForNode(child).toUpperCase() + x);
    if (child.getChildCount() > 0) {
        sortTreeNode(child);
    }
    } else {
    sortFileNames.add(ViewMethods.getStringForNode(child).toUpperCase() + x);
    origNames.add(ViewMethods.getStringForNode(child).toUpperCase() + x);
    }
}
Collections.sort(sortFolderNames);
Collections.sort(sortFileNames);
sortNames.addAll(sortFolderNames);
sortNames.addAll(sortFileNames);
for (String name : sortNames) {
    // find the original location to get from children arrayList
    int indx = origNames.indexOf(name);
    node.insert(children.get(indx), node.getChildCount());
}
}

publicstaticvoidsorttreenode（DefaultMutableTreeNode节点）{
List children=Collections.List（node.children（））；
List sortFileNames=new ArrayList（）；
List sortFolderNames=new ArrayList（）；
List sortNames=new ArrayList（）；
List origNames=new ArrayList（）；
DefaultMutableTreeNode temParent=新的DefaultMutableTreeNode（）；
对于（int x=0；x0）{
sortTreeNode（儿童）；
}
}否则{
添加（ViewMethods.getStringForNode（child.toUpperCase（）+x）；
add（ViewMethods.getStringForNode（child.toUpperCase（）+x）；
}
}
Collections.sort（sortFolderNames）；
Collections.sort（sortFileNames）；
sortNames.addAll（sortFolderNames）；
sortNames.addAll（sortfilename）；
for（字符串名称：sortNames）{
//查找要从子arrayList获取的原始位置
int indx=origNames.indexOf（名称）；
insert（children.get（indx），node.getChildCount（））；
}
}

非常简单： 放

    DefaultMutableTreeNode all_node = 
     new DefaultMutableTreeNode("Root folder");
    DefaultMutableTreeNode one_node;
    Vector sorted_people=new Vector();
    // a simple algorithm of sorting array
    for (int i=0;i<o_people.length-1;i++){
    for (int j=i+1;j<o_people.length;j++){
        if(o_people[j].toString().compareTo
           (o_people[i].toString())<0) {

            String permut=o_people[i].toString();
            o_people[i]=o_people[j];
            o_people[j]=permut;

        }

    }
    sorted_people.add(o_people[i]);

   //in my case the leaf is a JChechbox but you can put a String
    one_node = new DefaultMutableTreeNode
     ( new JCheckBox(o_people[i].toString(), boolien));
    all_node.add(one_node);
    }

    tree_model.setRoot(all_node);

DefaultMutableTreeNode node; // node can't be null, it's an example

List<DefaultMutableTreeNode> childrenList = Collections.list(node.children());

Collections.sort(childrenList, (o1,o2) ->
((Node) o1.getUserObject()).getName().compareToIgnoreCase(((Node)o2.getUserObject()).getName()));

node.removeAllChildren();
childrenList.forEach(node::add);