Que faire avec des champs null dans compare()?

En Java, j'utilise une classe dans laquelle certains champs peuvent être null. Par exemple:

class Foo {
    String bar;
    //....
}

Je veux écrire un BarComparator pour cette classe,

    private static class BarComparator
            implements Comparator<Foo> {
        public int compare( final Foo o1, final Foo o2 )
        {
            //Implementation goes here
        }
    }

Est-il un standard moyen de composer avec le fait que l'un des o1, o2, o1.bar, o2.bar peut être null, sans écrit beaucoup de imbriquée if...else?

Cheers!

InformationsquelleAutor Sébastien RoccaSerra | 2008-09-24

36

Je suppose que vous pourriez placer l'appel le champ méthode compareTo avec une petite méthode statique pour trier les valeurs null haute ou basse:
```
static <T extends Comparable<T>> int cp(T a, T b) {
     return
         a==null ?
         (b==null ? 0 : Integer.MIN_VALUE) :
         (b==null ? Integer.MAX_VALUE : a.compareTo(b));
}
```
Simple d'utilisation (plusieurs champs est comme vous le feriez normalement):
```
public int compare( final Foo o1, final Foo o2 ) {
    return cp(o1.field, o2.field);
}
```
- Hors sujet je sais, mais quelle est la raison de préférer MIN/MAX_VALUE sur -/+ 1?
- Désolé pour le retard à répondre. C'est pour nous assurer d'avoir le triangle de l'inégalité. Pour a > b > c, une.compareTo(b) + b.compareTo(c) <= un.compareTo(c). Non pas que ça...
- Encore pouvez jeter un NullPointerException, si o1/o2 est null. Comment devez-vous traiter o1/o2 nul? OP mentionné : o1, o2, o1.bar, o2.la barre peut être null. Ou est la partie d'un comparateur de contrat: comparaison entre les valeurs null devriez jeter un NPE?
- peut lancer une NPE avec null arguments. Il est généralement préférable de prendre toutes les fausses valeurs null, ou toute autre forme illégale d'argument, le plus tôt possible (bien que je ne la remarque à la question d'origine, fait mention de o1 et o2 peut être null).
InformationsquelleAutor Tom Hawtin - tackline

Merci pour les réponses! La méthode générique et le Google Comparateurs intéressante.

Et j'ai trouvé qu'il y a un NullComparator dans le Apache Commons Collections (que nous utilisons actuellement):

private static class BarComparator
        implements Comparator<Foo>
{
    public int compare( final Foo o1, final Foo o2 )
    {
        //o1.bar & o2.bar nulleness is taken care of by the NullComparator.
        //Easy to extend to more fields.
        return NULL_COMPARATOR.compare(o1.bar, o2.bar);
    }

    private final static NullComparator NULL_COMPARATOR =
                                            new NullComparator(false);
}

Note: je me suis concentré sur le bar champ ici pour en garder pour le moment.

Il semble que le lien vers la documentation Javadoc est mort. Il est maintenant situé à commons.apache.org/proper/commons-collections/javadocs/... .

InformationsquelleAutor Sébastien RoccaSerra

6

Cela dépend si vous considérez une valeur null à une valeur valide de la chaîne de valeur de comparaison. est null < ou > "apple". La seule chose que je pouvais dire pour sûr, c'est que null == null. Si vous pouvez définir l'endroit où la valeur null s'inscrit dans la commande, puis vous pouvez écrire le code en conséquence.

Dans ce cas je peut choisir de jeter un NullPointerExcpetion ou IllegalArgumentException et essayer de gérer la valeur null à un niveau supérieur en ne mettant pas dans la comparaison de la première place.
- J'aime cette réponse. Merci!
InformationsquelleAutor Matt

Vous pouvez écrire votre Comparateur pour elle. Disons que vous avez une Personne de la classe avec la Chaîne de nom de domaine privé. getName() et setName() la méthode pour accéder au champ nom. Ci-dessous est le Comparateur de Personne de la classe.

    Collections.sort(list, new Comparator<Person>() {
        @Override
        public int compare(Person a, Person b) {
            if (a == null) {
                if (b == null) {
                    return 0;
                }
                return -1;
            } else if (b == null) {
                return 1;
            }
            return a.getName().compareTo(b.getName());
        }
    });

Mise à jour:

De Java 8, vous pouvez utiliser au-dessous de l'API pour la Liste.

//Push nulls at the end of List
Collections.sort(subjects1, Comparator.nullsLast(String::compareTo));

//Push nulls at the beginning of List
Collections.sort(subjects1, Comparator.nullsFirst(String::compareTo));

InformationsquelleAutor savanibharat

2

Le point clé ici est de travailler sur la façon dont vous souhaitez les valeurs null pour être traités. Certaines options sont les suivantes: a) assumer les valeurs null venir avant tous les autres objets dans l'ordre de tri b) assumer les valeurs null venir après tous les autres objets dans l'ordre de tri c) traiter null comme l'équivalent de quelque valeur par défaut d) traiter les valeurs null comme des conditions d'erreur. Celui que vous choisissez dépend entièrement de l'application sur laquelle vous travaillez.

Dans le dernier cas, bien sûr, vous lancer une exception. Pour les autres, vous avez besoin d'un four-way si/d'autre cas (environ trois minutes de codage que vous avez travaillé hors de ce que vous voulez que les résultats soient).

InformationsquelleAutor DJClayworth
2

Si vous utilisez Google collections, vous pouvez trouver le Les comparateurs classe utile. Si a méthodes d'aide pour commander les valeurs null comme le plus ou moins d'éléments dans la collection. Vous pouvez utiliser composé de comparaison pour aider à réduire la quantité de code.

InformationsquelleAutor Gregg

Il y a aussi la classe org.springframework.util.comparator.NullSafeComparator dans le Cadre du Printemps, vous pouvez utiliser.

Exemple (Java 8):

SortedSet<Foo> foos = new TreeSet<>( ( o1, o2 ) -> {
        return new NullSafeComparator<>( String::compareTo, true ).compare( o1.getBar(), o2.getBar() );
    } );

    foos.add( new Foo(null) );
    foos.add( new Foo("zzz") );
    foos.add( new Foo("aaa") );

    foos.stream().forEach( System.out::println );

Ce sera d'impression:

Foo{bar='null'}
Foo{bar='aaa'}
Foo{bar='zzz'}

InformationsquelleAutor Wim Deblauwe

1

Il me semble qu'il n'y a pas une méthode pour le faire, mais de toute façon le code n'est pas si long.

InformationsquelleAutor Enrico Murru
1

Vous ne devez pas utiliser le NullComparator la façon dont vous faites - vous êtes en train de créer une nouvelle instance de la classe pour chaque opération de comparaison, et si par exemple vous êtes le tri d'une liste avec 1000 entrées, qui sera 1000 * log2(1000) des objets qui sont tout à fait superflue. Cela permet d'obtenir rapidement problématique.

Soit sous-classe, ou de lui déléguer, ou tout simplement mettre en place votre propre null check - ce n'est pas vraiment complexe:
```
private static class BarComparator
        implements Comparator<Foo> {
    private NullComparator delegate = new NullComparator(false);

    public int compare( final Foo o1, final Foo o2 )
    {
        return delegate.compare(o1.bar, o2.bar);
    }
}
```
- Vous avez raison, la NullComparator devrait être privé de champ statique. Je l'ai écrit de cette façon dans l'exemple de garder le focus sur la nullité.
InformationsquelleAutor Martin Probst

Considérer le Client comme un POJO.Ma réponse serait :

Comparator<Customer> compareCustomer = Comparator.nullsLast((c1,c2) -> c1.getCustomerId().compareTo(c2.getCustomerId()));

Comparator<Customer> compareByName = Comparator.comparing(Customer::getName,nullsLast(String::compareTo));

La deuxième ligne est réellement bon.

InformationsquelleAutor Mr.Koçak

Je pense que début de retour des déclarations serait l'autre alternative à beaucoup de fi

par exemple

if(o1==null) return x;
if(o2==null) return x;
if(o1.getBar()==null) return x;
if(o2.getBar()==null) return x;

//No null checks needed from this point.

InformationsquelleAutor cagcowboy

Vous devez vous connecter pour publier un commentaire.