J'essaie de faire un comparateur qui peut prendre n'importe quel type d'élément à comparer. Je ne sais pas comment créer la classe. Je veux juste qu'il compare deux éléments du même type (mais quel que soit le type que le client lui donne, ex: Integer, String, Double, etc ...) pour voir lequel est plus grand que l'autre.
public class InsertionComparator implements Comparator<T>
{
/**
* Compares two elements.
*
* @param f1 The first element you want to compare.
* @param f2 The second element you want to compare.
* @return -1,0,1 Whether or not one is greater than, less than,
* or equal to one another.
*/
public int compare(<T> element1,<T> element2)
{
if(element1 < element2)
{
return -1;
}
else
{
if(element1 > element2)
{
return 1;
}
else
{
return 0;
}
}
}
}
Veuillez aider, merci!
La chose la plus proche que vous puissiez faire pour cela est un Comparator
qui peut comparer tous les objets qui implémentent l'interface Comparable
:
class NaturalComparator<T extends Comparable<T>> implements Comparator<T> {
public int compare(T a, T b) {
return a.compareTo(b);
}
}
C'est vraiment le plus proche que vous puissiez faire: seuls les objets Comparable
ont "l'ordre naturel" que vous essayez de modéliser ici. Mais généralement, une fois que vous avez des objets Comparable
, vous n'avez pas nécessairement besoin a Comparator
: par exemple, Collections.sort
peut prendre soit un List
avec un Comparator
, soit un List
avec des éléments Comparable
.
Vous ne pouvez pas écrire un seul comparateur pour tout sans certaines hypothèses sur ce que seront les types. Que faites-vous des classes personnalisées? Comment pouvez-vous décider lequel est plus grand que l'autre? Pour plus de classes dans la nature, un comparateur n'a pas de sens.
D'un autre côté, si vous vous limitez à String, Integer, Double, alors ils sont comparables et vous pouvez simplement écrire le comparateur avec la méthode compareTo ():
public int compare(T element1,T element2)
{
return element1.compareTo(element2);
}
mais alors vous utiliseriez simplement l'ordre naturel des éléments, et cela irait à l'encontre de l'objectif d'utiliser un comparateur. Vous n'en avez généralement pas besoin dans ces cas.
Je ne sais pas si cela est nécessairement utile, mais il n'est pas possible d'implémenter un comparateur générique significatif.
Grâce à l'interface de réflexion, vous pouvez, par exemple, classer les objets par leur nom de classe. Ou peut-être même d'une certaine manière par leur hiérarchie de classe. Les enfants après les parents, par exemple.
Ou vous pouvez les trier en fonction de ce que produit leur méthode toString (). Ou hashCode (). Chaque objet les a, après tout.
Quoi que vous fassiez, n'oubliez pas de considérer que l'un ou l'autre élément peut être nul.
Je pense que nous devons savoir pourquoi vous avez besoin de ce comparateur générique.