Java 按字母顺序对Jtree节点排序
我已经加载了我的JTree以查看我的目录结构，如代码和输出图像所示。 这里，树节点默认按字母顺序排序，但我的另一个要求是，我希望根据目录名的第二个名称对所有节点进行排序，而不实际重命名目录。 我已经在需要对JTree节点进行排序的名称上画了下划线。请给我提个建议Java 按字母顺序对Jtree节点排序,java,swing,jtree,Java,Swing,Jtree,我已经加载了我的JTree以查看我的目录结构，如代码和输出图像所示。 这里，树节点默认按字母顺序排序，但我的另一个要求是，我希望根据目录名的第二个名称对所有节点进行排序，而不实际重命名目录。 我已经在需要对JTree节点进行排序的名称上画了下划线。请给我提个建议 import java.io.File; import javax.swing.JFrame; import javax.swing.JTree; import javax.swing.event.TreeModelListener;
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) {
}
}
String[] children = ((File) parent).list();
Arrays.sort(children, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// do your comparison
}
});
String[]children=（（文件）parent.list（）；
Arrays.sort（子级，新的Comparator（）{
@凌驾
公共整数比较（字符串o1、字符串o2）{
//你做比较吗
}
});
在模型方法中，它将是超载的，因此您可以考虑在某些模型私有字段中保存目录列表，并检查在模型方法调用中是否没有更改目录（比较文件。如果是-保存新列表。
它是这样的：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;
}
public void sortTree（）{
treeModel.reload（sort（rootNode））；
}
公共DefaultMutableTreeNode排序（DefaultMutableTreeNode节点）{
//按字母顺序排序
对于（int i=0；i0）{
分类（儿童）；
}
}
//首先放置文件夹-在Windows和某些Linux版本上是正常的，但在Mac OS X上不是。
对于（int i=0；iDefaultMutableTreeNode
扩展，每次添加新元素时对节点的子节点进行排序（总体思路归功于）：
此解决方案非常灵活，因为它允许您对树的每个级别甚至每个文件夹使用不同的排序方法。（当然，您也可以非常轻松地在任何地方使用相同或无比较器。）
如果这对任何人都有帮助，请参见下面我在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);
}
}
}
}
公共类比较器
{
/**允许按字母顺序或逆字母顺序排序
*
*/
公共静态类字母比较器
执行比较器
{
私有最终布尔序；
公共字母比较器（）
{
这是真的；
}
公共字母比较器（布尔顺序）
{
这个。顺序=顺序；
}
@凌驾
公共整数比较（对象o1、对象o2）
{
如果（订单）
{
返回o1.toString（）.compareTo（o2.toString（））；
}
其他的
{
返回o2.toString（）.compareTo（o1.toString（））；
}
}
}
/**允许根据预定义数组进行排序
*
*/
公共静态类OrderComparator
执行比较器
{
私有最终字符串[]字符串；
public OrderComparator（字符串[]字符串）
{
this.strings=字符串；
}
@凌驾
公共整数比较（对象o1、对象o2）
{
字符串s1=o1.toString（）；
字符串s2=o2.toString（）；
inti1=-1；
int i2=-1；
对于（int j=0；j
“请给我一些建议”1）描述您尝试过的内容。2）问一个问题。我仍在尝试。我会尽快告诉您，如果您不需要动态排序，最简单的方法是在构建树模型时对其进行排序。此代码无法正常工作。在内部循环中交换节点会导致后续比较使用错误的节点。最好搜索如果需要，在最后交换最小值。两个循环结束得太早。代码只会下降到包含两个或多个子项的文件夹中，并且不会比较最后一个子项。
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);
}
}
}
}