Trier Jtree Nœud Par Ordre Alphabétique

J'ai chargé mon JTree à la vue de Mon répertoire de la structure, comme indiqué dans mon code et de l'image de sortie.
Ici, les nœuds de l'Arborescence par défaut, sont triés dans l'ordre alphabétique, mais mon autre exigence est que je veux trier tous les nœuds selon un deuxième nom de nom de répertoire sans renommer le répertoire.
J'ai souligné le nom sur lequel j'ai besoin de trier les JTree nœud. Merci de me suggérer quelque chose.

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) {
}
}

"s'il vous plaît me suggérer quelque chose" 1) Décrire ce que vous avez essayé. 2) Poser une question.
eh bien, je suis encore en train vous permettra de savoir rapidement
Dans le cas où vous n'avez pas besoin de dynamique de tri, de la façon la plus simple est de trier vos TreeModel lorsque vous construire

OriginalL'auteur Jony | 2012-03-15

2

vous pouvez utiliser des Tableaux.méthode sort() qui utilise la Comparaison, et écrire votre propre comparateur qui compare les entrées par vos propres règles, comme ça:
```
String[] children = ((File) parent).list();
Arrays.sort(children, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//do your comparison
}
});
```
Dans le modèle des méthodes, il sera de surcharge, de sorte que vous pouvez envisager pour économiser de l'inscription à l'annuaire dans certains modèle de champ privé et de vérifier si le répertoire n'a pas été modifié dans le modèle les méthodes d'invocation (comparaison de Fichier.lastModified() peut aider). Si c'était - enregistrer la nouvelle liste.

OriginalL'auteur yggdraa

Il va comme ceci :

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;
}

OriginalL'auteur Adrian

La solution la plus souple est de construire une simple extension de DefaultMutableTreeNode qui trie les enfants du nœud à chaque fois qu'un nouvel élément est ajouté (crédit à cet article pour l'idée générale):

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);
}
}
}

Cette solution est très flexible car il permet d'avoir différentes méthodes de tri pour chaque niveau de l'arbre ou même pour chaque dossier. (Bien sûr, vous pouvez aussi très facilement utiliser le même ou pas Comparator partout.)

Dans le cas où cela peut aider n'importe qui, voir ci-dessous deux méthodes de tri que j'ai utilisé avec 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);
}
}
}
}

OriginalL'auteur Candamir

Vous devez vous connecter pour publier un commentaire.