Belle manière générale, pour trier les valeurs null pour le fond, peu importe?

Je suis en train d'écrire quelques éléments de comparaison, et je tiens à pousser null éléments vers le bas de la liste, indépendamment de savoir si je suis le tri croissant ou décroissant. Ce qui est une bonne stratégie ou de modèle pour cette approche?

Désinvolte:

Simplement écrire une ascendante et
descendant de comparaison, le partage de code
si possible
Déléguer la gestion des valeurs null à l'autre
de la classe, soit en les jetant un NPE ou
en appelant explicitement
Comprennent un croissant du drapeau et de mettre
la logique conditionnelle en elle pour naviguer
autour de les valeurs null
Envelopper régulière des comparateurs dans un
null-la manipulation de la classe

Autres stratégies? J'aimerais entendre des expériences avec des approches différentes, et tous les pièges pour les différentes stratégies.

OriginalL'auteur Carl Manaster | 2009-08-11

6

La dernière option m'attire beaucoup. Les comparateurs sont vraiment très bien à la chaîne. En particulier, vous pouvez bien voulez écrire un ReverseComparator ainsi que d'un NullWrappingComparator.

EDIT: Vous n'avez pas à écrire vous-même. Si vous regardez la La commande classe dans le Google Collections De La Bibliothèque vous trouverez cela et toutes sortes d'autres goodies 🙂

EDIT: Va dans les détails pour montrer ce que je veux dire, ReverseComparator ...

Un mot d'avertissement - dans la mise en œuvre d'un ReverseComparator, inverser l'ordre des arguments à la place de la négation de la raison, sinon Integer.MIN_VALUE est "inversée" à lui-même.

Donc cette mise en œuvre est faux (en supposant que original est le comparateur de reverse):
```
public int compare(T x, T y)
{
    return -original.compare(x, y);
}
```
mais cela est juste:
```
public int compare(T x, T y)
{
    return original.compare(y, x);
}
```
La raison en est que nous avons toujours envie de renverser la comparaison, mais si original.compare(x, y) retourne int.MIN_VALUE, puis la mauvaise comparer aura aussi retour int.MIN_VALUE, ce qui est incorrect. Cela est dû à la drôle de propriété que int.MIN_VALUE == -int.MIN_VALUE.

Je suis d'accord avec l'ensemble de vos réponse, sauf à propos niant le résultat d'une comparaison; je serais assez malheureux si j'ai découvert qu'un élément de Comparaison était la mise en œuvre de comparaison des entiers à l'aide de la soustraction, puisque cette méthode a de nombreux pièges.
Je pense que vous m'avez mal compris. Je vais modifier.
Je suis d'accepter cette réponse en raison de la référence à Google des Collections de la Commande de classe existantes éprouvées code est la meilleure solution. Aussi pour l'avertissement sur Entier.MIN_VALUE. Mais j'apprécie grandement @dfa code, ci-dessous, et souhaite que je pourrais accepter à la fois des réponses.

OriginalL'auteur Jon Skeet

Je suis d'accord avec Jon Skeet (c'est tellement facile :). J'ai essayé de mettre en œuvre très simple décorateur:

class NullComparators {

    static <T> Comparator<T> atEnd(final Comparator<T> comparator) {
        return new Comparator<T>() {

            public int compare(T o1, T o2) {
                if (o1 == null && o2 == null) {
                    return 0;
                }

                if (o1 == null) {
                    return 1;
                }

                if (o2 == null) {
                    return -1;
                }

                return comparator.compare(o1, o2);
            }
        };
    }

    static <T> Comparator<T> atBeginning(final Comparator<T> comparator) {
        return Collections.reverseOrder(atEnd(comparator));
    }
}

donné un élément de Comparaison:

Comparator<String> wrapMe = new Comparator<String>() {
      public int compare(String o1, String o2) {
          return o1.compareTo(o2);
      }
};

et des données de test:

List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null);

vous pouvez trier avec les valeurs null à la fin:

Collections.sort(strings, NullComparators.atEnd(wrapMe));

[aaa, bbb, ccc, null, null, null]

ou au début:

Collections.sort(strings, NullComparators.atBeginning(wrapMe));

[null, null, null, ccc, bbb aaa]

Très sympa! Je vous remercie. Est-il une raison pour ne pas retourner 0 si les deux arguments sont null? Je sais que le comportement null n'est pas tout à fait comme les non-null comportement, et que le fait de dire deux valeurs null sont égaux est discutable - mais est-il moins contestable de dire que l'un dépasse l'autre?
Exactement le point que je viens de faire sur ton post 🙂 Un Comparateur de doit return 0 ou lever une exception lorsqu'il est passé à deux les valeurs null, sinon, c'est désobéir à l'interface de contrat.

OriginalL'auteur dfa

Suivi tfd de réponse - ce que je veux, c'est que les valeurs null de tri à la fin, sans affecter l'ordre de la non-null. Donc je veux quelque chose de plus le long des lignes de cette:

public class NullComparatorsTest extends TestCase {
Comparator<String>  forward = new Comparator<String>() {
public int compare(String a, String b) {
return a.compareTo(b);
}
};
public void testIt() throws Exception {
List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null);
Collections.sort(strings, NullComparators.atEnd(forward));
assertEquals("[aaa, bbb, ccc, null, null, null]", strings.toString());
Collections.sort(strings, NullComparators.atBeginning(forward));
assertEquals("[null, null, null, aaa, bbb, ccc]", strings.toString());
}
}
public class NullComparators {
public static <T> Comparator<T> atEnd(final Comparator<T> comparator) {
return new Comparator<T>() {
public int compare(T a, T b) {
if (a == null && b == null)
return 0;
if (a == null)
return 1;
if (b == null)
return -1;
return comparator.compare(a, b);
}
};
}
public static <T> Comparator<T> atBeginning(final Comparator<T> comparator) {
return new Comparator<T>() {
public int compare(T a, T b) {
if (a == null && b == null)
return 0;
if (a == null)
return -1;
if (b == null)
return 1;
return comparator.compare(a, b);
}
};
}
}

Pleine de crédit à dfa, même si - c'est juste une modification mineure de son travail.

Un seul problème: vous n'avez pas de retour de 0 lorsque l'on compare les deux valeurs null.
Merci; édité avec la correction.

OriginalL'auteur Carl Manaster

3

Dans Java 8, vous pouvez utiliser le Comparateur.nullsLast et Comparateur.nullsFirst méthodes statiques pour avoir plus de null-amicale des comparateurs. Supposons que vous avez un Fruit classe comme suit:
```
public class Fruit {
private final String name;
private final Integer size;
//Constructor and Getters
}
```
Si vous souhaitez trier un tas de fruits, de par leur taille et de la mettre la nulls à la fin:
```
List<Fruit> fruits = asList(null, new Fruit("Orange", 25), new Fruit("Kiwi", 5));
```
Vous pouvez simplement écrire:
```
Collections.sort(fruits, Comparator.nullsLast(Comparator.comparingInt(Fruit::getSize)));
```
Et le résultat serait:
```
[Fruit{name='Kiwi', size=5}, Fruit{name='Orange', size=25}, null]
```
OriginalL'auteur Ali Dehghani
2

Vous pouvez toujours utiliser NullComparator de commons-collections. Il a été autour de plus que Google Collections.

OriginalL'auteur Tim R

Vous devez vous connecter pour publier un commentaire.