Pourquoi java.util.ArrayList permet-il d’ajouter null?

Je me demande pourquoi java.util.ArrayListpermet d'ajouter null. Y a-t-il un cas où je voudrais ajouter nullà un ArrayList?

Je pose cette question parce que dans un projet, nous avions un bogue qui ajoutait du code nullà la ArrayListet il était difficile de localiser la bogue. De toute évidence, un a NullPointerExceptionété lancé, mais pas avant qu'un autre code ait tenté d'accéder à l'élément. Le problème était de savoir comment localiser le code qui a ajouté l' nullobjet. Il aurait été plus facile de ArrayListcréer une exception dans le code où les éléments étaient ajoutés.

Cette décision de conception semble principalement motivée par le nommage.

Name ArrayList suggère au lecteur une fonctionnalité similaire à celle des tableaux - et il est naturel que les concepteurs de Java Collections Framework s’attendent à ce que la grande majorité des utilisateurs d’API s’en remettent à fonctionner de la même manière que les tableaux.

Cela implique notamment le traitement des éléments nuls. L'utilisateur de l'API sachant que ci-dessous fonctionne correctement:

array[0] = null; // NPE won't happen here

serait assez surpris de savoir si un code similaire pour ArrayList lancerait NPE:

arrayList.set(0, null); // NPE => WTF?

Le raisonnement comme ci-dessus est présenté dans les points de contrainte du didacticiel JCF qui suggèrent une similarité étroite entre ArrayList et les tableaux simples:

ArrayList ... offre un accès positionnel à temps constant et est tout simplement rapide ...

Si vous souhaitez qu'une implémentation de la liste n'autorise pas les valeurs NULL, mieux vaut l'appeler de la sorte NonNullableArrayListou quelque chose du genre, afin d'éviter toute confusion chez les utilisateurs d'API.

Note secondaire, il y a une discussion auxiliaire dans les commentaires ci-dessous, avec des considérations supplémentaires à l' appui du raisonnement exposé ici.

Null peut être une valeur valide pour un élément d'une liste. Supposons que votre liste contienne des éléments qui représentent des données optionnelles sur une liste d'utilisateurs et sont stockés dans le même ordre que les utilisateurs. Si les données supplémentaires sont renseignées, votre liste contiendra les données supplémentaires, sinon l'emplacement correspondant à un utilisateur sera nul. (Je suis sûr qu'il y a de meilleurs exemples, mais vous voyez l'idée)

Si vous ne souhaitez pas autoriser l'ajout de valeurs NULL, vous pouvez envelopper la liste de tableaux avec votre propre wrapper qui indique que la valeur null a été ajoutée.

ArrayListautorise null par conception. C'est intentionnel. Du javadoc :

"[ArrayList est] une implémentation de tableau redimensionnable de l'interface List. Implémente toutes les opérations de liste facultatives et autorise tous les éléments, y compris null ."

La réponse à "pourquoi" est que si ce n'était pas le cas, ArrayList ne serait pas utilisable dans les cas où il est nécessaire de mettre un nulldans la liste. En revanche, vous pouvez empêcher un ArrayList de contenir des valeurs NULL en testant les valeurs avant de les ajouter ou en utilisant un wrapper qui empêche cela de se produire.

Y a-t-il un cas où je voudrais ajouter null à un ArrayList?

De toute évidence, tout cas où nulla une signification distincte. Par exemple, cela peut signifier que la valeur à une position donnée de la liste n’a pas été initialisée ni fournie.

Cela aurait été plus facile si ArrayList avait généré une exception dans le code dans lequel les éléments étaient ajoutés.

Vous pouvez facilement implémenter ce comportement en créant une classe wrapper. Cependant, ce n'est pas le comportement que la plupart des programmeurs / applications ont besoin.

Y a-t-il un cas où je voudrais ajouter null à un ArrayList?

Bien sûr, qu'en est-il de la pré-allocation? Vous voulez une ArrayListchose que vous ne pouvez pas créer encore parce que vous n'avez pas assez d'informations. Ce n'est pas parce que vous ne pouvez imaginer une raison pour laquelle quelqu'un pourrait vouloir faire quelque chose que ce ne soit pas une mauvaise idée. Peu importe. (Maintenant, je suis sûr que quelqu'un va venir et dire que vous devriez plutôt avoir des objets vides qui correspondent à certains motifs sur lesquels ils ont lu sur un blog obscur et que les programmeurs devraient vraiment être capables d'écrire des programmes sans jamais utiliser d' ifinstructions, blah blah.)

Si vous avez un contrat qui ne devrait jamais figurer nulldans un conteneur, il vous appartient de vous assurer que ce contrat est respecté, probablement de manière plus appropriée en affirmant. Cela vous aurait probablement pris au maximum 10 lignes de code. Java vous simplifie incroyablement la tâche. Le JDK ne peut pas lire dans vos pensées.

Cela semble être davantage une question philosophique (logicielle) ici.

ArrayList en tant que classe d’utilité est conçu pour être utile dans un large contexte de cas d’utilisation possibles.

Contrairement à votre affirmation cachée selon laquelle l'acceptation de null en tant que valeur valide devrait être découragée, il existe de nombreux exemples dans lesquels la valeur null est parfaitement légale.

La raison la plus importante est que nullest l' do not knowéquivalent de tout type de référence, y compris les types de cadres. Cela implique que null ne peut en aucun cas être remplacé par une version plus fluide de la nothingvaleur.

Supposons donc que vous stockiez les entiers 1, 3, 7 dans votre arraylist à son index correspondant: En raison de certains calculs, vous voulez obtenir l'élément à l'index 5, votre tableau devrait donc renvoyer: "aucune valeur stockée". Cela pourrait être réalisé en renvoyant null ou un NullObject . Dans la plupart des cas, renvoyer la valeur null intégrée est suffisamment expressif. Après avoir appelé une méthode pouvant renvoyer null et utiliser sa valeur renvoyée, une vérification de la valeur renvoyée par rapport à null est assez courante dans le code moderne.

La déclaration

File f = null;

est valable et utile (je ne pense pas avoir besoin d'expliquer pourquoi). Il est également utile d’avoir une collection de fichiers dont certains peuvent être nuls.

List<File> files = new ArrayList<File>();
// use my collection of files
// ....
// not using this one anymore:
files.set(3, null);

L'utilité des collections pouvant contenir des objets nuls découle directement de l'utilité des objets pouvant être nuls. C'est vraiment aussi simple que ça.

Il est plus facile de tout accepter que d’être restrictif, puis d’essayer d’ouvrir votre projet après coup.

Par exemple, si Oracle / Sun fournissait uniquement NonNullableArrayList, mais que vous souhaitiez pouvoir ajouter un Null à votre liste. Comment le ferais-tu? Vous auriez probablement à créer un objet entièrement différent, vous ne pourriez pas utiliser une extension de NonNullableArrayList. Au lieu de cela, si vous avez un ArrayList qui prend tout, vous pouvez facilement l'étendre et redéfinir l'ajout s'il n'accepte pas les valeurs NULL.

Utilité de null?

Cela est tout à fait le cas lorsque vous utilisez une liste de listes pour modéliser une plaque 2D réelle avec différentes positions. La moitié de ces positions peuvent être vides (en coordonnées aléatoires), tandis que celles remplies ne représentent pas un simple int ou String, mais sont représentées par un objet complexe. Si vous souhaitez conserver les informations de position, vous devez remplir les zones vides avec null pour que votre liste.get (x) .get (y)ne conduit pas à de mauvaises surprises. Pour contrer les exceptions nulles, vous pouvez rechercher la valeur null (très populaire) ou utiliser une option (que je trouve pratique dans ce cas). L’alternative serait de remplir les espaces vides avec des objets «indésirables» qui peuvent causer toutes sortes de dégâts sur la route. Si votre contrôle nul échoue ou est oublié quelque part, Java vous le fera savoir. D'autre part, un objet de substitution "indésirable" mal contrôlé peut passer inaperçu.