comparer deux objets TreeNode (ou DefaultMutableTreeNode) dans Java Comparator

Question

Mon objectif est très simple aujourd'hui, j'essaye de trouver la bonne façon d'implémenter l'interface compareTo (ou Comparable) pour ma classe qui étend DefaultMutableTreeNode.

Le problème est le: Dites que j'ai une classe parfaitement bonne qui représente les temps. J'ai déjà écrit une très bonne méthode compareTo (qui fonctionne comme je le souhaite) que j'ai testé avec Arrays.sort() avec des résultats merveilleux.

Maintenant, supposons que j'ai un JTree avec des grappes d'objets différents, comme ceci:

new SpecialNode("Zomg a string!"); // add this group of nodes right here 
    new SpecialNode(new Time("8:55 PM")); 
    new SpecialNode(new SomeTypeYouveNeverHeardOf()); 

Donc, être un programmeur professionnel, je commence immédiatement le codage sans préméditation que ce soit. Voici ma classe SpecialNode:

class SpecialNode extends DefaultMutableTreeNode implements Comparator<SpecialNode> 
{ 
    public int compareTo(SpecialNode sn) 
    { 
     // Not only does this not work correctly (read: at all) 
     // But, it is sub-par, how do I get the type information out of the userObject 
     // So I can cast it correctly and call the correct compareTo method!! 
     return this.getUserObject().toString().compareTo(sn.getUserObject().toString()); 
    } 
} 

Ok, donc si vous ne l'avez pas lu les commentaires (qui, avouez, vous ne l'avez pas); Mon problème est que dans la méthode compareTo de SpecialNode, j'ai seulement accès à l'userObject. Malheureusement, je ne sais pas ce qu'utilisait userObject, et en tant que tel, je ne peux pas le lancer correctement pour appeler la méthode compareTo correcte!

C'est vraiment pénible, puisque j'ai déjà écrit plusieurs méthodes de comparaison parfaites dans toutes les classes qui seront ajoutées à mon arbre. Alors quelqu'un peut-il aider un gars et me laisser tomber un indice?

tl; dr - Comment obtenir des informations de type sur un objet générique stocké par DefaultMutableTreeNode? Si ce n'est pas possible, comment dois-je comparer deux instances de SpecialNode quand je ne sais même pas ce qu'elles peuvent contenir!

Merci d'avance.

Answer 1

Je suppose que vous ne pouvez pas avoir un TreeNode pour chaque type de données. Est-ce qu'il est logique dans votre cas d'utilisation de faire des comparaisons si le type est différent?

Idées:

1. Peut-simpleNode connaître tous les types possibles et à faire instanceof et des moulages du type correct pour Comparable? C'est ainsi que je l'aurais traité il y a quelques années.

2. Que pensez-vous des avertissements non vérifiés? J'ai eu un problème similaire avant d'utiliser un JList et je ne pouvais pas vraiment rendre le compilateur heureux (j'ai abandonné le modèle par défaut de swing pour me faciliter la vie). Peut-être que quelqu'un d'autre pourrait améliorer cette réponse?

   class SpecialNode<T extends Comparable<T>> extends DefaultMutableTreeNode 
                 implements Comparable<SpecialNode> 
   { 
       T typedUserObject; 
       SpecialNode(T t) 
       { 
       this.typedUserObject = t; 
       setUserObject(t); 
       } 
   
   
       public int compareTo(SpecialNode node) 
       { 
        if(typedUserObject.getClass().isInstance(node.typedUserObject)) 
        { 
         T otherObj = (T) node.typedUserObject; 
         return typedUserObject.compareTo(otherObj); 
        } 
        else 
        { 
         //What are you going to do if they're not the same type? 
         return -1; 
        } 
       } 
   
   
   } 
   

Edit: Si vous savez qu'ils devraient être du même type - élimine vérifier

class SpecialNode<T extends Comparable<T>> extends DefaultMutableTreeNode 
              implements Comparable<SpecialNode<T>> 
{ 
    T typedUserObject; 
    SpecialNode(T t) 
    { 
    this.typedUserObject = t; 
    setUserObject(t); 
    } 


    public int compareTo(SpecialNode<T> node) 
    { 
    return typedUserObject.compareTo(node.typedUserObject); 
    }  
} 

Si vous ne voulez pas le code dans le nœud lui-même (je ne pense que je le ferais), vous pourriez créer une classe séparée que