Meilleure pratique pour valider une collection nulle et vide en Java

Je veux vérifier si une collection est vide et null. Quelqu'un pourrait-il me faire part de la meilleure pratique?

Actuellement, je vérifie comme ci-dessous:

if (null == sampleMap || sampleMap.isEmpty()) {
  // do something
} 
else {
  // do something else
}

Si vous utilisez la bibliothèque Apache Commons Collections dans votre projet, vous pouvez utiliser les méthodes CollectionUtils.isEmptyet MapUtils.isEmpty()qui vérifient respectivement si une collection ou une carte est vide ou nulle (c'est-à-dire qu'elles sont "null-safe").

Le code derrière ces méthodes est plus ou moins ce que l'utilisateur @icza a écrit dans sa réponse.

Peu importe ce que vous faites, n'oubliez pas que moins vous écrivez de code, moins vous devez tester de code à mesure que la complexité de votre code diminue.

C'est le meilleur moyen de le vérifier. Vous pouvez écrire une méthode d'aide pour le faire:

public static boolean isNullOrEmpty( final Collection< ? > c ) {
    return c == null || c.isEmpty();
}

public static boolean isNullOrEmpty( final Map< ?, ? > m ) {
    return m == null || m.isEmpty();
}

Si vous utilisez des frameworks Spring, vous pouvez utiliser CollectionUtilspour vérifier à la fois les collections (liste, tableau) et la carte, etc.

if(CollectionUtils.isEmpty(...)) {...}

Personnellement, je préfère utiliser des collections vides au lieu de nullet faire fonctionner les algorithmes de telle sorte que pour l'algorithme, peu importe si la collection est vide ou non.

Lorsque vous utilisez le printemps, vous pouvez utiliser

boolean isNullOrEmpty = org.springframework.util.ObjectUtils.isEmpty(obj);

où obj est n'importe quel [carte, collection, tableau, aything ...]

sinon: le code est:

public static boolean isEmpty(Object[] array) {
    return (array == null || array.length == 0);
}

public static boolean isEmpty(Object obj) {
    if (obj == null) {
        return true;
    }

    if (obj.getClass().isArray()) {
        return Array.getLength(obj) == 0;
    }
    if (obj instanceof CharSequence) {
        return ((CharSequence) obj).length() == 0;
    }
    if (obj instanceof Collection) {
        return ((Collection) obj).isEmpty();
    }
    if (obj instanceof Map) {
        return ((Map) obj).isEmpty();
    }

    // else
    return false;
}

pour String best est:

boolean isNullOrEmpty = (str==null || str.trim().isEmpty());

Si vous devez vérifier la valeur null, c'est le chemin. Cependant, si vous avez le contrôle, renvoyez simplement la collection vide, chaque fois que vous le pouvez, et ne vérifiez que la collection vide plus tard.

Ce fil est à peu près la même chose avec C #, mais les principes s'appliquent également à java. Comme mentionné ici, null ne doit être retourné que si

• null pourrait signifier quelque chose de plus spécifique;
• votre API (contrat) peut vous forcer à retourner null.

Vous pouvez utiliser org.apache.commons.lang.Validatela méthode " notEmpty " de:

Validate.notEmpty(myCollection)-> Valider que la collection d'arguments spécifiée n'est ni nulle ni une taille de zéro (aucun élément); sinon lever une exception.

Nous vérifierons qu'un objet Collection est vide, nul ou non. ces toutes les méthodes qui sont données ci-dessous, sont présentes dans le package org.apache.commons.collections4.CollectionUtils.

Vérifier sur la liste ou définir le type d'objets de collection.

CollectionUtils.isEmpty(listObject);
CollectionUtils.isNotEmpty(listObject);

Vérifiez le type de carte des objets.

MapUtils.isEmpty(mapObject);
MapUtils.isNotEmpty(mapObject);

Le type de retour de toutes les méthodes est booléen.

Pour toutes les collections, y compris map use: isEmptymethod qui est là sur ces objets de collection. Mais vous devez faire une vérification nulle avant:

Map<String, String> map;

........
if(map!=null && !map.isEmpty())
......